XnStatus XnSensorDepthStream::SetMirror(XnBool bIsMirrored)
{
XnStatus nRetVal = XN_STATUS_OK;
xnOSEnterCriticalSection(GetLock());
// set firmware mirror
XnBool bFirmwareMirror = (bIsMirrored == TRUE && m_Helper.GetFirmwareVersion() >= XN_SENSOR_FW_VER_5_0);
nRetVal = m_Helper.SimpleSetFirmwareParam(m_FirmwareMirror, (XnUInt16)bFirmwareMirror);
if (nRetVal != XN_STATUS_OK)
{
xnOSLeaveCriticalSection(GetLock());
return (nRetVal);
}
// update prop
nRetVal = XnDepthStream::SetMirror(bIsMirrored);
xnOSLeaveCriticalSection(GetLock());
XN_IS_STATUS_OK(nRetVal);
if (m_depthUtilsHandle != NULL)
{
nRetVal = DepthUtilsSetDepthConfiguration(m_depthUtilsHandle, GetXRes(), GetYRes(), GetOutputFormat(), IsMirrored());
XN_IS_STATUS_OK(nRetVal);
}
return (XN_STATUS_OK);
}
XnStatus XnSensorDepthStream::SetOutputFormat(OniPixelFormat nOutputFormat)
{
XnStatus nRetVal = XN_STATUS_OK;
switch (nOutputFormat)
{
case ONI_PIXEL_FORMAT_SHIFT_9_2:
case ONI_PIXEL_FORMAT_DEPTH_1_MM:
nRetVal = DeviceMaxDepthProperty().UnsafeUpdateValue(XN_DEVICE_SENSOR_MAX_DEPTH_1_MM);
break;
case ONI_PIXEL_FORMAT_DEPTH_100_UM:
nRetVal = DeviceMaxDepthProperty().UnsafeUpdateValue(XN_DEVICE_SENSOR_MAX_DEPTH_100_UM);
break;
default:
XN_LOG_WARNING_RETURN(XN_STATUS_DEVICE_BAD_PARAM, XN_MASK_DEVICE_SENSOR, "Unsupported depth output format: %d", nOutputFormat);
}
XN_IS_STATUS_OK(nRetVal);
nRetVal = m_Helper.BeforeSettingDataProcessorProperty();
XN_IS_STATUS_OK(nRetVal);
nRetVal = XnDepthStream::SetOutputFormat(nOutputFormat);
XN_IS_STATUS_OK(nRetVal);
nRetVal = m_Helper.AfterSettingDataProcessorProperty();
XN_IS_STATUS_OK(nRetVal);
if (m_depthUtilsHandle != NULL)
{
nRetVal = DepthUtilsSetDepthConfiguration(m_depthUtilsHandle, GetXRes(), GetYRes(), GetOutputFormat(), IsMirrored());
XN_IS_STATUS_OK(nRetVal);
}
return (XN_STATUS_OK);
}
XnUInt32 XnSensorImageStream::CalculateExpectedSize()
{
XnUInt32 nExpectedImageBufferSize = GetXRes() * GetYRes();
// when cropping is turned on, actual IR size is smaller
const XnCropping* pCropping = GetCropping();
if (pCropping->bEnabled)
{
nExpectedImageBufferSize = pCropping->nXSize * pCropping->nYSize;
}
switch (m_InputFormat.GetValue())
{
case XN_IO_IMAGE_FORMAT_YUV422:
case XN_IO_IMAGE_FORMAT_UNCOMPRESSED_YUV422:
// in YUV each pixel is represented in 2 bytes (actually 2 pixels are represented by 4 bytes)
nExpectedImageBufferSize *= 2;
break;
case XN_IO_IMAGE_FORMAT_BAYER:
// each pixel is one byte.
break;
case XN_IO_IMAGE_FORMAT_JPEG:
// image should be in RGB now - 3 bytes a pixel
nExpectedImageBufferSize *= 3;
break;
default:
XN_LOG_WARNING_RETURN(XN_STATUS_ERROR, XN_MASK_DEVICE_SENSOR, "Does not know to calculate expected size for input format %d", m_InputFormat.GetValue());
}
return nExpectedImageBufferSize;
}
XnStatus XnPixelStream::FixCropping()
{
XnStatus nRetVal = XN_STATUS_OK;
XnCropping cropping = *GetCropping();
if (cropping.nXOffset > GetXRes() ||
cropping.nYOffset > GetYRes() ||
XnUInt32(cropping.nXOffset + cropping.nXSize) > GetXRes() ||
XnUInt32(cropping.nYOffset + cropping.nYSize) > GetYRes())
{
// disable it
cropping.bEnabled = FALSE;
nRetVal = SetCropping(&cropping);
XN_IS_STATUS_OK(nRetVal);
}
return (XN_STATUS_OK);
}
XnStatus XnPixelStream::FixCropping()
{
XnStatus nRetVal = XN_STATUS_OK;
OniCropping cropping = *GetCropping();
if (cropping.originX > (int)GetXRes() ||
cropping.originY > (int)GetYRes() ||
(cropping.originX + cropping.width) > (int)GetXRes() ||
(cropping.originY + cropping.height) > (int)GetYRes())
{
// disable it
cropping.enabled = FALSE;
nRetVal = SetCropping(&cropping);
XN_IS_STATUS_OK(nRetVal);
}
return (XN_STATUS_OK);
}
XnStatus XnPixelStream::ValidateCropping(const OniCropping* pCropping)
{
if (pCropping->enabled)
{
if (pCropping->originX > (int)GetXRes() ||
XnUInt32(pCropping->originX + pCropping->width) > GetXRes() ||
pCropping->originY > (int)GetYRes() ||
XnUInt32(pCropping->originY + pCropping->height) > GetYRes())
{
XN_LOG_WARNING_RETURN(XN_STATUS_DEVICE_BAD_PARAM, XN_MASK_DDK, "Cropping values do not match stream resolution!");
}
if (pCropping->width == 0 || pCropping->height == 0)
{
XN_LOG_WARNING_RETURN(XN_STATUS_DEVICE_BAD_PARAM, XN_MASK_DDK, "Cannot set a cropping window of zero size!");
}
}
return (XN_STATUS_OK);
}
XnStatus XnSensorIRStream::CalcRequiredSize(XnUInt32* pnRequiredSize) const
{
// in IR, in all resolutions except SXGA, we get additional 8 lines
XnUInt32 nYRes = GetYRes();
if (GetResolution() != XN_RESOLUTION_SXGA)
{
nYRes += 8;
}
*pnRequiredSize = GetXRes() * nYRes * GetBytesPerPixel();
return XN_STATUS_OK;
}
XnStatus XnPixelStream::ValidateCropping(const XnCropping* pCropping)
{
XnStatus nRetVal = XN_STATUS_OK;
if (pCropping->bEnabled)
{
if (pCropping->nXOffset > GetXRes() ||
XnUInt32(pCropping->nXOffset + pCropping->nXSize) > GetXRes() ||
pCropping->nYOffset > GetYRes() ||
XnUInt32(pCropping->nYOffset + pCropping->nYSize) > GetYRes())
{
XN_LOG_WARNING_RETURN(XN_STATUS_DEVICE_BAD_PARAM, XN_MASK_DDK, "Cropping values do not match stream resolution!");
}
if (pCropping->nXSize == 0 || pCropping->nYSize == 0)
{
XN_LOG_WARNING_RETURN(XN_STATUS_DEVICE_BAD_PARAM, XN_MASK_DDK, "Cannot set a cropping window of zero size!");
}
}
return (XN_STATUS_OK);
}
XnStatus XnPixelStream::SetYRes(XnUInt32 nYRes)
{
XnStatus nRetVal = XN_STATUS_OK;
XnResolutions res = XnDDKGetResolutionFromXY(GetXRes(), nYRes);
// set resolution (this will also set X and Y resolution)
nRetVal = SetResolution(res);
XN_IS_STATUS_OK(nRetVal);
if (res == XN_RESOLUTION_CUSTOM)
{
// update Y res ourselves
nRetVal = m_YRes.UnsafeUpdateValue(nYRes);
XN_IS_STATUS_OK(nRetVal);
}
return (XN_STATUS_OK);
}
XnStatus XnPixelStream::CropImpl(OniFrame* pFrame, const OniCropping* pCropping)
{
XnUChar* pPixelData = (XnUChar*)pFrame->data;
XnUInt32 nCurDataSize = 0;
for (XnUInt32 y = pCropping->originY; y < XnUInt32(pCropping->originY + pCropping->height); ++y)
{
XnUChar* pOrigLine = &pPixelData[y * GetXRes() * GetBytesPerPixel()];
// move line
xnOSMemCopy(pPixelData + nCurDataSize, pOrigLine + pCropping->originX * GetBytesPerPixel(), pCropping->width * GetBytesPerPixel());
nCurDataSize += pCropping->width * GetBytesPerPixel();
}
// update size
pFrame->dataSize = nCurDataSize;
return XN_STATUS_OK;
}
XnStatus XnPixelStream::CropImpl(XnStreamData* pStreamOutput, const XnCropping* pCropping)
{
XnStatus nRetVal = XN_STATUS_OK;
XnUChar* pPixelData = (XnUChar*)pStreamOutput->pData;
XnUInt32 nCurDataSize = 0;
for (XnUInt32 y = pCropping->nYOffset; y < XnUInt32(pCropping->nYOffset + pCropping->nYSize); ++y)
{
XnUChar* pOrigLine = &pPixelData[y * GetXRes() * GetBytesPerPixel()];
// move line
xnOSMemCopy(pPixelData + nCurDataSize, pOrigLine + pCropping->nXOffset * GetBytesPerPixel(), pCropping->nXSize * GetBytesPerPixel());
nCurDataSize += pCropping->nXSize * GetBytesPerPixel();
}
// update size
pStreamOutput->nDataSize = nCurDataSize;
return XN_STATUS_OK;
}
XnStatus XnSensorDepthStream::SetResolution(XnResolutions nResolution)
{
XnStatus nRetVal = XN_STATUS_OK;
nRetVal = m_Helper.BeforeSettingFirmwareParam(ResolutionProperty(), (XnUInt16)nResolution);
XN_IS_STATUS_OK(nRetVal);
nRetVal = XnDepthStream::SetResolution(nResolution);
XN_IS_STATUS_OK(nRetVal);
nRetVal = m_Helper.AfterSettingFirmwareParam(ResolutionProperty());
XN_IS_STATUS_OK(nRetVal);
if (m_depthUtilsHandle != NULL)
{
nRetVal = DepthUtilsSetDepthConfiguration(m_depthUtilsHandle, GetXRes(), GetYRes(), GetOutputFormat(), IsMirrored());
XN_IS_STATUS_OK(nRetVal);
}
return (XN_STATUS_OK);
}
XnStatus XnSensorIRStream::SetCroppingImpl(const OniCropping* pCropping, XnCroppingMode mode)
{
XnStatus nRetVal = XN_STATUS_OK;
XnFirmwareCroppingMode firmwareMode = m_Helper.GetFirmwareCroppingMode(mode, pCropping->enabled);
nRetVal = ValidateCropping(pCropping);
XN_IS_STATUS_OK(nRetVal);
xnOSEnterCriticalSection(GetLock());
if (m_Helper.GetFirmwareVersion() > XN_SENSOR_FW_VER_3_0)
{
nRetVal = m_Helper.StartFirmwareTransaction();
if (nRetVal != XN_STATUS_OK)
{
xnOSLeaveCriticalSection(GetLock());
return (nRetVal);
}
// mirror is done by software (meaning AFTER cropping, which is bad). So we need to flip the cropping area
// to match requested area.
XnUInt16 nXOffset = (XnUInt16) pCropping->originX;
if (IsMirrored())
{
nXOffset = (XnUInt16)(GetXRes() - pCropping->originX - pCropping->width);
}
if (pCropping->enabled)
{
nRetVal = m_Helper.SimpleSetFirmwareParam(m_FirmwareCropSizeX, (XnUInt16) pCropping->width);
if (nRetVal == XN_STATUS_OK)
nRetVal = m_Helper.SimpleSetFirmwareParam(m_FirmwareCropSizeY, (XnUInt16) pCropping->height);
if (nRetVal == XN_STATUS_OK)
nRetVal = m_Helper.SimpleSetFirmwareParam(m_FirmwareCropOffsetX, (XnUInt16) nXOffset);
if (nRetVal == XN_STATUS_OK)
nRetVal = m_Helper.SimpleSetFirmwareParam(m_FirmwareCropOffsetY, (XnUInt16) pCropping->originY);
}
if (nRetVal == XN_STATUS_OK)
{
nRetVal = m_Helper.SimpleSetFirmwareParam(m_FirmwareCropMode, (XnUInt16)firmwareMode);
}
if (nRetVal != XN_STATUS_OK)
{
m_Helper.RollbackFirmwareTransaction();
m_Helper.UpdateFromFirmware(m_FirmwareCropMode);
m_Helper.UpdateFromFirmware(m_FirmwareCropOffsetX);
m_Helper.UpdateFromFirmware(m_FirmwareCropOffsetY);
m_Helper.UpdateFromFirmware(m_FirmwareCropSizeX);
m_Helper.UpdateFromFirmware(m_FirmwareCropSizeY);
xnOSLeaveCriticalSection(GetLock());
return (nRetVal);
}
nRetVal = m_Helper.CommitFirmwareTransactionAsBatch();
if (nRetVal != XN_STATUS_OK)
{
m_Helper.UpdateFromFirmware(m_FirmwareCropMode);
m_Helper.UpdateFromFirmware(m_FirmwareCropOffsetX);
m_Helper.UpdateFromFirmware(m_FirmwareCropOffsetY);
m_Helper.UpdateFromFirmware(m_FirmwareCropSizeX);
m_Helper.UpdateFromFirmware(m_FirmwareCropSizeY);
xnOSLeaveCriticalSection(GetLock());
return (nRetVal);
}
}
nRetVal = m_CroppingMode.UnsafeUpdateValue(mode);
XN_ASSERT(nRetVal == XN_STATUS_OK);
nRetVal = XnIRStream::SetCropping(pCropping);
xnOSLeaveCriticalSection(GetLock());
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
XnStatus XnSensorIRStream::SetCropping(const XnCropping* pCropping)
{
XnStatus nRetVal = XN_STATUS_OK;
nRetVal = ValidateCropping(pCropping);
XN_IS_STATUS_OK(nRetVal);
xnOSEnterCriticalSection(GetLock());
if (m_Helper.GetFirmwareVersion() > XN_SENSOR_FW_VER_3_0)
{
nRetVal = m_Helper.StartFirmwareTransaction();
if (nRetVal != XN_STATUS_OK)
{
xnOSLeaveCriticalSection(GetLock());
return (nRetVal);
}
// mirror is done by software (meaning AFTER cropping, which is bad). So we need to flip the cropping area
// to match requested area.
XnUInt16 nXOffset = pCropping->nXOffset;
if (IsMirrored())
{
nXOffset = (XnUInt16)(GetXRes() - pCropping->nXOffset - pCropping->nXSize);
}
if (pCropping->bEnabled)
{
nRetVal = m_Helper.SimpleSetFirmwareParam(m_FirmwareCropSizeX, pCropping->nXSize);
if (nRetVal == XN_STATUS_OK)
nRetVal = m_Helper.SimpleSetFirmwareParam(m_FirmwareCropSizeY, pCropping->nYSize);
if (nRetVal == XN_STATUS_OK)
nRetVal = m_Helper.SimpleSetFirmwareParam(m_FirmwareCropOffsetX, nXOffset);
if (nRetVal == XN_STATUS_OK)
nRetVal = m_Helper.SimpleSetFirmwareParam(m_FirmwareCropOffsetY, pCropping->nYOffset);
}
if (nRetVal == XN_STATUS_OK)
{
nRetVal = m_Helper.SimpleSetFirmwareParam(m_FirmwareCropEnabled, (XnUInt16)pCropping->bEnabled);
}
if (nRetVal != XN_STATUS_OK)
{
m_Helper.RollbackFirmwareTransaction();
m_Helper.UpdateFromFirmware(m_FirmwareCropEnabled);
m_Helper.UpdateFromFirmware(m_FirmwareCropOffsetX);
m_Helper.UpdateFromFirmware(m_FirmwareCropOffsetY);
m_Helper.UpdateFromFirmware(m_FirmwareCropSizeX);
m_Helper.UpdateFromFirmware(m_FirmwareCropSizeY);
xnOSLeaveCriticalSection(GetLock());
return (nRetVal);
}
nRetVal = m_Helper.CommitFirmwareTransactionAsBatch();
if (nRetVal != XN_STATUS_OK)
{
m_Helper.UpdateFromFirmware(m_FirmwareCropEnabled);
m_Helper.UpdateFromFirmware(m_FirmwareCropOffsetX);
m_Helper.UpdateFromFirmware(m_FirmwareCropOffsetY);
m_Helper.UpdateFromFirmware(m_FirmwareCropSizeX);
m_Helper.UpdateFromFirmware(m_FirmwareCropSizeY);
xnOSLeaveCriticalSection(GetLock());
return (nRetVal);
}
}
nRetVal = XnIRStream::SetCropping(pCropping);
xnOSLeaveCriticalSection(GetLock());
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
XnStatus XnPixelStream::Mirror(XnStreamData* pStreamOutput) const
{
XnUInt32 nXRes = GetCropping()->bEnabled ? GetCropping()->nXSize : GetXRes();
return XnFormatsMirrorPixelData(GetOutputFormat(), (XnUChar*)pStreamOutput->pData, pStreamOutput->nDataSize, nXRes);
}
XnStatus XnPixelStream::CalcRequiredSize(XnUInt32* pnRequiredSize) const
{
*pnRequiredSize = GetXRes() * GetYRes() * GetBytesPerPixel();
return XN_STATUS_OK;
}
XnStatus XnSensorDepthStream::Init()
{
XnStatus nRetVal = XN_STATUS_OK;
// init base
nRetVal = XnDepthStream::Init();
XN_IS_STATUS_OK(nRetVal);
// start with no cut-off
nRetVal = MaxDepthProperty().UnsafeUpdateValue(XN_DEVICE_SENSOR_MAX_DEPTH_100_UM);
XN_IS_STATUS_OK(nRetVal);
m_InputFormat.UpdateSetCallback(SetInputFormatCallback, this);
m_DepthRegistration.UpdateSetCallback(SetRegistrationCallback, this);
m_HoleFilter.UpdateSetCallback(SetHoleFilterCallback, this);
m_WhiteBalance.UpdateSetCallback(SetWhiteBalanceCallback, this);
m_Gain.UpdateSetCallback(SetGainCallback, this);
m_RegistrationType.UpdateSetCallback(SetRegistrationTypeCallback, this);
m_AGCBin.UpdateSetCallback(SetAGCBinCallback, this);
m_AGCBin.UpdateGetCallback(GetAGCBinCallback, this);
m_GMCMode.UpdateSetCallback(SetGMCModeCallback, this);
m_CloseRange.UpdateSetCallback(SetCloseRangeCallback, this);
m_CroppingMode.UpdateSetCallback(SetCroppingModeCallback, this);
m_PixelRegistration.UpdateGetCallback(GetPixelRegistrationCallback, this);
m_GMCDebug.UpdateSetCallback(SetGMCDebugCallback, this);
m_WavelengthCorrection.UpdateSetCallback(SetWavelengthCorrectionCallback, this);
m_WavelengthCorrectionDebug.UpdateSetCallback(SetWavelengthCorrectionDebugCallback, this);
XN_VALIDATE_ADD_PROPERTIES(this, &m_InputFormat, &m_DepthRegistration, &m_HoleFilter,
&m_WhiteBalance, &m_Gain, &m_AGCBin, &m_ActualRead, &m_GMCMode,
&m_CloseRange, &m_CroppingMode, &m_RegistrationType, &m_PixelRegistration,
&m_HorizontalFOV, &m_VerticalFOV, &m_GMCDebug, &m_WavelengthCorrection, &m_WavelengthCorrectionDebug,
);
// register supported modes
XnCmosPreset* pSupportedModes = m_Helper.GetPrivateData()->FWInfo.depthModes.GetData();
XnUInt32 nSupportedModes = m_Helper.GetPrivateData()->FWInfo.depthModes.GetSize();
nRetVal = AddSupportedModes(pSupportedModes, nSupportedModes);
XN_IS_STATUS_OK(nRetVal);
if (m_Helper.GetPrivateData()->pSensor->IsLowBandwidth())
{
nRetVal = m_InputFormat.UnsafeUpdateValue(XN_IO_DEPTH_FORMAT_COMPRESSED_PS);
XN_IS_STATUS_OK(nRetVal);
}
// make sure default resolution is supported
XnBool bResSupported = FALSE;
for (XnUInt8 i = 0; i < nSupportedModes; ++i)
{
if (pSupportedModes[i].nResolution == XN_DEPTH_STREAM_DEFAULT_RESOLUTION)
{
bResSupported = TRUE;
break;
}
}
XnUInt64 nDefaultResolution = XN_DEPTH_STREAM_DEFAULT_RESOLUTION;
if (!bResSupported)
{
// QVGA was always supported
nDefaultResolution = XN_RESOLUTION_QVGA;
}
nRetVal = ResolutionProperty().UnsafeUpdateValue(nDefaultResolution);
XN_IS_STATUS_OK(nRetVal);
// set other properties default values
nRetVal = FPSProperty().UnsafeUpdateValue(XN_DEPTH_STREAM_DEFAULT_FPS);
XN_IS_STATUS_OK(nRetVal);
nRetVal = OutputFormatProperty().UnsafeUpdateValue(XN_DEPTH_STREAM_DEFAULT_OUTPUT_FORMAT);
XN_IS_STATUS_OK(nRetVal);
nRetVal = ParamCoefficientProperty().UnsafeUpdateValue(XN_SHIFTS_PARAM_COEFFICIENT);
XN_IS_STATUS_OK(nRetVal);
nRetVal = ShiftScaleProperty().UnsafeUpdateValue(XN_SHIFTS_SHIFT_SCALE);
XN_IS_STATUS_OK(nRetVal);
// read some data from firmware
XnDepthInformation DepthInformation;
nRetVal = XnHostProtocolAlgorithmParams(m_Helper.GetPrivateData(), XN_HOST_PROTOCOL_ALGORITHM_DEPTH_INFO, &DepthInformation, sizeof(XnDepthInformation), XN_RESOLUTION_VGA, 30);
XN_IS_STATUS_OK(nRetVal);
nRetVal = ConstShiftProperty().UnsafeUpdateValue(DepthInformation.nConstShift);
XN_IS_STATUS_OK(nRetVal);
nRetVal = ZeroPlaneDistanceProperty().UnsafeUpdateValue(m_Helper.GetFixedParams()->GetZeroPlaneDistance());
XN_IS_STATUS_OK(nRetVal);
nRetVal = ZeroPlanePixelSizeProperty().UnsafeUpdateValue(m_Helper.GetFixedParams()->GetZeroPlanePixelSize());
XN_IS_STATUS_OK(nRetVal);
nRetVal = EmitterDCmosDistanceProperty().UnsafeUpdateValue(m_Helper.GetFixedParams()->GetEmitterDCmosDistance());
XN_IS_STATUS_OK(nRetVal);
nRetVal = GetDCmosRCmosDistanceProperty().UnsafeUpdateValue(m_Helper.GetFixedParams()->GetDCmosRCmosDistance());
XN_IS_STATUS_OK(nRetVal);
XnDouble fZPPS = m_Helper.GetFixedParams()->GetZeroPlanePixelSize();
XnInt nZPD = m_Helper.GetFixedParams()->GetZeroPlaneDistance();
nRetVal = m_HorizontalFOV.UnsafeUpdateValue(2*atan(fZPPS*XN_SXGA_X_RES/2/nZPD));
XN_IS_STATUS_OK(nRetVal);
nRetVal = m_VerticalFOV.UnsafeUpdateValue(2*atan(fZPPS*XN_VGA_Y_RES*2/2/nZPD));
XN_IS_STATUS_OK(nRetVal);
// init helper
nRetVal = m_Helper.Init(this, this);
XN_IS_STATUS_OK(nRetVal);
if (m_Helper.GetFirmwareVersion() < XN_SENSOR_FW_VER_3_0)
{
nRetVal = m_GMCMode.UnsafeUpdateValue(FALSE);
XN_IS_STATUS_OK(nRetVal);
}
if (m_Helper.GetFirmwareVersion() < XN_SENSOR_FW_VER_5_2)
{
nRetVal = m_WavelengthCorrection.UnsafeUpdateValue(FALSE);
XN_IS_STATUS_OK(nRetVal);
}
if (m_Helper.GetFirmwareVersion() < XN_SENSOR_FW_VER_4_0)
{
nRetVal = m_WhiteBalance.UnsafeUpdateValue(FALSE);
XN_IS_STATUS_OK(nRetVal);
}
// on old firmwares, the host decides on the default gain. On new firmwares, we read it from firmware
if (m_Helper.GetFirmware()->GetInfo()->nFWVer > XN_SENSOR_FW_VER_1_2)
{
nRetVal = m_Gain.UnsafeUpdateValue(GetFirmwareParams()->m_DepthGain.GetValue());
XN_IS_STATUS_OK(nRetVal);
}
// registration
XnCallbackHandle hCallbackDummy;
nRetVal = ResolutionProperty().OnChangeEvent().Register(DecideFirmwareRegistrationCallback, this, hCallbackDummy);
XN_IS_STATUS_OK(nRetVal);
nRetVal = DecideFirmwareRegistration((XnBool)m_DepthRegistration.GetValue(), (XnProcessingType)m_RegistrationType.GetValue(), GetResolution());
XN_IS_STATUS_OK(nRetVal);
// data processor
nRetVal = m_Helper.RegisterDataProcessorProperty(m_InputFormat);
XN_IS_STATUS_OK(nRetVal);
nRetVal = m_Helper.RegisterDataProcessorProperty(ResolutionProperty());
XN_IS_STATUS_OK(nRetVal);
// pixel size factor
nRetVal = GetFirmwareParams()->m_ReferenceResolution.OnChangeEvent().Register(DecidePixelSizeFactorCallback, this, m_hReferenceSizeChangedCallback);
XN_IS_STATUS_OK(nRetVal);
nRetVal = DecidePixelSizeFactor();
XN_IS_STATUS_OK(nRetVal);
// initialize registration
if (m_Helper.GetFirmwareVersion() > XN_SENSOR_FW_VER_5_3)
{
nRetVal = PopulateSensorCalibrationInfo();
XN_IS_STATUS_OK(nRetVal);
nRetVal = DepthUtilsInitialize(&m_calibrationInfo, &m_depthUtilsHandle);
XN_IS_STATUS_OK(nRetVal);
nRetVal = DepthUtilsSetDepthConfiguration(m_depthUtilsHandle, GetXRes(), GetYRes(), GetOutputFormat(), IsMirrored());
XN_IS_STATUS_OK(nRetVal);
}
return (XN_STATUS_OK);
}
