/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Copyright (c) 2016 Raytrix GmbH. All rights reserved.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// namespace: Params
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
namespace Params
{
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Values that represent CUDA compute parameters.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef RX_MANAGED_ENUM
public enum class ECudaCompute
#else
namespace ECudaCompute
{
enum ID
#endif
{
None = 0,
/************************************************************************/
/* Ray PreProcess Algorithm */
/************************************************************************/
/// Enable Standard Preprocessing of ray image (unsigned,[0,1]:0,RW).
PreProc_Std_Enable = 0x00100000,
/// Standard preprocessing: brightness gain (double,[0.0,1e5]:1.0,RW).
PreProc_Std_Brightness,
/// Standard preprocessing: contrast center (double,[0.0,1.0]:0.5,RW).
PreProc_Std_ContrastCenter,
/// Standard preprocessing: contrast scale (double,[0.0,2.0]:0.0,RW).
PreProc_Std_ContrastScale,
/// Set of points in range [0,1] describing the gradation curve. Attention: Only two points are allowed at the moment (double[],[0.0,1.0]:(0.0,0.0,1.0,1.0), RW).
PreProc_Std_Gradation,
/// Enable sharpness algorithm 1: unsharp masking (unsigned,[0,1]:1,RW).
PreProc_Sharp1_Enable = 0x00102000,
/// Sharpness Algo1: Standard deviation of Gauss blurred image (double, [0.0,10.0]:2.5,RW).
PreProc_Sharp1_BlurStdDev,
/// Sharpness Algo1: Mixing factor of blurred image with original image as pixel * factor + blurred * (1 - factor) (double,[-2.0,3.0]:1.5,RW).
PreProc_Sharp1_Factor,
/// Use sharpness only for depth calculation (not for output image) (unsigned,[0,1]:1,RW).
PreProc_Sharp1_OnlyCalc,
/// Enable demosaic balance parameters (unsigned,[0,1]:0,RW).
PreProc_Demosaic_Enable = 0x00104000,
/// Red balance (double,[0.0,1.0]:1.0,RW).
PreProc_Demosaic_R,
/// Green balance (double,[0.0,1.0]:1.0,RW).
PreProc_Demosaic_G,
/// Blue balance (double,[0.0,1.0]:1.0,RW).
PreProc_Demosaic_B,
/// Enable Non-Local-Means denoising of raw image (unsigned,[0,1]:0,RW).
PreProc_DenoiseNLM_Enable = 0x00105000,
/// Denoise filter diameter in pixels (unsigned,[2,8]:4,RW).
PreProc_DenoiseNLM_FilterDia,
/// Noise level (double,[0.01,2.0]:0.1,RW).
PreProc_DenoiseNLM_NoiseLevel,
/// Blending factor (double,[0.0,0.3]:0.2,RW).
PreProc_DenoiseNLM_BlendFactor,
/// The data type of all resultant images. Supported data types are UByte (unsigned char) and UShort (unsigned short). If set to Void, the data type is the same as the input raw image. (enum,[Rx::Interop::Runtime28::EDataType]:UShort,RW).
PreProc_DataType = 0x00106000,
/************************************************************************/
/* Depth */
/************************************************************************/
/// Result image size divisor for depth evaluation (double,[2.0,20.0]:4.0,RW).
Depth_ImageDivisor = 0x00200000,
/// Minimum virtual depth for depth estimation (double,[2.0,100.0]:2.0,RW).
Depth_MinVirtualDepth,
/// Maximum virtual depth for depth estimation (double,[2.0,100.0]:15.0,RW).
Depth_MaxVirtualDepth,
/// The resolution level for near objects. The higher the number the finer the depth resolution for near objects (unsigned,[2,5]:3,RW).
Depth_NearResolutionLevel,
/// Flag whether to use a sparse set of micro lenses to calculate depth (unsigned,[0,1]:0,RW).
Depth_SparseLensSet,
/// Minimal standard deviation of correlation patch (double,[0.0,1.0]:0.01,RW).
Depth_MinStdDeviation,
/// Minimal correlation threshold (double,[0.0,1.0]:0.90,RW).
Depth_MinCorrelation,
/// Correlation patch radius (unsigned,[2,5]:3,RW).
Depth_PatchDiameter,
/// Correlation patch stride (unsigned,[1,5]:2,RW).
Depth_PatchStride,
/// A lens filter mask to disable (1) or enable (0) certain lens types during depth estimation (unsigned[12],[0,1]:0,RW).
Depth_LensFilterMask,
/// Enable (1) or disable (0) a depth consistency check while creating the depth map. This check should always be enabled (unsigned,[0,1]:1,RW).
Depth_ConsistencyCheck,
/// The algorithm used for depth estimation. (0) is the default depth path algorithm. (1) is the slower ray cast algorithm (unsigned,[0,1]:0,RW).
Depth_Algorithm,
/// Depth correction A (double,[,]:0,RW).
Depth_Correction_A = 0x00200100,
/************************************************************************/
/* Depth Fill */
/************************************************************************/
/// Flag whether filling of depth map is enabled (unsigned,[0,1]:1,RW).
Depth_Fill_Enabled = 0x00207000,
/// Number of iterations used for filling the depth map (unsigned,[0,20]:2,RW).
Depth_Fill_IterCnt,
/// Size of unknown depth border filled per iteration in pixels (unsigned,[1,100]:4,RW).
Depth_Fill_IterSize,
/// Flag to indicate whether the remaining unknown depth areas are to be filled after the iterations (unsigned,[0,1],0,RW).
Depth_Fill_Complete,
/// Flag whether bilateral filtering of depth map is enabled (unsigned,[0,1]:1,RW).
Depth_Fill_Bilateral_Enabled,
/// Bilateral filter radius (unsigned,[1,20]:5,RW).
Depth_Fill_Bilateral_FilterRadius,
/// Bilateral filter edge threshold (double,[0.01,0.2]:0.05,RW).
Depth_Fill_Bilateral_Edge,
/// Bilateral filter range distance threshold (double,[1.0,20.0]:5.0,RW).
Depth_Fill_Bilateral_Range,
/// Flag to indicate whether the first 3 iterations of the filling algorithm should perform an implicit filtering (unsigned,[0,1]:1,RW).
Depth_Fill_Filter_Enabled,
/// The algorithm used for depth filling. (0) is the default depth filling algorithm. (1) is the slower depth fill algorithm that considers more image information. (unsigned,[0,1]:0,RW).
Depth_Fill_Algorithm,
/// When the color difference of two compared pixels exceeds this threshold, the pixel is skipped. The difference is referred to normalized values where 1 would be a difference of 255 luminance values.
Depth_Fill_MaxColorSimilarity,
/// Shrinks the depth map 'contour' by removing all valid depths that are in this range (given in pixels) of an invalid depth value. A value of 0 means no shrink (unsigned,[0,100]:0,RW).
Depth_Fill_ShrinkRangePX,
/************************************************************************/
/* Focus */
/************************************************************************/
/// Result image size division factor (double,[0.0,-]:2.0,RW).
Focus_ImageDivisor = 0x00220000,
/// Focus value for refocusing onto a plane (double,[0.0,1.0]:0.1,RW).
Focus_RelativeFocusPlane,
/// This scale is used to blend the colored depth image with the focus image (double,[0.0,1.0]:0.0,RW).
Focus_DepthBlendingScale,
/************************************************************************/
/* Multiview */
/************************************************************************/
/// Multiview type (enum,[Rx::EMultiView]:Rx::EMultiView::RedCyan,RW).
Multiview_Type = 0x00220500,
/// Multiview eye separation (double,[1.0,20.0]:10.0,RW).
Multiview_EyeSeparation,
/************************************************************************/
/* Grid */
/************************************************************************/
/// If set to 1U, the grid is drawn on the gray image (unsigned,[0,1]:0,RW).
Grid_DrawOnGrayImage = 0x00230000,
/// If set to 1U, the grid is drawn with MLA calibration instead of MLI calibration (unsigned,[0,1]:0,RW).
Grid_DrawMlaGrid,
/************************************************************************/
/* Color */
/************************************************************************/
/// The color mode (enum,[EColorMode]:EColorMode::Manual,RW).
DepthMap_Color_Mode = 0x00350000,
/// The minimum color value given in millimeters in reference frame (double,[-,-]:0,RW).
DepthMap_Color_Min,
/// The maximum color value given in millimeters in reference frame (double,[-,-]:10,RW).
DepthMap_Color_Max,
/// Specifies the color map used to color the depth map (enum,[EColorMap]:EColorMap::Perceptually_Uniform_Rainbow,RW).
DepthMap_Color_Map
};
#ifndef RX_MANAGED_ENUM
}
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Values that represent calibration parameters.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef RX_MANAGED_ENUM
public enum class ECalib
#else
namespace ECalib
{
enum ID
#endif
{
None = 0,
/************************************************************************/
/* Projection */
/************************************************************************/
/// Type of the viewing frustum in space 2 (enum,[Rx::CamFormat::EViewingFrustumSpace2Type]:ViewFrustSpc2Type_Orthographic,RW).
ViewingFrustumSpace2Type,
/// Is true if the camera has been master calibrated. Must be set after master calibration (unsigned,[0,1]:0,RW).
IsMasterCalibrated,
/// Is true if the camera has been metric calibrated (unsigned,[0,1]:0,RO).
IsMetricCalibrated,
/// An enum constant representing the light field collimation plane in VD (double,[-,-]:4,RW).
CollimationPlaneVD,
/// An enum constant representing the light field collimation plane in MM in the reference frame (double,[-,-]:[4 projected into the object space in the reference frame],RW).
CollimationPlaneMM_Object_Reference,
/************************************************************************/
/* Main Lens Thick */
/************************************************************************/
/// The main lens's focal length in millimeters (double,[0.1,1e5]:100.0,RW).
MainLensThick_FocalLengthMM,
/// The total focus distance in millimeters. This is the distance from the sensor plane to the focus plane (double,[-,-]:500.0,RW).
MainLensThick_TotalFocusDistanceMM,
/// The magnification described by the used main lens (double,[0,1e9]: 0.38196601125010515179541316563436, RW).
MainLensThick_Magnification,
/// The nominal main lens's focal length in millimeters (double,[0.1,1e5]:100.0,RW).
MainLensThick_NominalFocalLengthMM,
/// The nominal total focus distance in millimeters. This is the distance from the sensor plane to the focus plane (double,[-,-]:500.0,RW).
MainLensThick_NominalFocusDistanceMM,
/// The nominal magnification described by the used main lens (double,[0,1e9]: 0.38196601125010515179541316563436, RW).
MainLensThick_NominalMagnification,
/************************************************************************/
/* Sensor */
/************************************************************************/
/// The size of the camera sensor. This is always the complete sensor size, even if the image only shows part of the whole original sensor image (double[2],[0,-]:[image width,image height] RW).
Sensor_TotalSizeMM,
/// The sensor size in millimeters that corresponds to the size of image that is stored with this format (double[2], [0,-]:[image width,image height],RW).
Sensor_SizeMM,
/// The sensor offset in millimeters. This is the vector from the center of the total sensor which is the origin of ordinates to the center of the actual sensor size in the sensor frame (double[2],[0,-]:(0.0,0.0),RW).
Sensor_OffsetMM_s,
/// The sensors pixel size in mm. (double,[0.0,1.0]:0.09,RW).
Sensor_PhysicalPixelSizeMM,
/************************************************************************/
/* Virtual Camera */
/************************************************************************/
/// Offset of image center of virtual camera in plane perpendicular to z-axis of main lens from center of main lens in millimeters (double[2],-:(0.0,0.0),RW).
ViewCam_Pinhole_ViewOffsetMM_g,
/// The zoom factor. A zoom factor of zero sets the viewing frustum to that of the main lens (double,[-2.0,2,0]:0.0,RW).
ViewCam_Pinhole_ViewZoomFactor,
/// Disables (0) / Enables (1) the Landscape Mode for the virtual Camera (unsigned,[0,1]:1,RW).
ViewCam_Pinhole_LandscapeMode,
/// Set the Sensor Scaling mode for the virtual Camera. Has to be one of the values defined in EVirtCamSensorScaling (enum,[Rx::CamFormat::EVirtCamSensorScaling]:VirtCam_Sensor_Scale_InnerRect,RW).
ViewCam_Pinhole_SensorScaling,
/// The virtual sensor size factor. This determines the size of the virtual camera's sensor with respect to the plenoptic camera's physical sensor size.
/// The virtual camera's sensor size is equal to this factor times the plenoptic camera's sensor size (double,[0.1,1000]:1.0,RW).
ViewCam_Pinhole_SensorSizeFactor,
/// The rotation of the virtual camera about its z-axis in degrees in a CCW sense (double,[0.0,360.0]:0.0,RO).
ViewCam_Pinhole_ViewRotationDEG,
/// The extended frustum of the virtual camera given in 6 coordinates: 1 = bottom/left/near, 2 = top/right/near, 3 = bottom/left/far, 4 = top/right/far, 5 = bottom/left/furthest, 6 = top/right/furthest (double[18],-:-,RO).
ViewCam_Pinhole_FrustumMM_g,
/************************************************************************/
/* Transformations */
/************************************************************************/
/// This describes the transformation from the global frame to the sensor frame: The first three entries are the translation and the following nine entries are the rotation (row wise) (double[12],[-1.0,1.0]:(0.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0),RW).
Transformation_Global_Sensor,
/// This describes the transformation from the global frame to the reference frame: The first three entries are the translation and the following nine entries are the rotation (row wise) (double[12],[-1.0,1.0]:(0.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0),RW).
RefPlane_Position,
/// This parameter allows the setting of the reference to global transformation with 3 points picked in the reference plane to be. (double[9],[-,-]:-,WO).
RefPlane_Position_FromPoints,
/// This parameter allows the adjusting of the reference plane position, by translating the reference plane along its z axis relative to the TCP origin. (double,[-,-]:-,RW).
RefPlane_ZOffsetToTCP,
/************************************************************************/
/* MLA Physical */
/************************************************************************/
/// The nominal MLA lens pitch in pixels. This is the distance between neighboring micro lens centers. The nominal lens pitch serves as an initial start for further more precise calibrations. This sets the automatically computed homography (double,[0.0,-]:23.0,RW).
MLA_NominalLensPitchPX,
/// The nominal MLA center in pixels on PXA (double[2],[-,-]:(0.0,0.0),RW).
MLA_NominalCenterPX_pxa,
/// The nominal MLA center in pixels on screen frame (double[2],[-,-]:-,RW).
MLA_NominalCenterPX_screen,
/// Number of 90 degree CCW rotation steps of the MLA, with respect to the standard orientation. (unsigned,[0,3]:0,RW).
MLA_Rotation90Count,
/// If true the MLA frame X-axis is inverted with the respect to the standard orientation (unsigned,[0,1]:0,RW).
MLA_InvertAxisX,
/// If true the MLA frame Y-axis is inverted with the respect to the standard orientation (unsigned,[0,1]:0,RW).
MLA_InvertAxisY,
/// Number of micro lens types on the MLA (unsigned,[0,12]:-,RW).
MLA_LensTypeCount,
/// Minimal virtual depth values from where on the corresponding micro lens type gives in-focus images.(double[12],[0.0,-]:(1.0,2.8,3.8),RW).
MLA_FocusRangeMinVD,
/// Maximal virtual depth values until where the corresponding micro lens type gives in-focus images (double[12],[0.0,-]:(3.0,4.0,100.0),RW).
MLA_FocusRangeMaxVD,
/// The nominal orthogonal distance between a micro-lens's optical center and the sensor. This may be different for each micro lens type. The values are given in millimeters (double[12],[0.0,-]:-,RO).
MLA_NominalMlaSensorDistanceMM,
/// Is true if the camera's MLA to sensor distance has been configured and must not be changed. Must be set after configuration of the true nominal MLA to sensor distances of the physical MLA. Setting this property copies the nominal MLA to sensor distance to calibrated MLA to sensor distance. (unsigned,[0,1]:0,RW).
MLA_IsMlaDistanceConfigured,
/// The nominal orthogonal distance between the micro-lenses of type 1 to the sensor. This may be different for each micro lens type. The values are given in millimeters (MM). This parameter describes the Length of 1VD in MM. (double,[> 0,-]:-,RW)
MLA_NominalSensorDistanceToLensType1MM,
///
/// The normalized offsets of lens type 0 and 2 to lens type 1. To calculate the Mla to sensor distances in MM for 0, 1 or 2:
/// double dMlaToSensorDistance0MM = (1 + vdLensTypeOffsetsToLensType1VD.x) * dSensorDistanceToLensType1MM;
/// double dMlaToSensorDistance1MM = dSensorDistanceToLensType1MM;
/// double dMlaToSensorDistance2MM = (1 + vdLensTypeOffsetsToLensType1VD.y) * dSensorDistanceToLensType1MM;
/// (double[2],[0,-]:-,RW)
///
MLA_LensTypeOffsetsToLensType1VD,
/************************************************************************/
/* MLA Calibration */
/************************************************************************/
/// The orthogonal distance between a micro-lens's optical center and the sensor. This may be different for each micro lens type. The values are given in millimeters. (double[12],[0.0,-]:-,RO).
MLA_MlaSensorDistanceMM,
/// Is true if this MLA has been calibrated automatically. (unsigned,[0,1]:0,RO).
MLA_IsAutoCalibrated,
/// The orthogonal distance between the micro-lenses of type 1 to the sensor. This may be different for each micro lens type. The values are given in millimeters (MM). This parameter describes the Length of 1VD in MM.(double,[> 0,-]:-,RW)
MLA_SensorDistanceToLensType1MM,
/************************************************************************/
/* MLI Calibration */
/************************************************************************/
/// The MLI micro lens pitch in Pixel. This is the distance between neighboring micro lens centers (double,[0.0,-]:0.0,RW).
MLI_ManualLensPitchPX = 0x00220200,
/// The MLI center in pixels on PXA (double[2],[0.0,-]:0.0,RW).
MLI_ManualCenterPX_pxa,
/// The MLI center in pixels on sensor frame (double[2],[0.0,-]:-,RW).
MLI_ManualCenterPX_s,
/// The MLI rotation in radians from sensor frame to MLA frame (double,[0.0,-]:0.0,RW).
MLI_ManualRotationRAD,
/// The MLI border in lens units. This Values defines the region of interest in various algorithms (double,[0.0,1000.0]:1.0,RW).
MLI_BorderLU,
/// The MLA lens gap in pixels. The micro lens diameter is the micro lens pitch minus this gap (double,[0.0,-]:0.0,RW).
MLI_LensGapPX,
/// The MLA lens border in pixels. The effectively usable micro lens diameter is the micro lens diameter minus twice this border (double,[0.0,-]:-,RW).
MLI_LensBorderPX,
/// Is true if this MLI has been calibrated manually or automatically (unsigned,[0,1]:0,RO).
MLI_IsCalibrated,
/// Is true if this MLI has been calibrated automatically. The manual MLI parameters aren't used (unsigned,[0,1]:0,RO).
MLI_IsAutoCalibrated,
/// Minimal virtual depth that allow a full refocus without gaps. The parameter MLA_FocusRangeMinVD describes the absolute minimal virtual depth but is affected by the current calibration. The affected value is returned by this parameter (double,[-,-]:0.0,RO).
MLI_FocusEffectiveMinVD,
/// Minimal mm in object space that allow a full refocus without gaps. The parameter MLA_FocusRangeMinVD describes the absolute minimal virtual depth but is affected by the current calibration. The affected value is returned by this parameter. (double,[-,-]:-,RO).
MLI_FocusEffectiveMinMM_ObjectSpace,
};
#ifndef RX_MANAGED_ENUM
}
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Values that represent metric calibration parameter.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef RX_MANAGED_ENUM
public enum class EMetricCalib
#else
namespace EMetricCalib
{
enum ID
#endif
{
None = 0,
/// Store the refocused image (unsigned,[0,1]:0,RW).
Enable_StoreRefocusedImage,
/// flag for calibration of the focal length (unsigned,[0,1]:1,RW).
Enable_FocalLength,
/// Flag for calibration of optical axis (unsigned,[0,1]:1,RW).
Enable_OpticalAxis,
/// Flag for calibration of principal point (unsigned,[0,1]:1,RW).
Enable_PrinciplePoint,
/// Flag for calibration of MLA to sensor distance (unsigned,[0,1]:1,RW).
Enable_MLAToSensorDistance,
/// Flag for distortion center (unsigned,[0,1]:1,RW).
Enable_Dist_Center,
/// Flag for radial distortion const (unsigned,[0,1]:0,RW).
Enable_RadialPolyConst,
/// Flag for radial distortion (unsigned,[0,1]:1,RW).
Enable_RadialPoly,
/// Flag for depth distortion (unsigned,[0,1]:1,RW).
Enable_DepthPoly,
/// Flag for axial distortion (unsigned,[0,1]:1,RW).
Enable_AxialPoly,
/// Flag for data output. This comprises information of the added images and their resultant models (planar and test). The calibration log, depth (intermediate) images and image sequence. (unsigned,[0,1]:0,RW).
Enable_DataOutput,
/// Number of calibration iterations (unsigned,[0,1]:50,RW).
CalibrationIterationCount,
/// Smooth radius for test model filter (unsigned,[0,1]:3,RW).
TestModelFilter_SmoothRadius,
/// Maximal number of point outliers that can be filtered. Test models with more outliers points are not filtered. (double,[0.0,1.0]:0.1,RW).
TestModelFilter_MaxOutlierPointsPercentage,
/// Depth threshold for test model filter (double,[0.0,1.0]:0.25,RW).
TestModelFilter_DepthStdDevThresholdVD,
/// Horizontal histogram bin count -> same for vertical (unsigned,[0,-]:15,RW).
TestModelFilter_Hist3dHorizBinCount,
/// Depth histogram bin count -> same for vertical (unsigned,[0,-]:20,RW).
TestModelFilter_Hist3dDepthBinCount,
/// Min value for depth histogram (double,[0,-]:2.0,RW).
TestModelFilter_Hist3dVirtDepthMin,
/// Max value for depth histogram (double,[TestModelFilter_Hist3dVirtDepthMin,-]:11,RW).
TestModelFilter_Hist3dVirtDepthMax,
/// Common part threshold (double,[0.0,1.0]:0.5,RW).
TestModelFilter_dHist3dCommonPartThreshold,
/// Register the metric calibration callback function (unsigned,[0,1]:0,RO).
Callback_Registered,
/// Distance of points in the model (double,[0.0,-]:2.0,RW).
ModelPointStep,
/// Initial focal length (double,-:100.0,RW).
InitialFocalLengthMM,
/// Initial total focus distance (unsigned,-:500.0,RW).
InitialTotalFocusDistanceMM,
/// The result of the last metric calibration (enum,EMetricCalibResult:None,RO).
CalibrationResult,
/// The known Z-Distance of the Dot-Target starting with 0 and following from that with relative steps (double,[0.000000,-]:0.000000,RW).
TargetZDistanceMM,
/// The export path for the additional output. (string,[-,-]:-,RW).
DataOutputPath,
};
#ifndef RX_MANAGED_ENUM
}
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Values that represent capture gray image parameters.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef RX_MANAGED_ENUM
public enum class ECaptureGrayImage
#else
namespace ECaptureGrayImage
{
enum ID
#endif
{
None = 0,
/// The number of image the actual gray image is averaged from. (unsigned, [1,-]:5,RW).
NumberOfImages,
/// The delay in seconds between each image of the gray image capturing routine (unsigned,[0,-]:0,RW).
DelayBetweenImages,
};
#ifndef RX_MANAGED_ENUM
}
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Values that represent Cuda device parameters.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef RX_MANAGED_ENUM
public enum class ECudaDevice
#else
namespace ECudaDevice
{
enum ID
#endif
{
None = 0,
/// The name of the CUDA device (string,-:-,RO).
Name,
/// The device ID of the selected CUDA device (unsigned,-:-,RO).
DeviceID,
/// The compute capability major version (unsigned,-:-,RO).
ComputeCapabilityMajor,
/// The compute capability minor version (unsigned,-:-,RO).
ComputeCapabilityMinor,
/// CUDA device total global memory in MB (double,-:-,RO).
TotalGlobalMemoryMB,
/// CUDA device total constant memory in MB (double,-:-,RO).
TotalConstMemoryMB,
/// CUDA device registers per block (unsigned,-:-,RO).
RegistersPerBlock,
/// CUDA device warp size (unsigned,-:-,RO).
WarpSize,
/// CUDA device memory pitch in MB (double,-:-,RO).
MemPitchMB,
/// CUDA device maximal number of threads per block (unsigned,-:-,RO).
MaxThreadsPerBlock,
/// CUDA device concurrent memory copy and kernel execution (unsigned,-:-,RO).
DeviceOverlap,
/// CUDA device number of processors (unsigned,-:-,RO).
MultiProcessorCount,
/// CUDA device compute mode (unsigned,-:-,RO).
ComputeMode,
/// CUDA device maximum 2D texture size x-dimension (unsigned,-:-,RO).
MaxTex2DSizeX,
/// CUDA device maximum 2D texture size y-dimension (unsigned,-:-,RO).
MaxTex2DSizeY,
/// CUDA device maximum 2D array texture size x-dimension (unsigned,-:-,RO).
MaxTex2DArraySizeX,
/// CUDA device maximum 2D array texture size y-dimension (unsigned,-:-,RO).
MaxTex2DArraySizeY,
/// CUDA device can execute kernels concurrently (unsigned,-:-,RO).
ConcurrentKernels,
/// CUDA device is a Tesla device using a TCC driver (unsigned,-:-,RO).
TCCDriver,
/// The clock frequency of the CUDA device in kilohertz (double,-:-,RO).
ClockFrequencyMHz,
/// Specified whether there is a run time limit on kernels (unsigned,-:-,RO).
KernelExecTimeoutEnabled,
/// PCI bus ID of the device (unsigned,-:-,RO).
PCIBusID,
};
#ifndef RX_MANAGED_ENUM
}
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Values that represent MLA calibration parameters.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef RX_MANAGED_ENUM
public enum class EMlaCalib
#else
namespace EMlaCalib
{
enum ID
#endif
{
None = 0,
/// Correlation patch radius (unsigned,[2,5]:3,RW).
Depth_PatchDiameter,
/// Correlation patch stride (unsigned,[1,5]:2,RW).
Depth_PatchStride,
/// Number of paths per depth path job. Values: (unsigned,[1,2]:1,RW).
Depth_NumberOfPaths,
/// Minimal correlation threshold (double,[0.0,1.0]:0.88,RW).
Depth_MinCorrelation,
/// The minimum variance. (double,[0.0,1.0]:0.0,RW).
Depth_MinVariance,
/// Minimum virtual depth for depth estimation (double,[2.0,100.0]:2.0,RW).
Depth_MinVirtualDepth,
/// Maximum virtual depth for depth estimation (double,[2.0,100.0]:15.0,RW).
Depth_MaxVirtualDepth,
/// True to use a polynomial fit to find the best correlation between two match points.(unsigned, [0,1]:1, RW).
Depth_UsePolynomialFit,
/// A lens filter mask to disable (1) or enable (0) certain lens types during depth estimation (unsigned[12],[0,1]:0,RW).
Depth_LensFilterMask,
/// Number of calibration iterations (unsigned,[1,-]:5,RW).
Algorithm_IterationCount,
/// If the error reached its stop criterion the calibration is aborted. (double,[0.0,1.0]:1e-6,RW).
Algorithm_ErrorStopCriterion,
/// The inner part in percentage that should be used to calibrate the MLA. (unsigned, [0,100]:95, RW).
Algorithm_InnerImagePartPercentage,
/// The pixel step in which the ROI should be sampled.(unsigned, [1,-]:1, RW).
Algorithm_PixelStep,
/// The MLA scale factor. (double,[0.0,1.0]:1.0,RW)
Algorithm_MlaScaleFactor,
/// true to use linear interpolation for reference depth (unsigned, [0,1]:1, RW).
Algorithm_UseLinearInterpolationForReferenceDepth,
/// true to use the median for the offset calculation (Within the algorithm and the final end outcome), false to use mean (unsigned, [0,1]:1, RW).
Algorithm_UseMedian,
/// true to write debug data to DebugOutputPath (unsigned, [0,1]:0, RW).
WriteDebugData,
/// Full base pathname of the debug output files. (string,[-,-]:-,RW)
DebugOutputPath,
};
#ifndef RX_MANAGED_ENUM
}
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// The main parameter enum of the Raytrix ApiLF.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef RX_MANAGED_ENUM
public enum class EApiLF
#else
namespace EApiLF
{
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// The main parameter enum of the Raytrix ApiLF.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum ID
#endif
{
None = 0,
/// Number of cameras available (unsigned,-:-,RO).
Cam_Count = 0x00020000,
/// Automatically store frames captured from a camera into the bound ray sequence in write mode (unsigned,[0,1]:0,RW).
RaySeq_AutoStoreCamFrames = 0x00060000,
/// Image stacking enabled (unsigned,[0,1]:0, RW).
ImgStack_StackingEnabled = 0x00340000,
/// Number of images to stack (unsigned,[1,1000]:4, RW).
ImgStack_StackCount,
};
#ifndef RX_MANAGED_ENUM
}
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Values that represent super resolution parameters.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef RX_MANAGED_ENUM
public enum class ESuperResolution
#else
namespace ESuperResolution
{
enum ID
#endif
{
None = 0,
/// The super resolution scale. (unsigned,[2,20]:3, RW).
Scale,
/// The number of iterations of the super resolution algorithm. (unsigned,[1,200]:20, RW).
Iterations,
/// Radius of the temporal search area. Where 0 sets the algorithm to automatic mode. (unsigned,[0,-]:0, RW).
TemporalRadius,
/// An enum constant representing the optical flow algorithm option. (enum,[Rx::EOpticalFlowType]:Rx::EOpticalFlowType::Farneback,RW).
OpticalFlowAlgorithm,
};
#ifndef RX_MANAGED_ENUM
}
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Values that represent high resolution particle detector parameters.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef RX_MANAGED_ENUM
public enum class EHighResolutionParticleDetector
#else
namespace EHighResolutionParticleDetector
{
enum ID
#endif
{
None = 0,
/************************************************************************/
/* DEPRECATED Feature Detection DEPRECATED */
/************************************************************************/
FD_InititalVariance = 1,
/// Feature detector: Ratio of pixels that have to be smaller pixel value to accept position as maximum. Evaluation area is given by uiHalfWinsizeMinMaxRatio (double,[0,-]:0.8,RW).
FD_MinMaxRatio = 2,
/// Feature detector: Half window size to determine maximum ratio.(unsigned,[1,-]:2,RW)
FD_HalfWinsizeMinMaxRatio = 3,
///
/// Feature detector:
/// Half window size to cluster maxima. Maxima within window around active pixel are considered to be the same maximum.
/// (unsigned,[1,-]:2,RW)
///
FD_HalfWinsizeMaxCluster = 4,
/// Feature detector: Size of the patch image.(unsigned,[1,-]:10,RW)
FD_HalfPatchSize = 5,
/************************************************************************/
/* Depth */
/************************************************************************/
/// Depth: Minimal correlation threshold (double,[0.0,1.0]:0.90,RW).
Depth_MinCorrelation = 6,
/// Depth: Minimal standard deviation of correlation patch (double,[0.0,1.0]:0.01,RW).
Depth_MinStdDeviation = 7,
/// Depth correlation patch size (unsigned,[2,5]:5,RW).
Depth_PatchSize = 8,
/************************************************************************/
/* Super Resolution */
/************************************************************************/
/// Super Resolution: The upscaling factor. (unsigned,[2,20]:2, RW).
SRScale = 9,
/// Super Resolution: The radius of the source patch.(unsigned,[2,-]:6, RW)
SRPatchRadius = 10,
/// The number of iterations of the super resolution algorithm. (unsigned,[1,200]:1, RW).
SRIterations = 11,
/// Super Resolution: The lower bound for source patches of lens type 1, that are used for super resolution regarding virtual depth. (double,[0.0,100.0]:1.0,RW)
SRFilterMinVdLens1 = 12,
/// Super Resolution: The upper bound for source patches of lens type 1, that are used for super resolution regarding virtual depth. (double,[0.0,100.0]:3.0,RW)
SRFilterMaxVdLens1 = 13,
/// Super Resolution: The lower bound for source patches of lens type 2, that are used for super resolution regarding virtual depth. (double,[0.0,100.0]:2.0,RW)
SRFilterMinVdLens2 = 14,
/// Super Resolution: The upper bound for source patches of lens type 2, that are used for super resolution regarding virtual depth. (double,[0.0,100.0]:4.0,RW)
SRFilterMaxVdLens2 = 15,
/// Super Resolution: The lower bound for source patches of lens type 3, that are used for super resolution regarding virtual depth. (double,[0.0,100.0]:3.8,RW)
SRFilterMinVdLens3 = 16,
/// Super Resolution: The upper bound for source patches of lens type 3, that are used for super resolution regarding virtual depth. (double,[0.0,100.0]:100.0,RW)
SRFilterMaxVdLens3 = 17,
/// Super Resolution: Min lens border distance. (unsigned,[0,-]:3,RW)
SRMinLensBorderDistance = 18,
/************************************************************************/
/* Feature Detection */
/************************************************************************/
FD_MaxFeaturesPerDetection = 19,
FD_FeatureQuality = 20,
FD_MinDistance = 21,
FD_PatchSize = 22,
FD_StrongFeaturesOnly = 23,
FD_Strongness = 24,
/************************************************************************/
/* Filter */
/************************************************************************/
MinMotionParticleMM = 25,
MaxMotionParticleMM = 26,
MaxDepthMotionParticleMM = 27,
MinMotionAngleDegree = 28,
MinSpanTrackMM = 29,
ParticleSimilarityMM_s = 30,
ParticleSimilarityColorPercentage = 31,
MaxMotionDifferencePercentage = 32,
TrusworthyTrack = 33,
MinTrackLength = 34,
MainFluidOrientation = 35,
};
#ifndef RX_MANAGED_ENUM
}
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Values that represent parameter groups.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef RX_MANAGED_ENUM
public enum class EGroup
#else
namespace EGroup
{
enum ID
#endif
{
None = 0,
/// CUDA parameter group.
Cuda = 0x00010000,
/// Camera parameter group.
Camera = 0x00020000,
/// Camera capture parameter group.
CamCap = 0x0003F000,
/// Ray image parameter group.
Ray = 0x00040000,
/// Ray sequence parameters.
RaySeq = 0x00050000,
/// PreProcessing parameter group.
PreProc = 0x00100000,
/// Depth evaluation parameter group.
Depth = 0x00200000,
/// Depth Path algorithm.
Depth_Path = 0x00203000,
/// Focus evaluation parameter group.
Focus = 0x00220000,
/// Grid display parameter group.
Grid = 0x00230000,
/// Grid calibration parameter group.
Grid_Calibration = 0x00240000,
/// Projection parameter group.
Projection = 0x00310000,
/// MLA parameter group.
MLA = 0x00320000,
/// Metric calibration parameter group.
MC = 0x00330000,
/// Gray image capturing properties.
Gray = 0x00340000,
/// The light field camera.
LF_Camera = 0x00350000,
/// The Mla calibration parameter group.
MlaCalibration = 0x00360000,
/// The particle tracking parameter group.
ParticleTracking = 0x00370000,
/// The Super resolution parameter group.
SuperResolution = 0x00380000,
/// The high resolution particle detector parameter group
HighResolutionParticleDetector = 0x00390000,
};
#ifndef RX_MANAGED_ENUM
}
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Values that represent particle tracking parameter.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef RX_MANAGED_ENUM
public enum class EParticleTracking
#else
namespace EParticleTracking
{
enum ID
#endif
{
None = 0,
/// Number of processes used for 2D particle detection and time tracking.
Misc_ProcessCount,
/// Base filename for temporary particle data swap.
Misc_WorkingDirectory,
/// 0-based frame index in sequence to start processing.
Misc_SequenceStartImage,
/// 0-based frame index in sequence to stop processing.
Misc_SequenceStopImage,
/// Minimum x-component in image region to process (Region of Interest).
Misc_ImageRegion_MinX,
/// Minimum y-component in image region to process (Region of Interest).
Misc_ImageRegion_MinY,
/// Maximum x-component in image region to process (Region of Interest). 0U to use full image width.
Misc_ImageRegion_MaxX,
/// Maximum y-component in image region to process (Region of Interest). 0U to use full image height.
Misc_ImageRegion_MaxY,
/// 1U to use lens type far, 0U to omit.
Misc_UseLensTypeFar,
/// 1U to use lens type middle, 0U to omit.
Misc_UseLensTypeMiddle,
/// 1U to use lens type near, 0U to omit.
Misc_UseLensTypeNear,
///
/// The particle density setting used in 2D particle detection. Trade off between uniqueness of particles and runtime.
/// 0U : only few particles in whole image. Exhaustive computational effort for moderate or higher particle count
/// 1U : only single particles in each lens. Exhaustive computational effort for high particle count
/// 2U : multiple particles per lens over large parts of the image. Least effort, possible multi detection of particles
///
ImageProc_ParticleDensity,
/// The minimum particle radius constraint for 2D particle detection. [0.1 ... 20]
ImageProc_MinParticleRadiusPX,
/// The maximum particle radius constraint for 2D particle detection. [0.1 ... 20]
ImageProc_MaxParticleRadiusPX,
ImageProc_MinParticleBrightness,
/// The maximum particles per lens constraint for 2D particle detection. Lenses with more 2D particles are not used in 3D estimation.
ImageProc_MaxParticlesPerLens,
/// 1U to use processed image instead of raw image for particle detection.
ImageProc_UseProcessedImage,
/// 1U to use background image subtraction. An BG image has to be available.
ImageProc_UseBackgroundImage,
/// 0-based start index for BG image computation.
ImageProc_BackgroundImageStartIndex,
/// 0-based stop index for BG image computation.
ImageProc_BackgroundImageStopIndex,
/// Set 1U to use radius and scale of particles for time matching instead of nearest neighbor.
Tracking_UseVisualTimeTracking,
/// The time delta for velocity estimation (in PIV mode the double-shoot delay).
Tracking_ImageTimeDelta,
/// 1U : Time matching only for succeeding image pairs (1 to 2 ; 3 to 4 ...).
Tracking_PivMode,
/// The maximum epipolar line distance constraint for 2D particle grouping.
Depth_MaxEpilineDistancePX,
};
#ifndef RX_MANAGED_ENUM
}
#endif
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// namespace: Interfaces
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
namespace Interfaces
{
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Values that represent image queue interfaces.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef RX_MANAGED_ENUM
public enum class EImageQueue
#else
namespace EImageQueue
{
enum ID
#endif
{
None = 0,
};
#ifndef RX_MANAGED_ENUM
}
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Values that represent parameter interfaces.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef RX_MANAGED_ENUM
public enum class EParameters
#else
namespace EParameters
{
enum ID
#endif
{
None = 0,
};
#ifndef RX_MANAGED_ENUM
}
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Values that represent ray file reader interfaces.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef RX_MANAGED_ENUM
public enum class ERayFileReader
#else
namespace ERayFileReader
{
enum ID
#endif
{
None = 0,
};
#ifndef RX_MANAGED_ENUM
}
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Values that represent ray file writer interfaces.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef RX_MANAGED_ENUM
public enum class ERayFileWriter
#else
namespace ERayFileWriter
{
enum ID
#endif
{
None = 0,
};
#ifndef RX_MANAGED_ENUM
}
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Values that represent sequence file reader interfaces.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef RX_MANAGED_ENUM
public enum class ESeqFileReader
#else
namespace ESeqFileReader
{
enum ID
#endif
{
None = 0,
};
#ifndef RX_MANAGED_ENUM
}
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Values that represent sequence file writer interfaces.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef RX_MANAGED_ENUM
public enum class ESeqFileWriter
#else
namespace ESeqFileWriter
{
enum ID
#endif
{
None = 0,
};
#ifndef RX_MANAGED_ENUM
}
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Values that represent camera interfaces.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef RX_MANAGED_ENUM
public enum class ECamera
#else
namespace ECamera
{
enum ID
#endif
{
None = 0,
/// Access to IP camera functions: The interface is IIPCamera.
IPCamera,
};
#ifndef RX_MANAGED_ENUM
}
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Values that represent camera server interfaces.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef RX_MANAGED_ENUM
public enum class ECameraServer
#else
namespace ECameraServer
{
enum ID
#endif
{
None = 0,
};
#ifndef RX_MANAGED_ENUM
}
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Values that represent calibration interfaces.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef RX_MANAGED_ENUM
public enum class ECalib
#else
namespace ECalib
{
enum ID
#endif
{
None = 0,
};
#ifndef RX_MANAGED_ENUM
}
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Values that represent calibration manager interfaces.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef RX_MANAGED_ENUM
public enum class ECalibManager
#else
namespace ECalibManager
{
enum ID
#endif
{
None = 0,
};
#ifndef RX_MANAGED_ENUM
}
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Values that represent Cuda interfaces.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef RX_MANAGED_ENUM
public enum class ECuda
#else
namespace ECuda
{
enum ID
#endif
{
None = 0,
};
#ifndef RX_MANAGED_ENUM
}
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Values that represent Cuda device interfaces.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef RX_MANAGED_ENUM
public enum class ECudaDevice
#else
namespace ECudaDevice
{
enum ID
#endif
{
None = 0,
};
#ifndef RX_MANAGED_ENUM
}
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Values that represent OpenGlInterop interfaces.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef RX_MANAGED_ENUM
public enum class EOpenGlInterop
#else
namespace EOpenGlInterop
{
enum ID
#endif
{
None = 0,
};
#ifndef RX_MANAGED_ENUM
}
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Values that represent Cuda compute interfaces.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef RX_MANAGED_ENUM
public enum class ECudaCompute
#else
namespace ECudaCompute
{
enum ID
#endif
{
None = 0,
/// Access to CUDA images: The interface is ICudaDataImages.
Images,
/// Access to CUDA textures: The interface is ICudaDataTextures.
Textures,
};
#ifndef RX_MANAGED_ENUM
}
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Values that represent images processing unit interfaces.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef RX_MANAGED_ENUM
public enum class EImageProcUnit
#else
namespace EImageProcUnit
{
enum ID
#endif
{
None = 0,
};
#ifndef RX_MANAGED_ENUM
}
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Values that represent param cache interfaces.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef RX_MANAGED_ENUM
public enum class EParamCache
#else
namespace EParamCache
{
enum ID
#endif
{
None = 0,
};
#ifndef RX_MANAGED_ENUM
}
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Values that represent capture gray image interfaces.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef RX_MANAGED_ENUM
public enum class ECaptureGrayImage
#else
namespace ECaptureGrayImage
{
enum ID
#endif
{
None = 0,
};
#ifndef RX_MANAGED_ENUM
}
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Values that represent Export interfaces.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef RX_MANAGED_ENUM
public enum class EExport
#else
namespace EExport
{
enum ID
#endif
{
None = 0,
};
#ifndef RX_MANAGED_ENUM
}
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Values that represent grid calibration interfaces.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef RX_MANAGED_ENUM
public enum class EGridCalib
#else
namespace EGridCalib
{
enum ID
#endif
{
None = 0,
};
#ifndef RX_MANAGED_ENUM
}
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Values that represent image stacking interfaces.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef RX_MANAGED_ENUM
public enum class EImageStacking
#else
namespace EImageStacking
{
enum ID
#endif
{
None = 0,
};
#ifndef RX_MANAGED_ENUM
}
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Values that represent metric calibration interfaces.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef RX_MANAGED_ENUM
public enum class EMetricCalib
#else
namespace EMetricCalib
{
enum ID
#endif
{
None = 0,
};
#ifndef RX_MANAGED_ENUM
}
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Values that represent light field runtime interfaces.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef RX_MANAGED_ENUM
public enum class ELightFieldRuntime
#else
namespace ELightFieldRuntime
{
enum ID
#endif
{
None = 0,
};
#ifndef RX_MANAGED_ENUM
}
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Values that represent ApiLF interfaces.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef RX_MANAGED_ENUM
public enum class EApiLF
#else
namespace EApiLF
{
enum ID
#endif
{
None = 0,
CudaCompute = 1,
CudaDevice = 2,
BoundCalibration = 3,
BoundCamera = 4,
};
#ifndef RX_MANAGED_ENUM
}
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Values that represent MLA calibration interfaces.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef RX_MANAGED_ENUM
public enum class EMlaCalib
#else
namespace EMlaCalib
{
enum ID
#endif
{
None = 0,
};
#ifndef RX_MANAGED_ENUM
}
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Values that represent Depth Correction Creator interfaces.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef RX_MANAGED_ENUM
public enum class EDepthCorrectionCreator
#else
namespace EDepthCorrectionCreator
{
enum ID
#endif
{
None = 0,
};
#ifndef RX_MANAGED_ENUM
}
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Values that represent ray depth processing interfaces.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef RX_MANAGED_ENUM
public enum class ERayDepthProcessing
#else
namespace ERayDepthProcessing
{
enum ID
#endif
{
None = 0,
};
#ifndef RX_MANAGED_ENUM
}
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Values that represent super resolution interfaces.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef RX_MANAGED_ENUM
public enum class ESuperResolution
#else
namespace ESuperResolution
{
enum ID
#endif
{
None = 0,
};
#ifndef RX_MANAGED_ENUM
}
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Values that represent high resolution particle detector interfaces.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef RX_MANAGED_ENUM
public enum class EHighResolutionParticleDetector
#else
namespace EHighResolutionParticleDetector
{
enum ID
#endif
{
None = 0,
};
#ifndef RX_MANAGED_ENUM
}
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Values that represent particle tracking interfaces.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef RX_MANAGED_ENUM
public enum class EParticleTracking
#else
namespace EParticleTracking
{
enum ID
#endif
{
None = 0,
};
#ifndef RX_MANAGED_ENUM
}
#endif
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Values that represent EImage.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef RX_MANAGED_ENUM
public enum class EImage
#else
namespace EImage
{
enum ID
#endif
{
/// No image.
None = 0x000000,
/// Raw image captured by camera.
Raw = 0x000001,
/// Gray image generated by MLI calibration.
Gray = 0x000002,
/// Raw depth image without fusion.
DepthRay = 0x000004,
/// Raw image containing the MLI/MLA calibration as a drawn overlay.
Grid = 0x000008,
/// Processed ray image. Raw image after applying all pre process algorithms such as debayer etc.
Processed_Normalized = 0x000010,
/// Processed ray image.
GridData = 0x000020,
/// Basic refocus image. This is the output of the basic refocus algorithm and always from the perspective of the orthographic virtual view.
RefocusBasic = 0x000040,
/// Total Focus image of virtual space.
TotalFocus_View_Virtual = 0x000800,
/// Total Focus result image.
TotalFocus_View_Object_Pinhole = 0x001000,
/// Multiview image. This is the output of the multi view algorithm and always from the perspective of the pinhole object view.
Multiview = 0x002000,
/// Depth image in virtual space.
DepthMap_View_Virtual = 0x004000,
/// Depth result image.
DepthMap_View_Object_Pinhole = 0x008000,
/// Depth color result image for virtual space.
DepthMapColored_View_Virtual = 0x010000,
/// Depth color result image for view camera.
DepthMapColored_View_Object_Pinhole = 0x020000,
/// Depth map mapping image. This is created by RxDepth3D(). See the documentation of this function.
Depth3D = 0x040000,
};
#ifndef RX_MANAGED_ENUM
}
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Values that represent EImgStack.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef RX_MANAGED_ENUM
public enum class EImgStack
#else
namespace EImgStack
{
enum ID
#endif
{
/// No stacking.
None = 0,
/// Noise reduction by averaging the input images.
Mean,
/// Increases the exposure rate by adding all images and clamp them on maximum intensity values.
Add,
};
#ifndef RX_MANAGED_ENUM
}
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Values that represent EMetricCalibType.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef RX_MANAGED_ENUM
public enum class EMetricCalibType
#else
namespace EMetricCalibType
{
enum ID
#endif
{
/// None.
None = 0,
/// The calibration based on a calibration setup that demands tilted dot target images that reach over a large part of the depth range.
PlaneBased,
/// The calibration based on a calibration setup that demands straight dot target images that are moved along the z-axis with known steps.
BoxBased,
};
#ifndef RX_MANAGED_ENUM
}
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Values that represent EMetricCalibResult.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef RX_MANAGED_ENUM
public enum class EMetricCalibResult
#else
namespace EMetricCalibResult
{
enum ID
#endif
{
/// None.
None = 0,
/// The calibration has successfully converged.
Converged,
/// The calibration diverged.
Diverged,
/// The calibration aborted after too many iteration. This threshold can be set via: EMetricCalib::CalibrationIterationCount.
TooManyIterations,
/// The calibration aborted because the data was insufficient.
InsufficientData,
/// The calibration aborted because an user interrupt.
UserInterrupt,
/// The calibration aborted because an error occurred.
Error,
/// The calibration has been set to its initial values.
InitialValues,
};
#ifndef RX_MANAGED_ENUM
}
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Values that represent EMetricCalibPointFilter.
///
/// These enums are to be used as a filter when getting points from the metric calibration.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef RX_MANAGED_ENUM
public enum class EMetricCalibPointFilter
#else
namespace EMetricCalibPointFilter
{
enum ID
#endif
{
/// All points from the planar model.
PlanarModelAll = 0x0000,
/// All points from the planar model with an accomplished depth calculation.
PlanarModelWithDepth,
/// All points from the test model.
TestModelAll,
/// All points from the test model but those that lie on the axes.
TestModelAllButAxes,
/// All points from the test model that lie on the x-axis.
TestModelAxisX,
/// All points from the test model that lie on the y-axis.
TestModelAxisY,
};
#ifndef RX_MANAGED_ENUM
}
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Values that represent EMetricCalibPointType.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef RX_MANAGED_ENUM
public enum class EMetricCalibPointType
#else
namespace EMetricCalibPointType
{
enum ID
#endif
{
/// Index of points.
Model2dIX = 0,
/// 3D Point placed in the sensor coordinate system in mm.
Model3dMM_m,
/// 2D Point placed in the sensor coordinate system in mm.
Space2MM_s,
/// 2D Point placed in the global coordinate system in mm.
Space2MM_g,
/// Point placed in the object coordinate system in mm.
Space4MM_g,
/// Point projected on the plane.
Space4PlaneMM_g,
/// Model point in object space.
Model3dSpace4MM_g,
/// 2D Point placed in the sensor coordinate system and z in virtual depth.
Space2VD_s,
/// The first entry is the virtual depth, the second is the mm depth in space 4 in the global coordinate system and the last value in the vector is the euclidean distance of the test model point to the ground truth model point after calibration.
ErrorByDepth,
};
#ifndef RX_MANAGED_ENUM
}
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Values that represent EStatusMsgSrc.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef RX_MANAGED_ENUM
public enum class EStatusMsgSrc
#else
namespace EStatusMsgSrc
{
enum ID
#endif
{
/// Undefined.
Unknown = 0,
/// Message originates from the API.
API,
/// API Gray image capturing message.
API_GrayCapture,
/// Message originates from camera.
Camera = 0x00001000,
/// Message originates from camera.
CameraDriver,
/// Message originates from an algorithm.
Compute,
/// Message originates from an application.
App,
/// Message originates from the metric calibration.
MC_CalibrationProgress = 0x00310000,
/// Message originates from the metric calibration.
MC_CreatingModelProgress,
/// Message originates from the metric calibration.
MC_Status,
/// Message originates from the metric calibration.
MC_AcceptedModels,
/// A stage of the grid calibration has been entered.
GridCalib_Stage = 0x00320000,
/// An iteration step of a grid calibration stage has been started.
GridCalib_Iteration,
/// The root mean square error of an grid calibration iteration has been calculated.
GridCalib_RMSE,
/// A stage of the master calibration has been entered.
MasterCalib_Stage,
/// An enum constant representing the MLA calibrator option.
MlaCalibrator,
/// .
PT_ImageProcessing = 0x00330000,
PT_ParticleGrouping,
PT_Estimation3D,
PT_BackgroundImage,
};
#ifndef RX_MANAGED_ENUM
}
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Values that represent EStatusMsgGrp.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef RX_MANAGED_ENUM
public enum class EStatusMsgGrp
#else
namespace EStatusMsgGrp
{
enum ID
#endif
{
/// Undefined.
None = 0,
/// Defines the Message group Text.
Text = 0x00010000,
/// Defines the Message group Progress --> Can be used to set a progress bar correctly.
Progress = 0x00020000,
};
#ifndef RX_MANAGED_ENUM
}
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Values that represent EStatusMsg.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef RX_MANAGED_ENUM
public enum class EStatusMsg
#else
namespace EStatusMsg
{
enum ID
#endif
{
/// Undefined.
None = 0,
/************************************************************************/
/* Text group */
/************************************************************************/
/// Debug message.
Debug = (int) EStatusMsgGrp::Text,
/// A message containing information.
Info,
/// A message containing brief information.
QuickInfo,
/// A message containing error information.
Error,
/// A message containing assertions.
Assertion,
/// A message containing exception information.
Exception,
/// A message containing fatal information.
Fatal,
/// A message containing warnings.
Warning,
/************************************************************************/
/* Progress group */
/************************************************************************/
/// The number of steps in the process is passed in the iValue parameter.
Progress_Init = (int) EStatusMsgGrp::Progress,
/// The new value of the progress is passed in the iValue parameter.
Progress_Value,
/// Increment the progress by the number passed in iValue.
Progress_Step,
/// Process is finished.
Progress_Finished,
/// Progress step delayed. Delay time in seconds given by iValue.
Progress_DelayTick,
/// Progress step delay stopped.
Progress_DelayStop,
};
#ifndef RX_MANAGED_ENUM
}
#endif
#ifdef RX_MANAGED_ENUM
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Ray sequence file modes. These enums can be used as a bit mask to combine various modes.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public enum class ERaySeqMode
#else
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Ray sequence file modes. These enums can be used as a bit mask to combine various modes.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
namespace ERaySeqMode
{
enum ID
#endif
{
/// Empty ray sequence mode
None = 0x0000,
/// A ray sequence opened for reading
Read = 0x0001,
/// A ray sequence opened for writing
Write = 0x0002,
};
#ifndef RX_MANAGED_ENUM
}
#endif
#ifdef RX_MANAGED_ENUM
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Enumeratives indicating stage of progress report. I.e. 2D image processing, 3D estimation etc.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public enum class EParticleTrackingProgress
#else
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Enumeratives indicating stage of progress report. I.e. 2D image processing, 3D estimation etc.
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
namespace EParticleTrackingProgress
{
enum ID
#endif
{
ImageProcessing = 0,
DepthMatching = 1,
Grouping = 2,
Estimation3D = 3,
BGImage = 4,
GRID = 5
};
#ifndef RX_MANAGED_ENUM
}
#endif