void TEXTE_PCB::GetMsgPanelInfo( EDA_UNITS_T aUnits, std::vector< MSG_PANEL_ITEM >& aList )
{
wxString msg;
wxCHECK_RET( m_Parent != NULL, wxT( "TEXTE_PCB::GetMsgPanelInfo() m_Parent is NULL." ) );
if( m_Parent->Type() == PCB_DIMENSION_T )
aList.push_back( MSG_PANEL_ITEM( _( "Dimension" ), GetShownText(), DARKGREEN ) );
else
aList.push_back( MSG_PANEL_ITEM( _( "PCB Text" ), GetShownText(), DARKGREEN ) );
aList.push_back( MSG_PANEL_ITEM( _( "Layer" ), GetLayerName(), BLUE ) );
if( !IsMirrored() )
aList.push_back( MSG_PANEL_ITEM( _( "Mirror" ), _( "No" ), DARKGREEN ) );
else
aList.push_back( MSG_PANEL_ITEM( _( "Mirror" ), _( "Yes" ), DARKGREEN ) );
msg.Printf( wxT( "%.1f" ), GetTextAngle() / 10.0 );
aList.push_back( MSG_PANEL_ITEM( _( "Angle" ), msg, DARKGREEN ) );
msg = MessageTextFromValue( aUnits, GetThickness() );
aList.push_back( MSG_PANEL_ITEM( _( "Thickness" ), msg, MAGENTA ) );
msg = MessageTextFromValue( aUnits, GetTextWidth() );
aList.push_back( MSG_PANEL_ITEM( _( "Width" ), msg, RED ) );
msg = MessageTextFromValue( aUnits, GetTextHeight() );
aList.push_back( MSG_PANEL_ITEM( _( "Height" ), msg, RED ) );
}
void TEXTE_PCB::Flip( const wxPoint& aCentre )
{
SetTextY( aCentre.y - ( GetTextPos().y - aCentre.y ) );
int copperLayerCount = GetBoard()->GetCopperLayerCount();
SetLayer( FlipLayer( GetLayer(), copperLayerCount ) );
SetMirrored( !IsMirrored() );
}
XnStatus XnSensorGenerator::SetMirror(XnBool bMirror)
{
if (bMirror != IsMirrored())
{
return m_pSensor->SetProperty(m_strModule, XN_MODULE_PROPERTY_MIRROR, (XnUInt64)bMirror);
}
else
{
return (XN_STATUS_OK);
}
}
// see class_text_mod.h
void TEXTE_MODULE::GetMsgPanelInfo( std::vector< MSG_PANEL_ITEM >& aList )
{
MODULE* module = (MODULE*) m_Parent;
if( module == NULL ) // Happens in modedit, and for new texts
return;
wxString msg, Line;
static const wxString text_type_msg[3] =
{
_( "Ref." ), _( "Value" ), _( "Text" )
};
Line = module->GetReference();
aList.push_back( MSG_PANEL_ITEM( _( "Footprint" ), Line, DARKCYAN ) );
Line = GetShownText();
aList.push_back( MSG_PANEL_ITEM( _( "Text" ), Line, BROWN ) );
wxASSERT( m_Type >= TEXT_is_REFERENCE && m_Type <= TEXT_is_DIVERS );
aList.push_back( MSG_PANEL_ITEM( _( "Type" ), text_type_msg[m_Type], DARKGREEN ) );
if( !IsVisible() )
msg = _( "No" );
else
msg = _( "Yes" );
aList.push_back( MSG_PANEL_ITEM( _( "Display" ), msg, DARKGREEN ) );
// Display text layer
aList.push_back( MSG_PANEL_ITEM( _( "Layer" ), GetLayerName(), DARKGREEN ) );
if( IsMirrored() )
msg = _( "Yes" );
else
msg = _( "No" );
aList.push_back( MSG_PANEL_ITEM( _( "Mirror" ), msg, DARKGREEN ) );
msg.Printf( wxT( "%.1f" ), GetTextAngleDegrees() );
aList.push_back( MSG_PANEL_ITEM( _( "Angle" ), msg, DARKGREEN ) );
msg = ::CoordinateToString( GetThickness() );
aList.push_back( MSG_PANEL_ITEM( _( "Thickness" ), msg, DARKGREEN ) );
msg = ::CoordinateToString( GetTextWidth() );
aList.push_back( MSG_PANEL_ITEM( _( "Width" ), msg, RED ) );
msg = ::CoordinateToString( GetTextHeight() );
aList.push_back( MSG_PANEL_ITEM( _( "Height" ), msg, RED ) );
}
void TEXTE_PCB::TransformShapeWithClearanceToPolygonSet(
SHAPE_POLY_SET& aCornerBuffer,
int aClearanceValue,
int aCircleToSegmentsCount,
double aCorrectionFactor ) const
{
wxSize size = GetSize();
if( IsMirrored() )
size.x = -size.x;
s_cornerBuffer = &aCornerBuffer;
s_textWidth = GetThickness() + ( 2 * aClearanceValue );
s_textCircle2SegmentCount = aCircleToSegmentsCount;
EDA_COLOR_T color = BLACK; // not actually used, but needed by DrawGraphicText
if( IsMultilineAllowed() )
{
wxArrayString strings_list;
wxStringSplit( GetShownText(), strings_list, '\n' );
std::vector<wxPoint> positions;
positions.reserve( strings_list.Count() );
GetPositionsOfLinesOfMultilineText( positions, strings_list.Count() );
for( unsigned ii = 0; ii < strings_list.Count(); ii++ )
{
wxString txt = strings_list.Item( ii );
DrawGraphicText( NULL, NULL, positions[ii], color,
txt, GetOrientation(), size,
GetHorizJustify(), GetVertJustify(),
GetThickness(), IsItalic(),
true, addTextSegmToPoly );
}
}
else
{
DrawGraphicText( NULL, NULL, GetTextPosition(), color,
GetShownText(), GetOrientation(), size,
GetHorizJustify(), GetVertJustify(),
GetThickness(), IsItalic(),
true, addTextSegmToPoly );
}
}
void R3Affine::
Draw(void) const
{
// Multiply top of stack by matrix
Matrix().Draw();
// Set mirror flag - this screws up Push/Pop ???
if (IsMirrored()) {
R3draw_mirrored = !R3draw_mirrored;
#if (RN_3D_GRFX == RN_IRISGL)
frontface(R3draw_mirrored);
backface(!R3draw_mirrored);
#elif (RN_3D_GRFX == RN_OPENGL)
glFrontFace((R3draw_mirrored) ? GL_CW : GL_CCW);
#elif (RN_3D_GRFX == RN_3DR)
G3dSetState(R3dr_gc, G3DL_FRONT_CCW, (R3draw_mirrored) ? 0 : 1);
#else
RNAbort("Not Implemented");
#endif
}
}
void R3Affine::
Pop(void) const
{
// Pop matrix off stack
Matrix().Pop();
// Restore mirror flag
if (IsMirrored()) {
R3draw_mirrored = !R3draw_mirrored;
#if (RN_3D_GRFX == RN_IRISGL)
frontface(R3draw_mirrored);
backface(!R3draw_mirrored);
#elif (RN_3D_GRFX == RN_OPENGL)
glFrontFace((R3draw_mirrored) ? GL_CW : GL_CCW);
#elif (RN_3D_GRFX == RN_3DR)
G3dSetState(R3dr_gc, G3DL_FRONT_CCW, (R3draw_mirrored) ? 0 : 1);
#else
RNAbort("Not Implemented");
#endif
}
}
XnStatus XnDeviceStream::Read(XnStreamData* pStreamOutput)
{
XnStatus nRetVal = XN_STATUS_OK;
// check the size of the stream output object
nRetVal = XnStreamDataCheckSize(pStreamOutput, GetRequiredDataSize());
XN_IS_STATUS_OK(nRetVal);
// first mark old data as old
pStreamOutput->bIsNew = FALSE;
// now check if we have some new data
if (m_bNewDataAvailable)
{
// copy data
nRetVal = ReadImpl(pStreamOutput);
XN_IS_STATUS_OK(nRetVal);
xnOSEnterCriticalSection(&m_hCriticalSection);
XnBool bMirror = IsMirrored();
xnOSLeaveCriticalSection(&m_hCriticalSection);
// mirror it if needed
if (bMirror)
{
nRetVal = Mirror(pStreamOutput);
XN_IS_STATUS_OK(nRetVal);
}
// mark that data is new
pStreamOutput->bIsNew = TRUE;
// and that we don't have new info
m_bNewDataAvailable = FALSE;
}
return (XN_STATUS_OK);
}
void EDA_TEXT::TransformTextShapeToSegmentList( std::vector<wxPoint>& aCornerBuffer ) const
{
wxSize size = GetSize();
if( IsMirrored() )
NEGATE( size.x );
s_cornerBuffer = &aCornerBuffer;
EDA_COLOR_T color = BLACK; // not actually used, but needed by DrawGraphicText
if( IsMultilineAllowed() )
{
wxArrayString* list = wxStringSplit( GetText(), '\n' );
std::vector<wxPoint> positions;
positions.reserve( list->Count() );
GetPositionsOfLinesOfMultilineText( positions, list->Count() );
for( unsigned ii = 0; ii < list->Count(); ii++ )
{
wxString txt = list->Item( ii );
DrawGraphicText( NULL, NULL, positions[ii], color,
txt, GetOrientation(), size,
GetHorizJustify(), GetVertJustify(),
GetThickness(), IsItalic(),
true, addTextSegmToBuffer );
}
delete list;
}
else
{
DrawGraphicText( NULL, NULL, GetTextPosition(), color,
GetText(), GetOrientation(), size,
GetHorizJustify(), GetVertJustify(),
GetThickness(), IsItalic(),
true, addTextSegmToBuffer );
}
}
void Matrix::FromPeps(int id)
{
// if(id) {
int set = PepsVdmOpen(id, VDM_MATRIX_TYPE , VDM_READ_ONLY | VDM_LOCAL);
if(set < 0) FAILURE(L"Failed to open Matrix VDM");
struct kgm_header pepsm;
PepsVdmReadTmx(set , &pepsm);
memcpy(e, pepsm.matrix, sizeof(pepsm.matrix));
m_unit = true;
for(int i = 0; i < 16; i++) {
// copy over matrix and check for unit matrix
if(i == 0 || i == 5 || i == 10 || i == 15) {
if((e[i] = pepsm.matrix[i]) != 1) m_unit = false;
}
else {
if((e[i] = pepsm.matrix[i]) != 0) m_unit = false;
}
}
PepsVdmClose(set);
m_mirrored = IsMirrored();
// }
}
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 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);
}
void TEXTE_MODULE::Draw( EDA_DRAW_PANEL* aPanel, wxDC* aDC, GR_DRAWMODE aDrawMode,
const wxPoint& aOffset )
{
if( aPanel == NULL )
return;
/* parent must *not* be NULL (a footprint text without a footprint
parent has no sense) */
wxASSERT( m_Parent );
BOARD* brd = GetBoard( );
auto frame = static_cast<PCB_BASE_FRAME*> ( aPanel->GetParent() );
auto color = frame->Settings().Colors().GetLayerColor( GetLayer() );
PCB_LAYER_ID text_layer = GetLayer();
if( !brd->IsLayerVisible( m_Layer )
|| ( IsFrontLayer( text_layer ) && !brd->IsElementVisible( LAYER_MOD_TEXT_FR ) )
|| ( IsBackLayer( text_layer ) && !brd->IsElementVisible( LAYER_MOD_TEXT_BK ) ) )
return;
if( !brd->IsElementVisible( LAYER_MOD_REFERENCES ) && GetText() == wxT( "%R" ) )
return;
if( !brd->IsElementVisible( LAYER_MOD_VALUES ) && GetText() == wxT( "%V" ) )
return;
// Invisible texts are still drawn (not plotted) in LAYER_MOD_TEXT_INVISIBLE
// Just because we must have to edit them (at least to make them visible)
if( !IsVisible() )
{
if( !brd->IsElementVisible( LAYER_MOD_TEXT_INVISIBLE ) )
return;
color = frame->Settings().Colors().GetItemColor( LAYER_MOD_TEXT_INVISIBLE );
}
auto displ_opts = (PCB_DISPLAY_OPTIONS*)( aPanel->GetDisplayOptions() );
// shade text if high contrast mode is active
if( ( aDrawMode & GR_ALLOW_HIGHCONTRAST ) && displ_opts && displ_opts->m_ContrastModeDisplay )
{
PCB_LAYER_ID curr_layer = ( (PCB_SCREEN*) aPanel->GetScreen() )->m_Active_Layer;
if( !IsOnLayer( curr_layer ) )
color = COLOR4D( DARKDARKGRAY );
}
// Draw mode compensation for the width
int width = GetThickness();
if( displ_opts && displ_opts->m_DisplayModTextFill == SKETCH )
width = -width;
GRSetDrawMode( aDC, aDrawMode );
wxPoint pos = GetTextPos() - aOffset;
// Draw the text anchor point
if( brd->IsElementVisible( LAYER_ANCHOR ) )
{
COLOR4D anchor_color = frame->Settings().Colors().GetItemColor( LAYER_ANCHOR );
GRDrawAnchor( aPanel->GetClipBox(), aDC, pos.x, pos.y, DIM_ANCRE_TEXTE, anchor_color );
}
// Draw the text proper, with the right attributes
wxSize size = GetTextSize();
double orient = GetDrawRotation();
// If the text is mirrored : negate size.x (mirror / Y axis)
if( IsMirrored() )
size.x = -size.x;
DrawGraphicText( aPanel->GetClipBox(), aDC, pos, color, GetShownText(), orient,
size, GetHorizJustify(), GetVertJustify(),
width, IsItalic(), IsBold() );
// Enable these line to draw the bounding box (debug test purpose only)
#if 0
{
EDA_RECT BoundaryBox = GetBoundingBox();
GRRect( aPanel->GetClipBox(), aDC, BoundaryBox, 0, BROWN );
}
#endif
}
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 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);
}
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 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);
}
