///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Copyright (c) 2017 Raytrix GmbH. All rights reserved. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// #pragma once #include "DLLInterface.h" #include "Rx.Interop.Runtime30/CameraProperties.h" #include "Rx.LF/ESpace.h" #include "Rx.Core.Dongle/RxDongle.Features.h" #include "Rx.Core/RxCalibMetaData.h" #include "Rx.Core.Ex/RxArrayString.h" #include "Rx.Core.Ex/RxArrayUInt.h" #include "Rx.Core.Ex/RxArrayDouble.h" #include "Rx.Core.Ex/RxMetaData.h" #include "Rx.Core.Ex/EValueType.h" ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // namespace: Rx.LFR ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// namespace Rx { namespace LFR { class CApiLF_Impl; ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// ApiLF. /// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// class RX_API CApiLF { public: ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Initialize the Raytrix API. /// /// /// 
			/// 	Before any light field images can be loaded, recorded or processed a CUDA device has to be chosen using the function
			/// 	Rx::LFR::CApiLF::RxCudaSelectDevice.To access Raytrix cameras you first have to call Rx::LFR::CApiLF::RxCamDriverInit and
			/// 	Rx::LFR::CApiLF::RxCamRegister.
			///
/// /// After executing Rx::LFR::CApiLF::RxInit neither a CUDA device is selected nor a camera device initialized. /// /// (Optional) If set to false only functionality that does not rely on CUDA can be used. /// (Optional) The absolute path to the camera driver DLLs (Rx.CameraNet.Type*.dll). /// (Optional) The absolute path to the camera calibration directories. /// [in,out] (Optional) Reserved. Must be zero. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxInit(bool bUseCUDA = true, const Rx::CRxString& sxLibPath = "", const Rx::CRxString& sxCalibPath = "", void* pvData = 0); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Close any open cameras and free all memory allocated on CUDA device and in host memory. /// /// /// /// Make sure to call this function before ending your program. Otherwise the CUDA device memory will fill up with repeated /// execution of the software. /// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxFinalize(); public: ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Gets the interface defined by the given interface ID. /// /// /// The interface ID. /// /// Null if it fails, else the interface. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void* GetInterface(Interfaces::EApiLF::ID eInterface); public: ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Registers a status message callback Function. This function will be called when a new Status Message is fired. /// /// /// The callback function. /// [in] A Context Pointer which is forwarded to the callback function call. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxAddStatusMessageHandler(Rx::LFR::TFuncStatusMsg pFunc, void* pvContext); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Removes a registered message callback function. /// /// /// The function. /// [in] If non-null, the context. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxRemoveStatusMessageHandler(Rx::LFR::TFuncStatusMsg pFunc, void* pvContext); public: ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Gets the release date of this version of the Raytrix Light Field Runtime. Can be called without initializing the API. /// /// /// [out] The release day. /// [out] The release month. /// [out] The release year. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxGetReleaseDate(int& iDay, int& iMonth, int& iYear); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Sets details about the application that uses this runtime currently. Saving a ray file will write this details into the /// meta data of the file. /// /// /// The application name. /// The application version. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxSetApplicationDetails(const Rx::CRxString& sxAppName, const Rx::CRxString& sxAppVersion); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Test whether the Dongle offers the given features. /// /// /// /// Not all functions of this API are necessarily available. This depends on the currently active license, which is defined /// by the Raytrix dongle attached to the system. To check whether a set of features is available you can OR the /// corresponding feature IDs. The feature IDs are available through defines all starting with /// Rx::Dongle::ERuntimeFeature::ID. For example, to test for the features multiview and 3D evaluation call: /// if(Rx::LFR::Net::ApiLF::RxHasFeature(Rx::Dongle::ERuntimeFeature::SDK | Rx::Dongle::ERuntimeFeature::RxLive)){...} /// /// /// A OR-ed list of Rx::Dongle::ERuntimeFeature::ID to check for availability. /// /// true if the feature is available, false otherwise. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static bool RxHasFeature(unsigned uFeatureIDs); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Test whether the Dongle offers a given feature. /// /// /// /// Not all functions of this API are necessarily available. This depends on the currently active license, which is defined /// by the Raytrix dongle attached to the system. /// /// /// The feature to check for availability. /// /// true if the feature is available, false otherwise. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static bool RxHasFeature(Rx::Dongle::ERuntimeFeature::ID eFeatureID); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Get the IDs of an attached dongle. /// /// /// [in] On return contains the hardware dongle ID. /// [in] On return contains the Raytrix dongle ID. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxDongleGetID(int& iDngID, int& iRxID); public: ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Returns the number of CUDA devices installed. /// /// /// The number of CUDA devices. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static int RxCudaDeviceCount(); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Get the name and the compute capability major and minor version for a CUDA device. /// /// /// Zero-based ID of the CUDA device. /// [out] On return contains the name of the CUDA device. /// [out] On return contains the major version of the CUDA device compute capability. /// [out] On return contains the minor version of the CUDA device compute capability. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxCudaDeviceProp(int iDevice, Rx::CRxString& sxName, unsigned& iCCMajor, unsigned& iCCMinor); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Select a CUDA device. /// /// /// /// This function must be called once and only once per process. The selected CUDA device cannot be changed during runtime. /// /// Use the functions Rx::LFR::CApiLF::RxCudaDeviceCount and Rx::LFR::CApiLF::RxCudaDeviceProp to obtain information about the /// installed CUDA devices and then select the most appropriate CUDA device with this function. If iDevice is set to -1, /// the first appropriate CUDA device is selected. /// /// To exchange image data generated by CUDA directly with an OpenGL rendering context on the same device, bUseGL has to be /// set to true and the CUDA device has to support OpenGL 3.0 or higher. Note that CUDA/DirectX interop. is currently not /// supported. /// /// For further details on CUDA/OpenGL interop. /// /// /// (Optional) The zero-based CUDA device ID or -1 for automatic selection. /// (Optional) Flag indicating whether to initialize CUDA for OpenGL interop. or not. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxCudaSelectDevice(int iDevice = -1, bool bUseGL = false); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Return free and total amount of memory on the selected CUDA device. /// /// /// [out] On return contains the amount of free memory in bytes. /// [out] On return contains the amount of total memory in bytes. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxCudaDeviceMemInfo(size_t& nFreeMem, size_t& nTotalMem); public: ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Register available cameras. /// /// This functions registers all cameras that are currently available. Only registered cameras can be used by the Raytrix /// API. This function can be called repeatedly to update the list of available cameras. This function has to be called /// after Rx::LFR::CApiLF::RxCamDriverInit and before any other API camera functions. /// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxCamRegister(); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Opens the given camera. Camera settings can only be accessed after a camera has been opened. The first call to open /// initializes the camera too. /// /// /// If initialization fails, an Rx::CRxException is thrown that holds the reason of failure. /// /// The zero-based index of the camera to open. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxCamOpen(unsigned uCamIdx); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Closes the given camera. If the given camera is currently bound, the camera is unbound before closing. Also, if the /// camera is in capture mode, the capturing is stopped before unbinding. /// /// /// The zero-based index of the camera to close. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxCamClose(unsigned uCamIdx); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Binds the given camera to the returned API image ID. Call RxCamUnBind to unbind the bound camera. Only one camera can /// be bound. Calling Rx::LFR::CApiLF::RxCamBind with another camera index results in an Rx::CRxException. /// /// /// /// The internal ray image with ID returned by this function is not deleted from memory when camera is unbound. It has to /// be deleted explicitly using Rx::LFR::CApiLF::RxRayDelete when it is no longer needed. /// /// /// Zero-based index of the camera. /// /// The ray image handle of the image into which camera images are captured. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static unsigned RxCamBind(unsigned uCamIdx); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Unbinds a currently bound camera. If the bound camera is still capturing images, the capturing is stopped and then the /// camera is unbound. /// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxCamUnbind(); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Prepares the currently bound camera for capturing images. If the currently bound camera is already in capture mode, /// then the function throws an exception. /// /// /// /// Calling this function does not actually capture any images but prepares the camera for capturing images.The /// function also reads the calibration data of the currently bound camera from the path set as sxCalibPath in /// Rx::LFR::CApiLF::RxInit. /// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxCamStartCapture(); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Stops capturing of the currently bound camera. If the camera is not in capture mode, the function simply returns /// without error. /// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxCamStopCapture(); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Suspend capturing images. /// /// This function stops the data transfer between camera and computer but keeps all other capture settings. /// /// /// True to suspend camera capture and false to restart camera capture. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxCamSuspendCapture(bool bSuspend); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Triggers capturing of a single image of the currently bound camera. The image can be retrieved by calling /// Rx::LFR::CApiLF::RxCamRetrieveImage. /// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxCamTrigger(); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Retrieve a single image from the currently bound camera. /// /// /// /// This function only returns after an image has been retrieved by the camera and is available on the CUDA device. The /// camera image is retrieved into the image referenced by the ray image handle returned by the function /// Rx::LFR::CApiLF::RxCamBind. It is also automatically copied onto the CUDA device, so that all processing of the light field /// image can be done purely on the CUDA device without repeated copying of the light-field image from host to device /// memory. /// /// /// true if an image was available, false otherwise. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static bool RxCamRetrieveImage(); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Register a callback function which is called when a new image is available. /// /// /// The callback function pointer. /// [in,out] The void pointer of the Context. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxCamRegisterImageCallback(Rx::LFR::TFuncImageCaptured pFunc, void* pvContext); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Remove the image callback function. /// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxCamRemoveImageCallback(); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Creates a new calibration database for bound camera. /// /// If a calibration database for this camera already exists, a new one will only be created if bForce is true Otherwise a /// Rx::CRxException is thrown. /// /// /// Flags whether to overwrite an existing database or not. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxCalibDBCreateDataBaseForBoundCamera(bool bForce); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Creates a new calibration database for camera with ID uCamIdx /// /// If a calibration database for this camera already exists, a new one will only be created if bForce is true. /// Otherwise a Rx::CRxException is thrown. /// /// /// Zero-based index of the camera. /// Flags whether to overwrite an existing database or not. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxCalibDBCreateDataBaseForCamera(unsigned uCamIdx, bool bForce); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Creates a new calibration database for camera with name sxCamHardwareId. /// /// /// /// If a calibration database for this camera already exists, a new one will only be created if bForce is true Otherwise a /// Rx::CRxException is thrown. /// /// /// Type of the camera. /// Flags whether to overwrite an existing database or not. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxCalibDBCreateDataBase(const Rx::CRxString& sxCamHardwareId, bool bForce); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Creates a new calibration and returns the GUID of the newly created calibration in sxNewGUID. /// /// /// [in] Unique identifier for the new calibration. /// Hardware id of the camera. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxCalibDBNewCalib(Rx::CRxString& sxNewGUID, const Rx::CRxString& sxCamHardwareId); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Creates a new calibration and returns the GUID of the newly created calibration in sxNewGUID. /// /// /// [in] Unique identifier for the new calibration. /// [in] id of a camera. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxCalibDBCameraNewCalib(Rx::CRxString& sxNewGUID, unsigned uCamIdx); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Creates a new calibration and returns the GUID of the newly created calibration in sxNewGUID. /// /// /// [in] Unique identifier for the new calibration. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxCalibDBBoundCameraNewCalib(Rx::CRxString& sxNewGUID); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Deletes camera calibration with GUID sxGUID /// /// /// If there is no calibration database for given parameters, an Rx::CRxException is thrown. /// /// The GUID of the calibration to delete. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxCalibDBDeleteCalib(const Rx::CRxString& sxGUID); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Applies the camera calibration defined by GUID sxGUID to the currently bound image in API. Also updates the /// computational class. /// /// /// GUID of the calibration which should be applied to bound image. /// If true, the current gray image is replaced by the one from the given calibration. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxCalibDBBindCalib(const Rx::CRxString& sxGUID, bool bApplyGrayImage); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Applies the currently bound camera calibration to the current bound image in API. Also updates to the computational /// class. /// /// /// 
 There must be a bound image before calling this function.
/// /// If true, the current gray image is replaced by the one from the given calibration. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxCalibDBReloadBoundCalib(bool bApplyGrayImage); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Gets (The camera calibration) from current bound image and saves it to the calibration defined by GUID sxGUID Also /// saves database to disk. /// /// /// 
 There must be a bound image before calling this function.
/// /// GUID of the calibration which should be saved. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxCalibDBUpdateAndSaveCalib(const Rx::CRxString& sxGUID); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Gets calibration (The camera calibration) from current bound image and saves it to current calibration. Also saves /// database to disk. /// /// /// 
 There must be a bound image before calling this function.
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxCalibDBUpdateAndSaveBoundCalib(); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Gets a Rx::CRxArrayString which contains GUIDs of all calibration on this computer. /// /// /// [out] Rx::CRxArrayString of GUIDS. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxCalibDBGetCompleteCalibGuidList(Rx::CRxArrayString& asxGUIDs); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Gets a Rx::CRxArrayString which contains unique IDs of all calibration for camera with given index uCamIdx. /// /// /// [out] Rx::CRxArrayString of GUIDs. /// Zero-based index of the camera. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxCalibDBGetCameraCalibGuidList(Rx::CRxArrayString& asxGUIDs, unsigned uCamIdx); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Gets a Rx::CRxArrayString which contains GUIDs of all master calibration on this computer. /// /// /// [out] Rx::CRxArrayString of GUIDS. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxCalibDBGetCompleteMasterCalibGuidList(Rx::CRxArrayString& asxGUIDs); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Gets a Rx::CRxString which contains the GUID of the master calibration of this camera. /// /// /// [out] Rx::CRxString of GUID. /// Zero-based index of the camera. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxCalibDBGetCameraMasterCalibGuid(Rx::CRxString& sxGUID, unsigned uCamIdx); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Gets Rx::CRxCalibMetaData for calibration with given GUID sxGUID. /// /// /// [out] The calibration data. /// The GUID of the calibration. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxCalibDBLoadCalibMetaData(Rx::CRxCalibMetaData& xCalibData, const Rx::CRxString& sxGUID); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Gets the last applied calibration data. /// /// /// [out] Information describing the calibration. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxCalibDBLoadBoundCalibMetaData(Rx::CRxCalibMetaData& xCalibData); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Sets Rx::CRxCalibMetaData for calibration with given GUID sxGUID. /// /// Only certain parameters will be considered. The GUID, camera serial and camera type cannot be set. /// /// /// The calibration data. /// The GUID of the calibration. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxCalibDBSaveCalibMetaData(const Rx::CRxCalibMetaData& xCalibData, const Rx::CRxString& sxGUID); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Sets calibration data to the last applied calibration. /// /// /// Information describing the calibration. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxCalibDBSaveBoundCalibMetaData(const Rx::CRxCalibMetaData& xCalibData); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Bind gray image of calibration to API and use this image as gray image too. Now you can calibrate a calibration without /// using a camera. /// /// This function returns the image ID of the bound gray image in uRayHandle. /// /// /// After using this image, you have to delete it to free the memory by calling Rx::LFR::CApiLF::RxRayDelete. /// /// [out] Image ID of the bound gray image. /// The GUID of the calibration. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxCalibDBBindCalibGrayImage(unsigned& uRayHandle, const Rx::CRxString& sxGUID); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Assign the gray image of the calibration with the given GUID to the bound calibration. This copies the gray image. /// /// /// The unique identifier of the calibration with the gray image to copy. /// true to load gray image. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxCalibDBAssignGrayImageToBoundCalib(const Rx::CRxString& sxGUID, bool bLoadGrayImg); public: ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Test whether a camera parameter is supported by the given camera. /// /// /// /// All camera and camera calibration parameters can be tested with this function. Use this function to test whether /// certain parameters are available or not. For example, the parameters: Rx::Interop::Runtime30::Camera::EProperty::Focus, Rx::Interop::Runtime30::Camera::EProperty::Iris, /// Rx::Interop::Runtime30::Camera::EProperty::Func_CalibMainLens are only available if a camera is attached that allows the direct control of the /// main lens. /// /// /// The camera parameter ID. /// The camera index. /// /// True if the parameter is supported, otherwise false. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static bool RxCamIsParameterSupported(Rx::Interop::Runtime30::Camera::EProperty::ID ePar, unsigned uCamIdx); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Test whether a camera parameter is supported by the currently bound camera. /// /// /// /// All camera and camera calibration parameters can be tested with this function. Use this function to test whether /// certain parameters are available or not. For example, the parameters: Rx::Interop::Runtime30::Camera::EProperty::Focus, Rx::Interop::Runtime30::Camera::EProperty::Iris, /// Rx::Interop::Runtime30::Camera::EProperty::Func_CalibMainLens are only available if a camera is attached that allows the direct control of the /// main lens. /// /// /// The camera parameter. /// /// True if the parameter is supported, otherwise false. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static bool RxCamIsParameterSupported(Rx::Interop::Runtime30::Camera::EProperty::ID ePar); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Get a camera parameter of type Rx::CRxString. /// /// /// Not all parameters may be supported by all Raytrix cameras. /// /// /// If the parameter referenced by ePar does not relate to a string parameter a Rx::CRxException is thrown. /// /// /// The zero-based camera index. /// The camera parameter. Allowed parameters from Rx::Interop::Runtime30::Camera::EProperty are: /// - Rx::Interop::Runtime30::Camera::EProperty::DriverName /// - Rx::Interop::Runtime30::Camera::EProperty::RaytrixModelName /// - Rx::Interop::Runtime30::Camera::EProperty::InternalModelName /// - Rx::Interop::Runtime30::Camera::EProperty::HardwareId /// - Rx::Interop::Runtime30::Camera::EProperty::Serial /// - Rx::Interop::Runtime30::Camera::EProperty::TapBalanceMode /// - Rx::Interop::Runtime30::Camera::EProperty::SourceImageFolder. /// [out] The returned string value. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxCamGetPar(unsigned uCamIdx, Rx::Interop::Runtime30::Camera::EProperty::ID ePar, Rx::CRxString& sxValue); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Get a camera parameter of type unsigned integer. /// /// /// Not all parameters may be supported by all Raytrix cameras. /// /// /// If the parameter referenced by ePar does not relate to an unsigned integer parameter an Rx::CRxException is /// thrown. /// /// /// The zero-based camera index. /// The camera parameter ID. Allowed parameters from Rx::Interop::Runtime30::Camera::EProperty are: /// - Camera /// - Rx::Interop::Runtime30::Camera::EProperty::IsColor /// - Rx::Interop::Runtime30::Camera::EProperty::IsBayer /// - Rx::Interop::Runtime30::Camera::EProperty::Width /// - Rx::Interop::Runtime30::Camera::EProperty::Height /// - Rx::Interop::Runtime30::Camera::EProperty::OffsetX /// - Rx::Interop::Runtime30::Camera::EProperty::OffsetY /// - Rx::Interop::Runtime30::Camera::EProperty::Func_CalibMainLens /// - Rx::Interop::Runtime30::Camera::EProperty::PIVMode /// - Rx::Interop::Runtime30::Camera::EProperty::IsOpen /// - Rx::Interop::Runtime30::Camera::EProperty::IsCapturing /// - Rx::Interop::Runtime30::Camera::EProperty::TriggerMode /// - Rx::Interop::Runtime30::Camera::EProperty::ExternalTriggerMode /// - Rx::Interop::Runtime30::Camera::EProperty::HasIPConfig /// - Rx::Interop::Runtime30::Camera::EProperty::GlobalStart /// - Rx::Interop::Runtime30::Camera::EProperty::StrobeOn /// [out] The returned unsigned integer value. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxCamGetPar(unsigned uCamIdx, Rx::Interop::Runtime30::Camera::EProperty::ID ePar, unsigned& uValue); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Get camera parameter of type double /// /// /// Not all parameters may be supported by all Raytrix cameras. /// /// /// If the parameter referenced by ePar does not relate to an double parameter an Rx::CRxException is thrown. /// /// /// The zero-based camera index. /// The camera parameter. Allowed parameters from Rx::Interop::Runtime30::Camera::EProperty are: /// - Camera /// - Rx::Interop::Runtime30::Camera::EProperty::Exposure /// - Rx::Interop::Runtime30::Camera::EProperty::TapBalance /// - Rx::Interop::Runtime30::Camera::EProperty::Gain /// - Rx::Interop::Runtime30::Camera::EProperty::GainRed /// - Rx::Interop::Runtime30::Camera::EProperty::GainGreen /// - Rx::Interop::Runtime30::Camera::EProperty::GainBlue /// - Rx::Interop::Runtime30::Camera::EProperty::FramesPerSecond /// - Rx::Interop::Runtime30::Camera::EProperty::ActualFramesPerSecond /// - Rx::Interop::Runtime30::Camera::EProperty::Focus /// - Rx::Interop::Runtime30::Camera::EProperty::Iris /// - Rx::Interop::Runtime30::Camera::EProperty::Temperature /// - Rx::Interop::Runtime30::Camera::EProperty::StrobeLength1 /// - Rx::Interop::Runtime30::Camera::EProperty::StrobeLength2 /// - Rx::Interop::Runtime30::Camera::EProperty::StrobeDelay1 /// - Rx::Interop::Runtime30::Camera::EProperty::StrobeDelay2 /// [out] The returned double value. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxCamGetPar(unsigned uCamIdx, Rx::Interop::Runtime30::Camera::EProperty::ID ePar, double& dValue); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Get camera parameter of type Rx::CRxArrayString. /// /// /// Not all parameters may be supported by all Raytrix cameras. /// /// /// If the parameter referenced by ePar does not relate to a string-array parameter an Rx::CRxException is thrown. /// /// /// The zero-based camera index. /// The camera parameter. /// [out] The returned value. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxCamGetPar(unsigned uCamIdx, Rx::Interop::Runtime30::Camera::EProperty::ID ePar, Rx::CRxArrayString& aValue); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Get a camera parameter of type Rx::CRxString from the currently bound camera. /// /// /// Not all parameters may be supported by all Raytrix cameras. /// /// /// If the parameter referenced by ePar does not relate to a string parameter an Rx::CRxException is /// thrown. /// /// /// The camera parameter. Allowed parameters from Rx::Interop::Runtime30::Camera::EProperty are: /// - Rx::Interop::Runtime30::Camera::EProperty::DriverName /// - Rx::Interop::Runtime30::Camera::EProperty::RaytrixModelName /// - Rx::Interop::Runtime30::Camera::EProperty::InternalModelName /// - Rx::Interop::Runtime30::Camera::EProperty::HardwareId /// - Rx::Interop::Runtime30::Camera::EProperty::Serial /// - Rx::Interop::Runtime30::Camera::EProperty::TapBalanceMode /// - Rx::Interop::Runtime30::Camera::EProperty::SourceImageFolder. /// [out] The returned string value. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxCamGetPar(Rx::Interop::Runtime30::Camera::EProperty::ID ePar, Rx::CRxString& sxValue); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Get a camera parameter of type unsigned integer from the currently bound camera. /// /// /// Not all parameters may be supported by all Raytrix cameras. /// /// /// If the parameter referenced by ePar does not relate to an unsigned integer parameter anRx::CRxException is /// thrown. /// /// /// The camera parameter. Allowed parameters from Rx::Interop::Runtime30::Camera::EProperty are: /// - Rx::Interop::Runtime30::Camera::EProperty::IsColor /// - Rx::Interop::Runtime30::Camera::EProperty::IsBayer /// - Rx::Interop::Runtime30::Camera::EProperty::Width /// - Rx::Interop::Runtime30::Camera::EProperty::Height /// - Rx::Interop::Runtime30::Camera::EProperty::OffsetX /// - Rx::Interop::Runtime30::Camera::EProperty::OffsetY /// - Rx::Interop::Runtime30::Camera::EProperty::Func_CalibMainLens /// - Rx::Interop::Runtime30::Camera::EProperty::PIVMode /// - Rx::Interop::Runtime30::Camera::EProperty::IsOpen /// - Rx::Interop::Runtime30::Camera::EProperty::IsCapturing /// - Rx::Interop::Runtime30::Camera::EProperty::TriggerMode /// - Rx::Interop::Runtime30::Camera::EProperty::ExternalTriggerMode. /// - Rx::Interop::Runtime30::Camera::EProperty::HasIPConfig /// - Rx::Interop::Runtime30::Camera::EProperty::GlobalStart /// - Rx::Interop::Runtime30::Camera::EProperty::StrobeOn /// [out] The returned unsigned integer value. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxCamGetPar(Rx::Interop::Runtime30::Camera::EProperty::ID ePar, unsigned& uValue); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Get camera parameter of type double from the currently bound camera. /// /// /// Not all parameters may be supported by all Raytrix cameras. /// /// /// If the parameter referenced by ePar does not relate to an double parameter an Rx::CRxException is thrown. /// thrown. /// /// /// The camera parameter ID. Allowed parameters from Rx::Interop::Runtime30::Camera::EProperty are: /// - Camera /// - Rx::Interop::Runtime30::Camera::EProperty::Exposure /// - Rx::Interop::Runtime30::Camera::EProperty::TapBalance /// - Rx::Interop::Runtime30::Camera::EProperty::Gain /// - Rx::Interop::Runtime30::Camera::EProperty::GainRed /// - Rx::Interop::Runtime30::Camera::EProperty::GainGreen /// - Rx::Interop::Runtime30::Camera::EProperty::GainBlue /// - Rx::Interop::Runtime30::Camera::EProperty::FramesPerSecond /// - Rx::Interop::Runtime30::Camera::EProperty::ActualFramesPerSecond /// - Rx::Interop::Runtime30::Camera::EProperty::Focus /// - Rx::Interop::Runtime30::Camera::EProperty::Iris /// - Rx::Interop::Runtime30::Camera::EProperty::Temperature. /// - Rx::Interop::Runtime30::Camera::EProperty::StrobeLength1 /// - Rx::Interop::Runtime30::Camera::EProperty::StrobeLength2 /// - Rx::Interop::Runtime30::Camera::EProperty::StrobeDelay1 /// - Rx::Interop::Runtime30::Camera::EProperty::StrobeDelay2 /// [out] The returned double value. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxCamGetPar(Rx::Interop::Runtime30::Camera::EProperty::ID ePar, double& dValue); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Get camera parameter of type Rx::CRxArrayString. /// /// /// Not all parameters may be supported by all Raytrix cameras. /// /// /// If the parameter referenced by ePar does not relate to an string-array parameter an Rx::CRxException is /// thrown. /// /// /// The camera parameter. /// [out] The returned Rx::CRxArrayString value. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxCamGetPar(Rx::Interop::Runtime30::Camera::EProperty::ID ePar, Rx::CRxArrayString& aValue); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Set a camera property of type Rx::CRxString. /// /// /// Not all parameters may be supported by all Raytrix cameras. /// /// /// If the parameter referenced by ePar does not relate to an unsigned integer parameter an Rx::CRxException is /// thrown. /// /// /// The zero-based camera index. /// The camera parameter. Allowed parameters from Rx::Interop::Runtime30::Camera::EProperty are: /// - Camera /// - Rx::Interop::Runtime30::Camera::EProperty::TapBalanceMode /// - Rx::Interop::Runtime30::Camera::EProperty::SourceImageFolder. /// The string value. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxCamSetPar(unsigned uCamIdx, Rx::Interop::Runtime30::Camera::EProperty::ID ePar, const Rx::CRxString& sxValue); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Set a camera property of type unsigned integer. /// /// /// Not all parameters may be supported by all Raytrix cameras. /// /// /// If the parameter referenced by \a ePar does not relate to an unsigned integer parameter an Rx::CRxException /// is thrown. /// /// /// The zero-based camera index. /// The camera parameter. Allowed parameters from Rx::Interop::Runtime30::Camera::EProperty are: /// - Camera /// - Rx::Interop::Runtime30::Camera::EProperty::Func_CalibMainLens /// - Rx::Interop::Runtime30::Camera::EProperty::PIVMode /// - Rx::Interop::Runtime30::Camera::EProperty::TriggerMode /// - Rx::Interop::Runtime30::Camera::EProperty::ExternalTriggerMode /// - Rx::Interop::Runtime30::Camera::EProperty::GlobalStart /// - Rx::Interop::Runtime30::Camera::EProperty::StrobeOn /// The unsigned integer value. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxCamSetPar(unsigned uCamIdx, Rx::Interop::Runtime30::Camera::EProperty::ID ePar, unsigned uValue); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Set a camera property of type double. /// /// /// Not all parameters may be supported by all Raytrix cameras. /// /// /// If the parameter referenced by ePar does not relate to an double parameter an Rx::CRxException is thrown. /// /// /// The zero-based camera index. /// The camera parameter. Allowed parameters from Rx::Interop::Runtime30::Camera::EProperty are: /// - Camera /// - Rx::Interop::Runtime30::Camera::EProperty::Exposure /// - Rx::Interop::Runtime30::Camera::EProperty::TapBalance /// - Rx::Interop::Runtime30::Camera::EProperty::Gain /// - Rx::Interop::Runtime30::Camera::EProperty::GainRed /// - Rx::Interop::Runtime30::Camera::EProperty::GainGreen /// - Rx::Interop::Runtime30::Camera::EProperty::GainBlue /// - Rx::Interop::Runtime30::Camera::EProperty::FramesPerSecond /// - Rx::Interop::Runtime30::Camera::EProperty::Focus /// - Rx::Interop::Runtime30::Camera::EProperty::Iris /// - Rx::Interop::Runtime30::Camera::EProperty::StrobeLength1 /// - Rx::Interop::Runtime30::Camera::EProperty::StrobeLength2 /// - Rx::Interop::Runtime30::Camera::EProperty::StrobeDelay1 /// - Rx::Interop::Runtime30::Camera::EProperty::StrobeDelay2 /// The double value. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxCamSetPar(unsigned uCamIdx, Rx::Interop::Runtime30::Camera::EProperty::ID ePar, double dValue); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Set a camera property of type Rx::CRxString from the currently bound camera. /// /// /// Not all parameters may be supported by all Raytrix cameras. /// /// /// If the parameter referenced by \a ePar does not relate to an unsigned integer parameter an Rx::CRxException /// is thrown. /// /// /// The camera parameter. Allowed parameters from Rx::Interop::Runtime30::Camera::EProperty are: /// - Camera /// - Rx::Interop::Runtime30::Camera::EProperty::TapBalanceMode /// - Rx::Interop::Runtime30::Camera::EProperty::SourceImageFolder. /// The string value. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxCamSetPar(Rx::Interop::Runtime30::Camera::EProperty::ID ePar, const Rx::CRxString& sxValue); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Set a camera property of type unsigned integer from the currently bound camera. /// /// /// Not all parameters may be supported by all Raytrix cameras. /// /// /// If the parameter referenced by ePar does not relate to an unsigned integer parameter an Rx::CRxException is /// thrown. /// /// /// The camera parameter. Allowed parameters from Rx::Interop::Runtime30::Camera::EProperty are: /// - Camera /// - Rx::Interop::Runtime30::Camera::EProperty::Func_CalibMainLens /// - Rx::Interop::Runtime30::Camera::EProperty::PIVMode /// - Rx::Interop::Runtime30::Camera::EProperty::TriggerMode /// - Rx::Interop::Runtime30::Camera::EProperty::ExternalTriggerMode /// - Rx::Interop::Runtime30::Camera::EProperty::GlobalStart /// - Rx::Interop::Runtime30::Camera::EProperty::StrobeOn /// The unsigned integer value. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxCamSetPar(Rx::Interop::Runtime30::Camera::EProperty::ID ePar, unsigned uValue); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Set a camera property of type double /// /// /// Not all parameters may be supported by all Raytrix cameras. /// /// /// If the parameter referenced by \a ePar does not relate to an double parameter an Rx::CRxException is thrown. /// /// /// The camera parameter. Allowed parameters from Rx::Interop::Runtime30::Camera::EProperty are: /// - Camera /// - Rx::Interop::Runtime30::Camera::EProperty::Exposure /// - Rx::Interop::Runtime30::Camera::EProperty::TapBalance /// - Rx::Interop::Runtime30::Camera::EProperty::Gain /// - Rx::Interop::Runtime30::Camera::EProperty::GainRed /// - Rx::Interop::Runtime30::Camera::EProperty::GainGreen /// - Rx::Interop::Runtime30::Camera::EProperty::GainBlue /// - Rx::Interop::Runtime30::Camera::EProperty::FramesPerSecond /// - Rx::Interop::Runtime30::Camera::EProperty::Focus /// - Rx::Interop::Runtime30::Camera::EProperty::Iris /// - Rx::Interop::Runtime30::Camera::EProperty::StrobeLength1 /// - Rx::Interop::Runtime30::Camera::EProperty::StrobeLength2 /// - Rx::Interop::Runtime30::Camera::EProperty::StrobeDelay1 /// - Rx::Interop::Runtime30::Camera::EProperty::StrobeDelay2 /// The double value. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxCamSetPar(Rx::Interop::Runtime30::Camera::EProperty::ID ePar, double dValue); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Get the parameter range of a camera parameter of type unsigned integer. /// /// /// The zero-based camera index. /// The camera parameter. Allowed parameters from Rx::Interop::Runtime30::Camera::EProperty are: /// - Camera /// - Rx::Interop::Runtime30::Camera::EProperty::IsColor /// - Rx::Interop::Runtime30::Camera::EProperty::IsBayer /// - Rx::Interop::Runtime30::Camera::EProperty::PIVMode /// - Rx::Interop::Runtime30::Camera::EProperty::IsOpen /// - Rx::Interop::Runtime30::Camera::EProperty::IsCapturing /// - Rx::Interop::Runtime30::Camera::EProperty::TriggerMode /// - Rx::Interop::Runtime30::Camera::EProperty::ExternalTriggerMode. /// [out] On return the minimal parameter value. /// [out] On return the maximal parameter value. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxCamGetParRange(unsigned uCamIdx, Rx::Interop::Runtime30::Camera::EProperty::ID ePar, unsigned& uMin, unsigned& uMax); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Get the parameter range of a camera parameter of type double /// /// /// The zero-based camera index. /// The camera parameter. Allowed parameters from Rx::Interop::Runtime30::Camera::EProperty are: /// - Camera /// - Rx::Interop::Runtime30::Camera::EProperty::TapBalance /// - Rx::Interop::Runtime30::Camera::EProperty::Gain /// - Rx::Interop::Runtime30::Camera::EProperty::GainRed /// - Rx::Interop::Runtime30::Camera::EProperty::GainGreen /// - Rx::Interop::Runtime30::Camera::EProperty::GainBlue. /// [out] On return the minimal parameter value. /// [out] On return the maximal parameter value. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxCamGetParRange(unsigned uCamIdx, Rx::Interop::Runtime30::Camera::EProperty::ID ePar, double& dMin, double& dMax); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Get a set of available values for a parameter of type unsigned integer /// /// /// The zero-based camera index. /// The camera parameter. /// [out] The list of available values. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxCamGetParRange(unsigned uCamIdx, Rx::Interop::Runtime30::Camera::EProperty::ID ePar, Rx::CRxArrayUInt& auValues); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Get the parameter range of a camera parameter of type unsigned integer from the currently bound camera. /// /// /// The camera parameter. Allowed parameters from Rx::Interop::Runtime30::Camera::EProperty are: /// - Camera /// - Rx::Interop::Runtime30::Camera::EProperty::IsColor /// - Rx::Interop::Runtime30::Camera::EProperty::IsBayer /// - Rx::Interop::Runtime30::Camera::EProperty::PIVMode /// - Rx::Interop::Runtime30::Camera::EProperty::IsOpen /// - Rx::Interop::Runtime30::Camera::EProperty::IsCapturing /// - Rx::Interop::Runtime30::Camera::EProperty::TriggerMode /// - Rx::Interop::Runtime30::Camera::EProperty::ExternalTriggerMode. /// [out] On return the minimal parameter value. /// [out] On return the maximal parameter value. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxCamGetParRange(Rx::Interop::Runtime30::Camera::EProperty::ID ePar, unsigned& uMin, unsigned& uMax); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Get the parameter range of a camera parameter of type double from the currently bound camera. /// /// /// The camera parameter. Allowed parameters from Rx::Interop::Runtime30::Camera::EProperty are: /// - Camera /// - Rx::Interop::Runtime30::Camera::EProperty::TapBalance /// - Rx::Interop::Runtime30::Camera::EProperty::Gain /// - Rx::Interop::Runtime30::Camera::EProperty::GainRed /// - Rx::Interop::Runtime30::Camera::EProperty::GainGreen /// - Rx::Interop::Runtime30::Camera::EProperty::GainBlue. /// [out] On return the minimal parameter value. /// [out] On return the maximal parameter value. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxCamGetParRange(Rx::Interop::Runtime30::Camera::EProperty::ID ePar, double& dMin, double& dMax); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Get set of available values for parameter of type unsigned. /// /// /// The camera parameter. /// [out] The list of available values. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxCamGetParRange(Rx::Interop::Runtime30::Camera::EProperty::ID ePar, Rx::CRxArrayUInt& auValues); public: ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Create a new ray image. /// /// The allowed pixel types of ray images are /// - Rx::Interop::Runtime28::EPixelType::RGB /// - Rx::Interop::Runtime28::EPixelType::RGBA /// - Rx::Interop::Runtime28::EPixelType::BGR /// - Rx::Interop::Runtime28::EPixelType::BGRA /// - Rx::Interop::Runtime28::EPixelType::Lum /// - Rx::Interop::Runtime28::EPixelType::LumA /// - Rx::Interop::Runtime28::EPixelType::BayerBG /// - Rx::Interop::Runtime28::EPixelType::BayerGB /// - Rx::Interop::Runtime28::EPixelType::BayerGR /// - Rx::Interop::Runtime28::EPixelType::BayerRG /// - Rx::Interop::Runtime28::EPixelType::YUV420P. /// /// Returns the ray handle, which you can use in: /// - Rx::LFR::CApiLF::RxRayDelete /// - Rx::LFR::CApiLF::RxRaySave /// - Rx::LFR::CApiLF::RxRayCalibSaveXML /// - Rx::LFR::CApiLF::RxRayCalibXmlGet /// - Rx::LFR::CApiLF::RxRayBind /// - Rx::LFR::CApiLF::RxRayGetFormat /// - Rx::LFR::CApiLF::RxRayGetRaw /// - Rx::LFR::CApiLF::RxRayGetMetaData /// - Rx::LFR::CApiLF::RxRaySetMetaData. /// /// /// The ray image format. /// /// The ray image handle of the ray image. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static unsigned RxRayNew(const Rx::CRxImageFormat& xF); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Load a ray image. /// /// /// The ray image filename. /// /// The ray image handle of the ray image. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static unsigned RxRayLoad(const Rx::CRxString& sxFilename); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Delete the image with the given ID. /// /// /// /// If the ray image referenced by \p uRayHandle is currently bound by a previous call to Rx::LFR::CApiLF::RxRayBind or /// Rx::LFR::CApiLF::RxCamStartCapture, the image is not deleted and an exception is thrown. /// /// /// The handle of the ray image to delete. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxRayDelete(unsigned uRayHandle); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Saves the given light field image to the given file. /// /// This augments the meta data with information from the current light field environment and saves them along the image /// data. These information contain the current algorithm parameter. /// /// /// The ID of the light field image created by calling RxRayLoad, RxRaySeqBind or RxCamBind. /// The complete file path. /// True to update the current meta data so that they are available in the next call to /// RxRayGetMetaData; false to update a COPY of the current meta data so that they are NOT /// available in the next call to RxRayGetMetaData. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxRaySave(unsigned uRayHandle, const Rx::CRxString& sxFilename, bool bUpdateMetaData); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Saves the bound light field image to the given file. /// /// This augments the meta data with information from the current light field environment and saves them along the image /// data. These information contain the current algorithm parameter. /// /// /// The complete file path. /// True to update the current meta data so that they are available in the next call to /// RxRayGetMetaData; false to update a COPY of the current meta data so that they are NOT /// available in the next call to RxRayGetMetaData. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxRaySave(const Rx::CRxString& sxFilename, bool bUpdateMetaData); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Save calibration data of ray image in XML format. /// /// /// The ID of the ray image whose calibration data is to be saved. /// The complete file path under which to save the data. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxRayCalibSaveXML(unsigned uRayHandle, const Rx::CRxString& sxFilename); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Get the calibration data of the given ray image as XML string. /// /// /// The ID of the ray image whose calibration data is to be saved. /// [out] On successful return contains the XML string. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxRayCalibXmlGet(unsigned uRayHandle, Rx::CRxString& sxXml); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Gets the pointer to the internal camera format. /// /// /// The pointer to the internal camera format. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static const void* RxRayGetCameraFormat(); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Bind a ray image to perform computations on. /// /// /// The ID of the light field image that is to be used for calculations. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxRayBind(unsigned uRayHandle); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Unbind the currently bound ray image. /// /// /// /// If no ray image is bound the function does nothing. If a ray sequence or a camera is bound, the function throws an /// exception. /// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxRayUnbind(); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Get the image format of a ray image. /// /// /// The ray image handle. /// [out] On return contains the image format of the ray image. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxRayGetFormat(unsigned uRayHandle, Rx::CRxImageFormat& xF); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Gets the image timestamp of the given light field image. Is 0 if the image hasn't a valid timestamp. You can use this /// timestamp and the timestamp of another camera or sequence frame to determine the time between them. /// /// /// The ID of the light field image created by calling RxRayLoad, RxRaySeqBind or RxCamBind. /// /// The timestamp. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static double RxRayGetTimestap(unsigned uRayHandle); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Gets the image timestamp of the bound light field image. Is 0 if the image hasn't a valid timestamp. You can use this /// timestamp and the timestamp of another camera or sequence frame to determine the time between them. /// /// /// The timestamp. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static double RxRayGetTimestap(); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Gets the frame ID of the given light field image. Used when working with sequences or cameras. /// /// /// The ID of the light field image created by calling RxRayLoad, RxRaySeqBind or RxCamBind. /// /// The frame ID. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static unsigned RxRayGetFrameID(unsigned uRayHandle); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Gets the frame ID of the bound light field image. Used when working with sequences or cameras. /// /// /// The frame ID. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static unsigned RxRayGetFrameID(); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Get the ray image as Rx::CRxImage instance. /// /// /// The ray image handle. /// [out] On return contains the ray image. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxRayGetRaw(unsigned uRayHandle, Rx::CRxImage& xRawImage); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Get the ray image. /// /// /// /// If Create is true, the necessary memory for the image is created with a call to /// Rx::Interop::Runtime28::IImage::Create, otherwise it is expected that pRawImage is already allocated with the correct /// amount of memory. /// /// /// The ray image handle. /// [out] Pointer to an IImage interface. /// Flag whether to create image. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxRayGetRaw(unsigned uRayHandle, Rx::Interop::Runtime28::IImage* pRawImage, bool bCreate); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Get meta data of a ray image. /// /// The meta data class CRxMetaData can contain any number of meta data elements of types unsigned, double and /// Rx::CRxString. You can get, set and add elements to the meta data instance and store this together with the ray image. /// /// /// [out] Contains the ray image meta data on return. /// The ray image handle. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxRayGetMetaData(Rx::CRxMetaData& xMetaData, unsigned uImgID); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Get the meta data of the bound ray image. /// /// The meta data class CRxMetaData can contain any number of meta data elements of types unsigned, double and /// Rx::CRxString. You can get, set and add elements to the meta data instance and store this together with the ray image. /// /// /// [out] Contains the ray image meta data on return. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxRayGetMetaData(Rx::CRxMetaData& xMetaData); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Set meta data of a ray image. /// /// /// /// The meta data class CRxMetaData can contain any number of meta data elements of types unsigned, double and /// Rx::CRxString. You can get, set and add elements to the meta data instance and store this together with the ray image. /// /// /// The ray image handle. /// The ray image meta data to set. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxRaySetMetaData(unsigned uRayHandle, const Rx::CRxMetaData& xMetaData); public: ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Open a ray sequence. Depending on the mode a ray sequence can be opened for reading or writing. /// /// /// Returns the ray sequence handle. /// /// The complete file path to the ray sequence. /// The ray sequence mode. This is a combination of elements of Rx::ERaySeqMode . /// The number of frame buffers used for buffered writing/reading. /// /// The ray sequence id. This id is used in other functions to reference the ray sequence. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static unsigned RxRaySeqOpen(const Rx::CRxString& sxFilename, unsigned uMode, unsigned uFrameBufferCount); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Close a ray sequence. /// /// /// /// Closing a ray sequence also unbinds the corresponding ray image. The ray sequence ID becomes invalid once the ray /// sequence has been closed. /// /// /// The id of the ray sequence. /// /// The number of frames written (if sequence was in write mode). ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static unsigned RxRaySeqClose(unsigned uRaySeqHandle); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Bind a ray sequence for use by other API functions. /// /// Only one ray sequence for reading and one ray sequence for writing can be bound at a time. When a ray sequence is bound /// for reading, then any currently bound ray image is unbound, a new prototype ray image of the format of the ray sequence /// is created and bound and the first image of the ray sequence is loaded into the bound ray image.The ID of the newly /// created ray image is returned. No new ray image can be bound until the ray sequence is unbound using /// Rx::LFR::CApiLF::RxRaySeqUnbind .If a camera capture is started while a ray sequence is bound for reading, the ray sequence is /// automatically unbound. While a camera is in capture mode, no ray sequence can be bound for reading. /// /// When a ray sequence is bound for writing a ray image must already be bound. If the ray sequence is empty up to now, the /// ray sequence is created for the currently bound image type and only ray images of the same format can be written to the /// ray sequence.Also only ray images of the same format can be bound while the ray sequence is bound. If the ray sequence /// already contains images, it can only be bound if the currently bound ray image format is of the same format as the ray /// sequence. If a ray sequence in write mode is bound and camera capture is started the ray sequence is also unbound if /// the image formats do not agree.To capture frames from a camera, first start the camera capture, then bind the ray /// sequence in write mode and set the parameter Rx::LFR::Params::EApiLF::RaySeq_AutoStoreCamFrames to 1. The value returned is the /// ray image ID of the currently bound ray image. /// /// /// The id of the ray sequence. /// /// the currently bound ray image handle. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static unsigned RxRaySeqBind(unsigned uRaySeqHandle); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Determines if a sequence is bound for reading to the API. /// /// /// True if a sequence in read mode is bound, false if not. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static bool RxRaySeqIsBound(); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Unbind a ray sequence. If a ray sequence in write mode is unbound, the currently bound ray image stays bound. No more /// images can be written to the ray sequence once it has been unbound, however, the ray sequence has not been closed. It /// can be bound again to write further ray images to it. /// /// If a ray sequence in read mode is unbound, the currently bound ray image stays bound. The ray image is therefore also /// not removed from memory. /// /// /// You will have to unbind the ray image and then delete it to free all memory. /// /// The ray sequence ID of the ray sequence to unbind. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxRaySeqUnbind(unsigned uRaySeqHandle); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Read a frame from the currently bound ray sequence. /// /// /// 
 A ray sequence in read mode must have been bound beforehand.
/// /// /// This function reads the current frame from the ray sequence and advanced the frame pointer by one frame.The ray image /// is read into the currently bound ray image and the image is automatically copied onto the CUDA device. This means that /// the function Rx::LFR::CApiLF::RxRaySeqGetFrameIndex returns a frame index higher than before after calling /// Rx::LFR::CApiLF::RxRaySeqRead. /// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxRaySeqRead(); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Write currently bound ray image to currently bound ray sequence. /// /// This function appends the currently bound ray image to the bound ray sequence. /// /// /// /// To automatically write frames captured from a camera device to the bound ray sequence, set the parameter /// Rx::LFR::Params::EApiLF::RaySeq_AutoStoreCamFrames to 1. /// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxRaySeqWrite(); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Get number of frame buffers in use. /// /// /// The ray sequence id. /// /// The number of frames in use in the frame buffer. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static unsigned RxRaySeqGetFrameBufferUsedCount(unsigned uRaySeqHandle); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Receive ray sequence frame count. /// /// /// Identifier for the ray sequence. /// /// Number of frames. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static unsigned RxRaySeqGetFrameCount(unsigned uRaySeqHandle); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Get number of frames in ray sequence that is currently bound in read mode. /// /// /// Number of frames. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static unsigned RxRaySeqGetFrameCount(); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Get the total file size of the ray sequence in bytes. /// /// /// The ray sequence id. /// [out] Contains the total size of the ray sequence in bytes. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxRaySeqGetFileSize(unsigned uRaySeqHandle, unsigned __int64& uFileSize); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Get current frame index of ray sequence. /// /// /// The ray sequence id. /// /// The frame index on return. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static unsigned RxRaySeqGetFrameIndex(unsigned uRaySeqHandle); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Set the current frame index of ray sequence. /// /// /// The ray sequence id. /// The frame index. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxRaySeqSetFrameIndex(unsigned uRaySeqHandle, unsigned uFrameIdx); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Move the frame index relative to the current position in the ray sequence. /// /// /// The ray sequence id. /// The number of frames to move. Negative values move frame index backward. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxRaySeqMoveFrameIndex(unsigned uRaySeqHandle, int iStep); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Get the doubleshot mode used when recording the given sequence. /// /// /// The ray sequence id. /// /// The doubleshot mode. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static unsigned RxRaySeqGetDoubleShotMode(unsigned uRaySeqHandle); public: ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Get OpenGL version of current OpenGL rendering context. /// /// /// This function only return a meaningful result if it is called within an active OpenGL rendering context. /// /// [out] On return contains the OpenGL major version. /// [out] On return contains the OpenGL minor version. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxGlGetVersion(int& iMajor, int& iMinor); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Copy CUDA result images to OpenGL textures. /// /// The internal image IDs that can be used with this function are those declared in Rx::LFR::CApiLF::EImgID. Combining a number /// of image IDs by OR, updates all the related textures. /// /// /// Internal image ID. A number of internal image IDs can be combined with OR operation. /// (optional) the create mipmaps flag. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxGlUpdateTex(unsigned uIntImgIDs, bool bCreateMipmaps = false); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Get the OpenGL texture ID corresponding to given parameter eImgID The content of this texture can be updated /// with the Rx::LFR::CApiLF::RxGlUpdateTex function. /// /// /// The image ID. /// [out] Identifier for the OpenGL texture. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxGlGetTextureID(LFR::EImage::ID eImgID, unsigned& uGlTextureID); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Get the OpenGL texture ID corresponding to given parameter eImgID The content of this texture can be updated /// with the Rx::LFR::CApiLF::RxGlUpdateTex function. /// /// /// The image ID. /// /// The identifier for the OpenGL texture. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static unsigned RxGlGetTextureID(LFR::EImage::ID eImgID); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Assigns the OpenGL context created by Rx::LFR::CApiLF::RxCudaSelectDevice to the calling thread. /// /// /// 
			/// 	Before assigning a context, the thread that has the context currently must release it via
			/// 	Rx::LFR::CApiLF::RxGlReleaseContext().
			///
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxGlGetContext(); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Releases the OpenGL context owned by the calling thread. /// /// /// /// Another thread can get the released context via Rx::LFR::CApiLF::RxGlGetContext. If the calling thread hasn't a valid context /// this function will do nothing and only returns. /// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxGlReleaseContext(); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Store the threads current OpenGL context. The context can be retrieved with RxGlGetContext() and released with /// RxGlReleaseContext. /// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxGlSetContext(); public: ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Sets the value of a parameter. /// /// /// The ID of the parameter. /// [in] The value of the parameter. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxSetPar(Rx::LFR::Params::EApiLF::ID ePar, unsigned uValue); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Gets the value of a parameter. /// /// /// The ID of the parameter. /// [out] The value of the parameter. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxGetPar(Rx::LFR::Params::EApiLF::ID ePar, unsigned& uValue); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Get the value range of a parameter. /// /// /// The ID of the parameter. /// [out] The min allowed value of the parameter. /// [out] The max allowed value of the parameter. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxGetParRange(Rx::LFR::Params::EApiLF::ID ePar, unsigned& uMin, unsigned& uMax); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Get the string representation of a parameter. /// /// /// The parameter ID. /// [out] On return contains the parameter string representation. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxGetParName(Rx::LFR::Params::EApiLF::ID ePar, Rx::CRxString& sValue); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Get the Properties of a parameter. /// /// /// The parameter ID. /// [out] On return contains the parameter string representation. /// [out] On return contains the parameter ReadAccess flag. /// [out] On return contains the parameter WriteAccess flag. /// [out] On return contains the parameter DataType. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxGetParProperties(Rx::LFR::Params::EApiLF::ID ePar, Rx::CRxString& sValue, bool& bReadAccess, bool& bWriteAccess, EValueType::ID& eParameterType); public: ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Sets the value of a parameter. /// /// /// The ID of the parameter. /// [in] The value of the parameter. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxSetPar(Rx::LFR::Params::ECudaCompute::ID ePar, unsigned uValue); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Sets the value of a parameter. /// /// /// The ID of the parameter. /// [in] The value of the parameter. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxSetPar(Rx::LFR::Params::ECudaCompute::ID ePar, double dValue); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Sets the value of a parameter. /// /// /// The ID of the parameter. /// [in] The value of the parameter. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxSetPar(Rx::LFR::Params::ECudaCompute::ID ePar, const Rx::CRxString& sValue); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Sets the value of a parameter. /// /// /// The ID of the parameter. /// [in] The value of the parameter. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxSetPar(Rx::LFR::Params::ECudaCompute::ID ePar, const Rx::CRxArrayUInt& auValue); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Sets the value of a parameter. /// /// /// The ID of the parameter. /// [in] The value of the parameter. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxSetPar(Rx::LFR::Params::ECudaCompute::ID ePar, const Rx::CRxArrayDouble& adValue); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Sets the value of a parameter. /// /// /// The ID of the parameter. /// [in] The value of the parameter. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxSetPar(Rx::LFR::Params::ECudaCompute::ID ePar, const Rx::CRxArrayString& asValue); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Gets the value of a parameter. /// /// /// The ID of the parameter. /// [out] The value of the parameter. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxGetPar(Rx::LFR::Params::ECudaCompute::ID ePar, unsigned& uValue); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Gets the value of a parameter. /// /// /// The ID of the parameter. /// [out] The value of the parameter. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxGetPar(Rx::LFR::Params::ECudaCompute::ID ePar, double& dValue); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Gets the value of a parameter. /// /// /// The ID of the parameter. /// [out] The value of the parameter. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxGetPar(Rx::LFR::Params::ECudaCompute::ID ePar, Rx::CRxString& sValue); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Gets the value of a parameter. /// /// /// The ID of the parameter. /// [out] The value of the parameter. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxGetPar(Rx::LFR::Params::ECudaCompute::ID ePar, Rx::CRxArrayUInt& auValue); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Gets the value of a parameter. /// /// /// The ID of the parameter. /// [out] The value of the parameter. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxGetPar(Rx::LFR::Params::ECudaCompute::ID ePar, Rx::CRxArrayDouble& adValue); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Gets the value of a parameter. /// /// /// The ID of the parameter. /// [out] The value of the parameter. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxGetPar(Rx::LFR::Params::ECudaCompute::ID ePar, Rx::CRxArrayString& asValue); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Get the value range of a parameter. /// /// /// The ID of the parameter. /// [out] The min allowed value of the parameter. /// [out] The max allowed value of the parameter. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxGetParRange(Rx::LFR::Params::ECudaCompute::ID ePar, unsigned& uMin, unsigned& uMax); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Get the value range of a parameter. /// /// /// The ID of the parameter. /// [out] The min allowed value of the parameter. /// [out] The max allowed value of the parameter. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxGetParRange(Rx::LFR::Params::ECudaCompute::ID ePar, double& dMin, double& dMax); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Get the value range of an array parameter and the min and max allowed number of elements in the array. /// /// /// The ID of the parameter. /// [out] The min number of values allowed in the array. /// [out] The max number of values allowed in the array. /// [out] The min allowed value of the parameter. /// [out] The max allowed value of the parameter. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxGetParRange(Rx::LFR::Params::ECudaCompute::ID ePar, size_t& iMinCount, size_t& iMaxCount, unsigned& uMin, unsigned& uMax); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Get the value range of an array parameter and the min and max allowed number of elements in the array. /// /// /// The ID of the parameter. /// [out] The min number of values allowed in the array. /// [out] The max number of values allowed in the array. /// [out] The min allowed value of the parameter. /// [out] The max allowed value of the parameter. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxGetParRange(Rx::LFR::Params::ECudaCompute::ID ePar, size_t& iMinCount, size_t& iMaxCount, double& dMin, double& dMax); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Get the string representation of a parameter. /// /// /// The parameter ID. /// [out] On return contains the parameter string representation. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxGetParName(Rx::LFR::Params::ECudaCompute::ID ePar, Rx::CRxString& sValue); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Get the Properties of a parameter. /// /// /// The parameter ID. /// [out] On return contains the parameter string representation. /// [out] On return contains the parameter ReadAccess flag. /// [out] On return contains the parameter WriteAccess flag. /// [out] On return contains the parameter DataType. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxGetParProperties(Rx::LFR::Params::ECudaCompute::ID ePar, Rx::CRxString& sValue, bool& bReadAccess, bool& bWriteAccess, EValueType::ID& eParameterType); public: ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Sets the value of a parameter. /// /// /// The ID of the parameter. /// [in] The value of the parameter. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxSetPar(Rx::LFR::Params::ECalib::ID ePar, unsigned uValue); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Sets the value of a parameter. /// /// /// The ID of the parameter. /// [in] The value of the parameter. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxSetPar(Rx::LFR::Params::ECalib::ID ePar, double dValue); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Sets the value of a parameter. /// /// /// The ID of the parameter. /// [in] The value of the parameter. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxSetPar(Rx::LFR::Params::ECalib::ID ePar, const Rx::CRxString& sValue); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Sets the value of a parameter. /// /// /// The ID of the parameter. /// [in] The value of the parameter. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxSetPar(Rx::LFR::Params::ECalib::ID ePar, const Rx::CRxArrayUInt& auValue); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Sets the value of a parameter. /// /// /// The ID of the parameter. /// [in] The value of the parameter. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxSetPar(Rx::LFR::Params::ECalib::ID ePar, const Rx::CRxArrayDouble& adValue); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Sets the value of a parameter. /// /// /// The ID of the parameter. /// [in] The value of the parameter. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxSetPar(Rx::LFR::Params::ECalib::ID ePar, const Rx::CRxArrayString& asValue); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Gets the value of a parameter. /// /// /// The ID of the parameter. /// [out] The value of the parameter. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxGetPar(Rx::LFR::Params::ECalib::ID ePar, unsigned& uValue); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Gets the value of a parameter. /// /// /// The ID of the parameter. /// [out] The value of the parameter. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxGetPar(Rx::LFR::Params::ECalib::ID ePar, double& dValue); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Gets the value of a parameter. /// /// /// The ID of the parameter. /// [out] The value of the parameter. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxGetPar(Rx::LFR::Params::ECalib::ID ePar, Rx::CRxString& sValue); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Gets the value of a parameter. /// /// /// The ID of the parameter. /// [out] The value of the parameter. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxGetPar(Rx::LFR::Params::ECalib::ID ePar, Rx::CRxArrayUInt& auValue); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Gets the value of a parameter. /// /// /// The ID of the parameter. /// [out] The value of the parameter. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxGetPar(Rx::LFR::Params::ECalib::ID ePar, Rx::CRxArrayDouble& adValue); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Gets the value of a parameter. /// /// /// The ID of the parameter. /// [out] The value of the parameter. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxGetPar(Rx::LFR::Params::ECalib::ID ePar, Rx::CRxArrayString& asValue); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Get the value range of a parameter. /// /// /// The ID of the parameter. /// [out] The min allowed value of the parameter. /// [out] The max allowed value of the parameter. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxGetParRange(Rx::LFR::Params::ECalib::ID ePar, unsigned& uMin, unsigned& uMax); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Get the value range of a parameter. /// /// /// The ID of the parameter. /// [out] The min allowed value of the parameter. /// [out] The max allowed value of the parameter. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxGetParRange(Rx::LFR::Params::ECalib::ID ePar, double& dMin, double& dMax); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Get the value range of an array parameter and the min and max allowed number of elements in the array. /// /// /// The ID of the parameter. /// [out] The min number of values allowed in the array. /// [out] The max number of values allowed in the array. /// [out] The min allowed value of the parameter. /// [out] The max allowed value of the parameter. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxGetParRange(Rx::LFR::Params::ECalib::ID ePar, size_t& iMinCount, size_t& iMaxCount, unsigned& uMin, unsigned& uMax); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Get the value range of an array parameter and the min and max allowed number of elements in the array. /// /// /// The ID of the parameter. /// [out] The min number of values allowed in the array. /// [out] The max number of values allowed in the array. /// [out] The min allowed value of the parameter. /// [out] The max allowed value of the parameter. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxGetParRange(Rx::LFR::Params::ECalib::ID ePar, size_t& iMinCount, size_t& iMaxCount, double& dMin, double& dMax); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Get the string representation of a parameter. /// /// /// The parameter ID. /// [out] On return contains the parameter string representation. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxGetParName(Rx::LFR::Params::ECalib::ID ePar, Rx::CRxString& sValue); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Get the Properties of a parameter. /// /// /// The parameter ID. /// [out] On return contains the parameter string representation. /// [out] On return contains the parameter ReadAccess flag. /// [out] On return contains the parameter WriteAccess flag. /// [out] On return contains the parameter DataType. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxGetParProperties(Rx::LFR::Params::ECalib::ID ePar, Rx::CRxString& sValue, bool& bReadAccess, bool& bWriteAccess, EValueType::ID& eParameterType); public: ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Saves all writable API parameter to file. Its mandatory to bind a light field image before. /// /// /// The filename. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxSaveParameter(const Rx::CRxString& sxFilename); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Loads all writable API parameter from file. Its mandatory to bind a light field image before. /// /// /// The filename. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxLoadParameter(const Rx::CRxString& sxFilename); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Resets all parameters to their default value. /// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxResetParameters(); public: ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Convert a Rx::CRxImage to a new pixel and data type. /// /// /// [out] Destination image. /// Reference to the image. /// Pixel type of the converted image. /// Data type of the converted image. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxConvertImage(Rx::CRxImage& xDstImage, const Rx::CRxImage& xSrcImage, Rx::Interop::Runtime28::EPixelType::ID eDstPixelType, Rx::Interop::Runtime28::EDataType::ID eDstDataType); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Convert a Rx::CRxImage to a new pixel and data type. /// /// /// [out] Destination image. /// Reference to the image. /// Pixel type of the converted image. /// Data type of the converted image. /// if true, memory for the destination image is created by this function. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxConvertImage(Rx::Interop::Runtime28::IImage* pDstImage, const Rx::Interop::Runtime28::IImage* pSrcImage, Rx::Interop::Runtime28::EPixelType::ID eDstPixelType, Rx::Interop::Runtime28::EDataType::ID eDstDataType, bool bCreate); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Get an internal image. /// /// The available internal image IDs are listed in Rx::LFR::CApiLF::EImgID. /// /// /// Internal image ID. This is not a ray image handle. /// [out] On return contains a copy of the specified internal image. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxGetImage(LFR::EImage::ID eImgID, Rx::CRxImage& xImage); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Get an internal image. /// /// The available internal image IDs are listed in Rx::LFR::CApiLF::EImgID. /// /// /// Internal image ID. This is not a ray image handle. /// [out] On return contains a copy of the specified internal image. /// If true, a new image is created in pImage. Otherwise, it is ensured that pImage refers to an image /// the same size and type as the respective internal image, and then the internal image is copied. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxGetImage(LFR::EImage::ID eImgID, Rx::Interop::Runtime28::IImage* pImage, bool bCreate); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Set an internal image. /// /// The available internal image IDs are listed in Rx::LFR::CApiLF::EImgID. /// /// A new ray image can be set with eImgID set to LFR::EImage::Raw and a new gray image with LFR::EImage::Gray. /// RxSetImage copies the image data into the currently bound ray image and to the CUDA device. For the new ray image to be /// used in calculations you must call Rx::LFR::CApiLF::RxPreProcess after setting the ray and the gray image. /// /// You can also circumvent the internal preprocessing of the ray image by writing directly the processed ray image to the /// CUDA device with LFR::EImage::Processed_Normalized. However, this will not change the LFR::EImage::Raw or /// LFR::EImage::Gray images currently bound. /// /// /// Internal image ID. This is not a ray image handle. /// The image to copy into the specified internal image. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxSetImage(LFR::EImage::ID eImgID, const Rx::CRxImage& xImage); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Set an internal image. /// /// The available internal image IDs are listed in Rx::LFR::CApiLF::EImgID. /// /// A new ray image can be set with eImgID set to LFR::EImage::Raw and a new gray image with /// LFR::EImage::Gray. RxSetImage copies the image data into the currently bound ray image and to the CUDA /// device. /// For the new ray image to be used in calculations you must call Rx::LFR::CApiLF::RxPreProcess after setting the ray and the /// gray image. /// /// You can also circumvent the internal preprocessing of the ray image by writing directly the processed ray image to the /// CUDA device with LFR::EImage::Processed_Normalized. However, this will not change the /// LFR::EImage::Raw or LFR::EImage::Gray images currently bound. /// /// /// Internal image ID. This is not a ray image handle. /// The image to copy into the specified internal image. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxSetImage(LFR::EImage::ID eImgID, const Rx::Interop::Runtime28::IImage* pImage); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Test whether an internal image is valid. /// /// /// The available internal image IDs are listed in Rx::LFR::CApiLF::EImgID. /// /// Internal image ID. This is not a ray image handle. /// /// true if the image is valid, false otherwise. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static bool RxIsImageValid(LFR::EImage::ID eImgID); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Frees memory used by the image defined in eImgID. This invalidates the image. /// /// /// The image ID. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxFreeImage(LFR::EImage::ID eImgID); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Get the image format of an internal image. /// /// /// /// This function returns the image format of an internal image without copying the actual image from the CUDA device to /// host memory. /// The available internal image IDs are listed in Rx::LFR::CApiLF::EImgID. /// /// /// Internal image ID. This is not a ray image handle. /// [out] On return contains the internal image's format. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxGetImageFormat(LFR::EImage::ID eImgID, Rx::CRxImageFormat& xF); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Get the device pointer of an internal image. /// /// /// /// This function returns the image device pointer of an internal image. The available internal image IDs are listed in /// Rx::LFR::CApiLF::EImgID. /// /// /// Internal image ID. This is not a ray image handle. /// [out] On return contains the internal image's device pointer. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxGetImageDevicePointer(LFR::EImage::ID eImgID, void*& pDevicePtr); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Gets device pointer pitch, which is the width in bytes of the allocation. Given a row and column of an array element of /// type T, the address is computed as: /// /// T* pElement = (T*)((char*)BaseAddress + Row * pitch) + Column; /// /// /// Internal image ID. This is not a ray image handle. /// /// The image device pointer pitch. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static size_t RxGetImageDevicePointerPitch(LFR::EImage::ID eImgID); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Resize an image. /// /// /// [out] The target image to store the result. /// [in] The image that is to be resized. /// [in] The image size divider. For example, if iDivder = 2, then the resultant image size is half the /// original size. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxResizeImage(Rx::Interop::Runtime28::IImage* xDstImage, Rx::Interop::Runtime28::IImage* xSrcImage, int iDivider); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Finds the minimum and maximum value of the given eImgID /// /// /// The image ID. /// The channel. /// [out] The minimum value. /// [out] The maximum value. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxGetImageMinMax(LFR::EImage::ID eImgID, unsigned uChannel, float& fMin, float& fMax); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Calculates the histogram of the image with the given eImgID and stores the histogram data in the given array. /// This array must be large enough to hold 4 * 256 numbers. The number of calculated channels is returned in uChannels. /// /// /// The image ID. /// [out] A reference of Rx::CRxArrayUInt where the histogram will be stored. /// [out] The number of channels. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxGetImageHistogram(LFR::EImage::ID eImgID, Rx::CRxArrayUInt& xHistogram, unsigned& uChannels); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Projects an array of points from the given source space into the given target space. /// /// /// [out] The array of projected points. /// The array of points to project. /// The target space. /// The source space. /// /// /// True if all projections succeeded, false if at least one projection failed (out of sensor or image projection). /// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static bool RxProject(Rx::CRxArrayDouble& adTrgPoints, const Rx::CRxArrayDouble& adSrcPoints, LF::ESpace::ID eTrgSpace, LF::ESpace::ID eSrcSpace); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Projects the given source depth value into the given target space. /// /// /// The source depth in millimeter or virtual depths. /// The source space. /// True if the source depth is given in virtual depths. Is ignored if the source space isn't virtual. /// The target space. /// True if the target depth should be given in virtual depths. Is ignored if the target space isn't virtual. /// /// The resultant target depth in millimeter or virtual depths. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static double RxProjectDepth(double dSrcDepth, LF::ESpace::ID eSrcSpace, bool bSrcVD, LF::ESpace::ID eTrgSpace, bool bTrgVD); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Locks the CUDA Mutex. /// /// /// If the mutex is locked, the timeout defines the time in ms until a Rx::CRxException is /// thrown. /// /// True if it succeeds, false if it fails. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static bool RxLockCudaMutex(int iTimeout); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Unlocks the CUDA Mutex. /// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxUnlockCudaMutex(); public: ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Automatically calibrates MLI grid. /// /// /// Returns false if estimation has been failed because of wrong exposure or aperture configuration. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static bool RxGridCalibrateMli(); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Automatically calibrates MLA grid. Requires master dongle feature. /// /// /// Returns false if estimation has been failed because of wrong exposure or aperture configuration. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static bool RxGridCalibrateMla(); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Automatically calibrates the MLA rotation steps and the MLA reflection. Requires master dongle feature. /// /// /// Returns false if estimation has been failed because of wrong exposure or aperture configuration. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static bool RxGridCalibrateMaster(); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Enables or disables a callback during automatic grid calibration via RxGridCalibrateMli, RxGridCalibrateMla and /// RxGridCalibrateMaster. /// /// /// True to enable, false to disable. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxGridEnableCalibrationCallback(bool bEnable); public: ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Pre-Process a ray image. /// /// /// /// The ray image that is bound with RxRayBind() is a raw lightfield image. Before this ray image can be used by the actual /// processing algorithms, it has to be adjusted by applying a rectification of a possible radial distortion and by /// adjusting its brightness and color with respect to a gray image. /// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxPreProcess(); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Pre Process a ray image with a minimal Set of preprocessing parameter. /// /// This function does the same preprocessing as Rx::LFR::CApiLF::RxPreProcess but all preprocessing flags with exception of /// debayering are deactivated. /// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxGridDataImage(); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Show a lens grid overlay on the raw ray image. /// /// The result is written to the internal image with ID LFR::EImage::Grid. /// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxGrid(); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Focus image to a plane perpendicular to the optical axis, i.e. parallel to the image plane. /// /// This focuses to a plane perpendicular to the optical axis. To change the focal plane, use parameter /// Rx::LFR::Params::EApiLF::Focus_RelativeFocusPlane. A relative focus value of zero refocuses to the plane furthest away from the /// viewer and a value of 1 would focus to a plane that passes through the object side focal point of the recording lens. /// /// The result is written to the internal image with ID LFR::EImage::RefocusBasic. The size of this resultant image is set /// in relation to the ray image size via the parameter Rx::LFR::Params::EApiLF::Focus_ImageDivisor. /// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxRefocusBasic(); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Focus on a depth surface. /// /// In principle, each pixel of the result image can be focused individually. The function Rx::LFR::CApiLF::RxTotalFocus /// makes this property available by focusing the ray image to the depth surface given in the internal depth image related /// to the target space that is selected. To calculate the depth image you have to call Rx::LFR::CApiLF::RxDepthRay first /// and next Rx::LFR::CApiLF::RxDepthMap, or by a user defined image set with Rx::LFR::CApiLF::RxSetImage. /// /// When setting a depth image with Rx::LFR::CApiLF::RxSetImage it need not have the same dimensions as the resultant /// image. The given depth map is implicitly scaled to the size of the resultant refocused image. /// /// If the size of the given depth map image is 1x1 pixel, the depth encoded for that pixel is applied to all focused /// pixel. The depth image has to be of pixel type Rx::Interop::Runtime28::EPixelType::Lum and data type /// Rx::Interop::Runtime28::EDataType::UByte. The pixel value range of [0,255] is mapped to [0,1] for the interpretation as /// depth. /// /// \attention The result is written to the internal image related to the given space. The size of this resultant image is /// set in relation to the ray image size via the parameter Rx::LFR::Params::EApiLF::Focus_ImageDivisor. /// /// /// The space. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxTotalFocus(Rx::LF::ESpace::ID eSpace); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Creates a multi view image and stores the result in the image with the ID LFR::EImage::Multiview_ViewCamera. /// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxMultiview(); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Estimates the depth of the bound ray image and stores the result in the image with the ID LFR::EImage::DepthRay. /// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxDepthRay(); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Creates a depth map from the ray depth image created by Rx::LFR::CApiLF::RxDepthRay. /// /// /// The space. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxDepthMap(Rx::LF::ESpace::ID eSpace); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Object space depth 3D. /// /// This creates a RGBA float image which maps each pixel in the view camera to a 3D position in object space. The R /// channel is the X coordinate, the G channel is the Y coordinate and the B channel is the Z coordinate. The Z coordinate /// is relative to the global coordinate system which typically coincides with the light field camera sensor. All /// coordinate values are given in millimeters. /// /// The image is stored in the image with the ID LFR::EImage::Depth3D. /// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxDepth3D(); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Colorizes the depth map created by Rx::LFR::CApiLF::RxDepthMap.The result is stored in the image with the ID /// LFR::EImage::Depth3D. /// /// /// The space. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxDepthColorCode(Rx::LF::ESpace::ID eSpace); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Saves the 3D mesh provided by image 'Depth3D' to binary STL format. This requires a valid image computed by /// Rx::LFR::CApiLF::RxDepth3D. Triangles with a depth-variation larger than 'dMaxEdgeLength' for at least one vertex pair are /// not added to the mesh. /// /// /// The complete file path. /// True to save the mesh in virtual depth units instead of metric units. /// (Optional) Limit for depth-variation in vertices. -1 = infinity. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxSaveDepth3dMesh(const Rx::CRxString& sxFilename, bool bUseVD, const double dMaxEdgeLength = -1.0); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Saves the 3D mesh provided by image 'Depth3D' to binary STL format. This requires a valid image computed by /// Rx::LFR::CApiLF::RxDepth3D. Triangles with a depth-variation larger than 'dMaxEdgeLength' for at least one vertex pair are /// not added to the mesh. /// /// /// The complete file path. /// True to save the mesh in virtual depth uni /// ts instead of metric units. /// Limit for depth-variation in vertices. -1 = infinity. /// the percentage of the cropping on the left side. /// the percentage of the cropping on the right side. /// the percentage of the cropping on the top side. /// the percentage of the cropping on the bottom side. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxSaveDepth3dMesh(const Rx::CRxString& sxFilename, bool bUseVD, const double dMaxEdgeLength, const double dCropLeftPerc, const double dCropRightPerc, const double dCropTopPerc, const double dCropBottomPerc); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Saves the depth values of the current Depth3D image to the given file as a point list. /// /// The formats available are: /// /// ASCII: /// - .txt -- one point per row as plain text (default when no other extension matches, .txt is appended to filename) /// - .xyz -- conform to the 'xyz' file standard (augments txt format with small header) /// /// Binary: /// - .pcd -- the 'Point Cloud Data' format, see http://pointclouds.org/documentation/tutorials/pcd_file_format.php. /// /// /// The complete file path. /// True to save the point list in virtual depth units instead of metric units. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxSaveDepth3dPointList(const Rx::CRxString& sxFilename, bool bUseVD); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Saves the depth values of the current Depth3D image to the given file as a point list. /// /// The formats available are: /// /// ASCII: /// - .txt -- one point per row as plain text (default when no other extension matches, .txt is appended to filename) /// - .xyz -- conform to the 'xyz' file standard (augments txt format with small header) /// /// Binary: /// - .pcd -- the 'Point Cloud Data' format, see http://pointclouds.org/documentation/tutorials/pcd_file_format.php. /// /// /// The complete file path. /// True to save the point list in virtual depth units instead of metric units. /// The crop left perc. /// The crop right perc. /// The crop top perc. /// The crop bottom perc. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxSaveDepth3dPointList(const Rx::CRxString& sxFilename, bool bUseVD, const double dCropLeftPerc, const double dCropRightPerc, const double dCropTopPerc, const double dCropBottomPerc); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Sets the computation filter mask image. /// /// This image is used to reduce the number of lenses used for depth estimation (Rx::LFR::CApiLF::RxDepthRay). /// /// It must have the same dimension as the raw image and a pixel type of Rx::Interop::Runtime28::EPixelType::Lum and a data /// type of Rx::Interop::Runtime28::EDataType::UByte. /// /// Each lens of the raw image has a lens center that can be rounded to a pixel. If this pixel has the value 255 in the /// filter mask image, the corresponding lens is used. If this pixel has another value, the lens is not used. /// /// /// The computation filter mask image. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxSetComputationFilterMask(const Rx::CRxImage& xImage); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Sets the computation filter mask image. /// /// This image is used to reduce the number of lenses used for depth estimation (Rx::LFR::CApiLF::RxDepthRay). /// /// It must have the same dimension as the raw image and a pixel type of Rx::Interop::Runtime28::EPixelType::Lum and a data /// type of Rx::Interop::Runtime28::EDataType::UByte. /// /// Each lens of the raw image has a lens center that can be rounded to a pixel. If this pixel has the value 255 in the /// filter mask image, the corresponding lens is used. If this pixel has another value, the lens is not used. /// /// /// The complete file path of the computation filter mask image to load. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxSetComputationFilterMask(const Rx::CRxString& sxFilename); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// Removes the computation filter mask image set by Rx::LFR::CApiLF::RxSetComputationFilterMask. /// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static void RxRemoveComputationFilterMask(); private: static CApiLF_Impl* sm_pxImpl; private: ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// CApiLF(); // Forbidden ~CApiLF(); // Forbidden CApiLF(const CApiLF&); // Forbidden CApiLF& operator=(const CApiLF&); // Forbidden }; } }