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);
}
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 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);
}
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::SetXRes(XnUInt32 nXRes)
{
XnStatus nRetVal = XN_STATUS_OK;
XnResolutions res = XnDDKGetResolutionFromXY(nXRes, GetYRes());
// set resolution (this will also set X and Y resolution)
nRetVal = SetResolution(res);
XN_IS_STATUS_OK(nRetVal);
if (res == XN_RESOLUTION_CUSTOM)
{
// update X res ourselves
nRetVal = m_XRes.UnsafeUpdateValue(nXRes);
XN_IS_STATUS_OK(nRetVal);
}
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 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);
}