0030120: Draw Harness - fixshape command does not heal missing 3D curves

Select3D_SensitiveSet::Matches() has been improved to check if BVH node is fully included by selection volume
and pass this information to overlapsElement()/elementIsInside() interfaces
to avoid expensive partial overlapping checks for individual elements.
Select3D_SensitivePrimitiveArray implements this new interface to improve partial overlapping performance.
Select3D_SensitivePrimitiveArray::Matches() now handles rectangle selection for sub-elements when Elements map is defined.
Added missing const to SelectMgr_BaseFrustum::Overlaps() methods.

AIS_PointCloud has been extended with new selection mode for collecting selected nodes

Draw Harness command vdrawparray has been extended with an option -shape
allowing to create a triangulation from tessellated shape.

src/AIS/AIS_PointCloud.cxx

@@ -32,8 +32,140 @@
 #include <SelectMgr_Selection.hxx>
 #include <StdPrs_BndBox.hxx>
 
+IMPLEMENT_STANDARD_RTTIEXT(AIS_PointCloudOwner, SelectMgr_EntityOwner)
+IMPLEMENT_STANDARD_RTTIEXT(AIS_PointCloud, AIS_InteractiveObject)
 
-IMPLEMENT_STANDARD_RTTIEXT(AIS_PointCloud,AIS_InteractiveObject)
+//=======================================================================
+//function : AIS_PointCloudOwner
+//purpose  :
+//=======================================================================
+AIS_PointCloudOwner::AIS_PointCloudOwner (const Handle(AIS_PointCloud)& theOrigin)
+: SelectMgr_EntityOwner ((const Handle(SelectMgr_SelectableObject)& )theOrigin,  5),
+  myDetPoints (new TColStd_HPackedMapOfInteger()),
+  mySelPoints (new TColStd_HPackedMapOfInteger())
+{
+  //
+}
+
+//=======================================================================
+//function : ~AIS_PointCloudOwner
+//purpose  :
+//=======================================================================
+AIS_PointCloudOwner::~AIS_PointCloudOwner()
+{
+  //
+}
+
+//=======================================================================
+//function : HilightWithColor
+//purpose  :
+//=======================================================================
+Standard_Boolean AIS_PointCloudOwner::IsForcedHilight() const
+{
+  return true;
+}
+
+//=======================================================================
+//function : HilightWithColor
+//purpose  :
+//=======================================================================
+void AIS_PointCloudOwner::HilightWithColor (const Handle(PrsMgr_PresentationManager3d)& thePrsMgr,
+                                                      const Handle(Prs3d_Drawer)& theStyle,
+                                                      const Standard_Integer )
+{
+  Handle(AIS_PointCloud) anObj = Handle(AIS_PointCloud)::DownCast (Selectable());
+  if (anObj.IsNull())
+  {
+    throw Standard_ProgramError ("Internal Error within AIS_PointCloud::PointsOwner!");
+  }
+
+  const Handle(TColStd_HPackedMapOfInteger)& aMap = thePrsMgr->IsImmediateModeOn()
+                                                  ? myDetPoints
+                                                  : mySelPoints;
+  Handle(Prs3d_Presentation) aPrs = thePrsMgr->IsImmediateModeOn()
+                                  ? anObj->GetHilightPresentation(thePrsMgr)
+                                  : anObj->GetSelectPresentation (thePrsMgr);
+  const Graphic3d_ZLayerId aZLayer = theStyle->ZLayer() != -1
+                                   ? theStyle->ZLayer()
+                                   : (thePrsMgr->IsImmediateModeOn() ? Graphic3d_ZLayerId_Top : anObj->ZLayer());
+  aMap->ChangeMap().Clear();
+  for (SelectMgr_SequenceOfSelection::Iterator aSelIter (anObj->Selections()); aSelIter.More(); aSelIter.Next())
+  {
+    const Handle(SelectMgr_Selection)& aSel = aSelIter.Value();
+    for (NCollection_Vector<Handle(SelectMgr_SensitiveEntity)>::Iterator aSelEntIter (aSel->Entities()); aSelEntIter.More(); aSelEntIter.Next())
+    {
+      const Handle(SelectMgr_SensitiveEntity)& aSelEnt = aSelEntIter.Value();
+      if (aSelEnt->BaseSensitive()->OwnerId() == this)
+      {
+        if (Handle(Select3D_SensitivePrimitiveArray) aSensitive = Handle(Select3D_SensitivePrimitiveArray)::DownCast (aSelEnt->BaseSensitive()))
+        {
+          aMap->ChangeMap() = aSensitive->LastDetectedElementMap()->Map();
+          if (aSensitive->LastDetectedElement() != -1)
+          {
+            aMap->ChangeMap().Add (aSensitive->LastDetectedElement());
+          }
+          break;
+        }
+      }
+    }
+  }
+
+  aPrs->Clear();
+  if (aPrs->GetZLayer() != aZLayer)
+  {
+    aPrs->SetZLayer (aZLayer);
+  }
+  if (aMap->Map().IsEmpty())
+  {
+    return;
+  }
+
+  const Handle(Graphic3d_ArrayOfPoints) anAllPoints = anObj->GetPoints();
+  if (anAllPoints.IsNull())
+  {
+    return;
+  }
+
+  Handle(Graphic3d_ArrayOfPoints) aPoints = new Graphic3d_ArrayOfPoints (aMap->Map().Extent());
+  for (TColStd_PackedMapOfInteger::Iterator aPntIter (aMap->Map()); aPntIter.More(); aPntIter.Next())
+  {
+    const gp_Pnt aPnt = anAllPoints->Vertice (aPntIter.Key() + 1);
+    aPoints->AddVertex (aPnt);
+  }
+
+  Handle(Graphic3d_Group) aGroup = aPrs->NewGroup();
+  aGroup->SetGroupPrimitivesAspect (theStyle->PointAspect()->Aspect());
+  aGroup->AddPrimitiveArray (aPoints);
+  if (thePrsMgr->IsImmediateModeOn())
+  {
+    thePrsMgr->AddToImmediateList (aPrs);
+  }
+  else
+  {
+    aPrs->Display();
+  }
+}
+
+//=======================================================================
+//function : Unhilight
+//purpose  :
+//=======================================================================
+void AIS_PointCloudOwner::Unhilight (const Handle(PrsMgr_PresentationManager)& , const Standard_Integer )
+{
+  if (Handle(Prs3d_Presentation) aPrs = Selectable()->GetSelectPresentation (Handle(PrsMgr_PresentationManager3d)()))
+  {
+    aPrs->Erase();
+  }
+}
+
+//=======================================================================
+//function : Clear
+//purpose  :
+//=======================================================================
+void AIS_PointCloudOwner::Clear (const Handle(PrsMgr_PresentationManager)& thePrsMgr, const Standard_Integer theMode)
+{
+  SelectMgr_EntityOwner::Clear (thePrsMgr, theMode);
+}
 
 //==================================================
 // Function: AIS_PointCloud
@@ -46,6 +178,8 @@ AIS_PointCloud::AIS_PointCloud()
 
   SetDisplayMode (AIS_PointCloud::DM_Points);
   SetHilightMode (AIS_PointCloud::DM_BndBox);
+
+  myDynHilightDrawer->SetPointAspect (new Prs3d_PointAspect (Aspect_TOM_PLUS, Quantity_NOC_CYAN1, 1.0));
 }
 
 //=======================================================================
@@ -432,14 +566,22 @@ void AIS_PointCloud::ComputeSelection (const Handle(SelectMgr_Selection)& theSel
   switch (theMode)
   {
     case SM_Points:
+    case SM_SubsetOfPoints:
     {
       const Handle(Graphic3d_ArrayOfPoints) aPoints = GetPoints();
       if (!aPoints.IsNull()
        && !aPoints->Attributes().IsNull())
       {
+        if (theMode == SM_SubsetOfPoints)
+        {
+          anOwner = new AIS_PointCloudOwner (this);
+        }
+
         // split large point clouds into several groups
         const Standard_Integer aNbGroups = aPoints->Attributes()->NbElements > 500000 ? 8 : 1;
         Handle(Select3D_SensitivePrimitiveArray) aSensitive = new Select3D_SensitivePrimitiveArray (anOwner);
+        aSensitive->SetDetectElements (true);
+        aSensitive->SetDetectElementMap (theMode == SM_SubsetOfPoints);
         aSensitive->SetSensitivityFactor (8);
         aSensitive->InitPoints (aPoints->Attributes(), aPoints->Indices(), TopLoc_Location(), true, aNbGroups);
         aSensitive->BVH();

src/AIS/AIS_PointCloud.hxx

@@ -21,14 +21,11 @@
 #include <Bnd_Box.hxx>
 #include <Graphic3d_ArrayOfPoints.hxx>
 #include <Quantity_HArray1OfColor.hxx>
-#include <Standard.hxx>
-#include <Standard_Type.hxx>
-#include <Standard_Macro.hxx>
+#include <SelectMgr_EntityOwner.hxx>
 #include <TColgp_HArray1OfDir.hxx>
 #include <TColgp_HArray1OfPnt.hxx>
 
-class AIS_PointCloud;
-DEFINE_STANDARD_HANDLE(AIS_PointCloud, AIS_InteractiveObject)
+class TColStd_HPackedMapOfInteger;
 
 //! Interactive object for set of points.
 //! The presentation supports two display modes:
@@ -43,7 +40,7 @@ DEFINE_STANDARD_HANDLE(AIS_PointCloud, AIS_InteractiveObject)
 //! hilight mode, e.g. 100);
 class AIS_PointCloud : public AIS_InteractiveObject
 {
-
+  DEFINE_STANDARD_RTTIEXT(AIS_PointCloud, AIS_InteractiveObject)
 public:
 
   //! Display modes supported by this Point Cloud object
@@ -56,8 +53,9 @@ public:
   //! Selection modes supported by this Point Cloud object
   enum SelectionMode
   {
-    SM_Points = 0, //!< detected by points
-    SM_BndBox = 2  //!< detected by bounding box
+    SM_Points         = 0, //!< detected by points
+    SM_SubsetOfPoints = 1, //!< detect point(s) within Point Cloud rather than object as whole
+    SM_BndBox         = 2, //!< detected by bounding box
   };
 
 public:
@@ -121,10 +119,45 @@ private:
   Handle(Graphic3d_ArrayOfPoints) myPoints;    //!< points array for presentation
   Bnd_Box                         myBndBox;    //!< bounding box for presentation
 
+};
+
+DEFINE_STANDARD_HANDLE(AIS_PointCloud, AIS_InteractiveObject)
+
+//! Custom owner for highlighting selected points.
+class AIS_PointCloudOwner : public SelectMgr_EntityOwner
+{
+  DEFINE_STANDARD_RTTIEXT(AIS_PointCloudOwner, SelectMgr_EntityOwner)
 public:
+  //! Main constructor.
+  Standard_EXPORT AIS_PointCloudOwner (const Handle(AIS_PointCloud)& theOrigin);
 
-  DEFINE_STANDARD_RTTIEXT(AIS_PointCloud,AIS_InteractiveObject)
+  //! Destructor.
+  Standard_EXPORT virtual ~AIS_PointCloudOwner();
 
+  //! Return selected points.
+  //! WARNING! Indexation starts with 0 (shifted by -1 comparing to Graphic3d_ArrayOfPoints::Vertice()).
+  const Handle(TColStd_HPackedMapOfInteger)& SelectedPoints() const { return mySelPoints; }
+
+  //! Return last detected points.
+  //! WARNING! Indexation starts with 0 (shifted by -1 comparing to Graphic3d_ArrayOfPoints::Vertice()).
+  const Handle(TColStd_HPackedMapOfInteger)& DetectedPoints() const { return myDetPoints; }
+
+  //! Always update dynamic highlighting.
+  Standard_EXPORT virtual Standard_Boolean IsForcedHilight() const Standard_OVERRIDE;
+
+  //! Handle dynamic highlighting.
+  Standard_EXPORT virtual void HilightWithColor (const Handle(PrsMgr_PresentationManager3d)& thePrsMgr,
+                                                 const Handle(Prs3d_Drawer)& theStyle,
+                                                 const Standard_Integer theMode) Standard_OVERRIDE;
+
+  //! Removes highlighting.
+  Standard_EXPORT virtual void Unhilight (const Handle(PrsMgr_PresentationManager)& thePrsMgr, const Standard_Integer theMode) Standard_OVERRIDE;
+
+  //! Clears presentation.
+  Standard_EXPORT virtual void Clear (const Handle(PrsMgr_PresentationManager)& thePrsMgr, const Standard_Integer theMode) Standard_OVERRIDE;
+protected:
+  Handle(TColStd_HPackedMapOfInteger) myDetPoints; //!< last detected points
+  Handle(TColStd_HPackedMapOfInteger) mySelPoints; //!< selected points
 };
 
 #endif // _AIS_PointCloud_HeaderFile

src/DrawResources/TestCommands.tcl

@@ -1041,8 +1041,10 @@ proc locate_data_file {filename} {
             while {[llength $dir] != 0} { 
                 set name [lindex $dir 0]
                 set dir [lrange $dir 1 end]
+
                 # skip directories starting with dot
-                if { [regexp {^[.]} $name] } { continue }
+                set aTail [file tail $name]
+                if { [regexp {^[.]} $aTail] } { continue }
                 if { [file exists $name/$filename] } {
                     return [file normalize $name/$filename]
                 }

src/MeshVS/MeshVS_CommonSensitiveEntity.cxx

@@ -222,10 +222,16 @@ void MeshVS_CommonSensitiveEntity::Swap (const Standard_Integer theIdx1,
 //function : overlapsElement
 //purpose  :
 //=======================================================================
-Standard_Boolean MeshVS_CommonSensitiveEntity::overlapsElement (SelectBasics_SelectingVolumeManager& theMgr,
+Standard_Boolean MeshVS_CommonSensitiveEntity::overlapsElement (SelectBasics_PickResult& thePickResult,
+                                                                SelectBasics_SelectingVolumeManager& theMgr,
                                                                 Standard_Integer theElemIdx,
-                                                                SelectBasics_PickResult& thePickResult)
+                                                                Standard_Boolean theIsFullInside)
 {
+  if (theIsFullInside)
+  {
+    return Standard_True;
+  }
+
   const Standard_Integer anItemIdx = myItemIndexes.Value (theElemIdx);
   if (mySelMethod == MeshVS_MSM_PRECISE)
   {
@@ -276,8 +282,14 @@ Standard_Boolean MeshVS_CommonSensitiveEntity::overlapsElement (SelectBasics_Sel
 //purpose  :
 //=======================================================================
 Standard_Boolean MeshVS_CommonSensitiveEntity::elementIsInside (SelectBasics_SelectingVolumeManager& theMgr,
-                                                                const Standard_Integer theElemIdx)
+                                                                Standard_Integer theElemIdx,
+                                                                Standard_Boolean theIsFullInside)
 {
+  if (theIsFullInside)
+  {
+    return Standard_True;
+  }
+
   const Standard_Integer anItemIdx = myItemIndexes.Value (theElemIdx);
   if (mySelMethod == MeshVS_MSM_PRECISE)
   {

src/MeshVS/MeshVS_CommonSensitiveEntity.hxx

@@ -65,13 +65,15 @@ public:
 protected:
 
   //! Checks whether the entity with index theIdx overlaps the current selecting volume
-  Standard_EXPORT virtual Standard_Boolean overlapsElement (SelectBasics_SelectingVolumeManager& theMgr,
+  Standard_EXPORT virtual Standard_Boolean overlapsElement (SelectBasics_PickResult& thePickResult,
+                                                            SelectBasics_SelectingVolumeManager& theMgr,
                                                             Standard_Integer theElemIdx,
-                                                            SelectBasics_PickResult& thePickResult) Standard_OVERRIDE;
+                                                            Standard_Boolean theIsFullInside) Standard_OVERRIDE;
 
   //! Checks whether the entity with index theIdx is inside the current selecting volume
   Standard_EXPORT virtual Standard_Boolean elementIsInside (SelectBasics_SelectingVolumeManager& theMgr,
-                                                            const Standard_Integer theElemIdx) Standard_OVERRIDE;
+                                                            Standard_Integer theElemIdx,
+                                                            Standard_Boolean theIsFullInside) Standard_OVERRIDE;
 
   //! Calculates distance from the 3d projection of used-picked screen point to center of the geometry
   Standard_EXPORT virtual Standard_Real distanceToCOG (SelectBasics_SelectingVolumeManager& theMgr) Standard_OVERRIDE;

src/STEPCAFControl/STEPCAFControl_Reader.cxx

@@ -56,6 +56,7 @@
 #include <STEPConstruct_Tool.hxx>
 #include <STEPConstruct_UnitContext.hxx>
 #include <STEPConstruct_ValidationProps.hxx>
+#include <STEPControl_ActorRead.hxx>
 #include <STEPControl_Reader.hxx>
 #include <StepGeom_GeometricRepresentationItem.hxx>
 #include <StepGeom_Axis2Placement3d.hxx>
@@ -229,6 +230,7 @@
 #include <Transfer_Binder.hxx>
 #include <Transfer_TransientProcess.hxx>
 #include <TransferBRep.hxx>
+#include <UnitsMethods.hxx>
 #include <XCAFDoc.hxx>
 #include <XCAFDoc_Area.hxx>
 #include <XCAFDoc_Centroid.hxx>
@@ -253,6 +255,8 @@
 #include <XCAFDimTolObjects_GeomToleranceObject.hxx>
 #include <XCAFDimTolObjects_DatumObject.hxx>
 #include <XCAFView_Object.hxx>
+#include <XSAlgo.hxx>
+#include <XSAlgo_AlgoContainer.hxx>
 #include <XSControl_TransferReader.hxx>
 #include <XSControl_WorkSession.hxx>
 #include <StepAP242_DraughtingModelItemAssociation.hxx>
@@ -1621,104 +1625,6 @@ Standard_Boolean STEPCAFControl_Reader::ReadSHUOs (const Handle(XSControl_WorkSe
   return Standard_True;
 }
 
-
-//=======================================================================
-//function : GetLengthConversionFactor
-//purpose  : 
-//=======================================================================
-static Standard_Boolean GetLengthConversionFactor(const Handle(StepBasic_NamedUnit)& NU,
-                                                  Standard_Real& afact)
-{
-  afact=1.;
-  if( !NU->IsKind(STANDARD_TYPE(StepBasic_ConversionBasedUnitAndLengthUnit)) ) return Standard_False;
-  Handle(StepBasic_ConversionBasedUnitAndLengthUnit) CBULU =
-    Handle(StepBasic_ConversionBasedUnitAndLengthUnit)::DownCast(NU);
-  Handle(StepBasic_MeasureWithUnit) MWUCBU = CBULU->ConversionFactor();
-  afact = MWUCBU->ValueComponent();
-  StepBasic_Unit anUnit2 = MWUCBU->UnitComponent();
-  if(anUnit2.CaseNum(anUnit2.Value())==1) {
-    Handle(StepBasic_NamedUnit) NU2 = anUnit2.NamedUnit();
-    if(NU2->IsKind(STANDARD_TYPE(StepBasic_SiUnit))) {
-      Handle(StepBasic_SiUnit) SU = Handle(StepBasic_SiUnit)::DownCast(NU2);
-      if(SU->Name()==StepBasic_sunMetre) {
-        if(SU->HasPrefix()) 
-          afact *= STEPConstruct_UnitContext::ConvertSiPrefix (SU->Prefix());
-        // convert m to mm
-        afact *= 1000.;
-      }
-    }
-  }
-  return Standard_True;
-}
-
-//=======================================================================
-//function : GetLengthConversionFactorFromContext
-//purpose  : 
-//=======================================================================
-static Standard_Boolean GetLengthConversionFactorFromContext(const Handle(StepRepr_RepresentationContext)& theRC,
-                                                             Standard_Real& theFact)
-{
-  theFact = 1;
-  if (theRC.IsNull())
-    return Standard_False;
-  Handle(StepBasic_ConversionBasedUnitAndLengthUnit) aSiLU;
-  Handle(StepGeom_GeometricRepresentationContextAndGlobalUnitAssignedContext) aCtx =
-    Handle(StepGeom_GeometricRepresentationContextAndGlobalUnitAssignedContext)::DownCast(theRC);
-  if (!aCtx.IsNull()) {
-    for (Standard_Integer j = 1; j <= aCtx->NbUnits(); j++) {
-      if (aCtx->UnitsValue(j)->IsKind(STANDARD_TYPE(StepBasic_ConversionBasedUnitAndLengthUnit))) {
-        aSiLU = Handle(StepBasic_ConversionBasedUnitAndLengthUnit)::DownCast(aCtx->UnitsValue(j));
-        break;
-      }
-    }
-  }
-  if (aSiLU.IsNull()) {
-    Handle(StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx) aCtx1 =
-      Handle(StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx)::DownCast(theRC);
-    if (!aCtx1.IsNull()) {
-      for (Standard_Integer j = 1; j <= aCtx1->NbUnits(); j++) {
-        if (aCtx1->UnitsValue(j)->IsKind(STANDARD_TYPE(StepBasic_ConversionBasedUnitAndLengthUnit))) {
-          aSiLU = Handle(StepBasic_ConversionBasedUnitAndLengthUnit)::DownCast(aCtx1->UnitsValue(j));
-          break;
-        }
-      }
-    }
-  }
-  if (aSiLU.IsNull())
-    return Standard_False;
-  return GetLengthConversionFactor(aSiLU, theFact);
-  
-}
-
-//=======================================================================
-//function : GetAngleConversionFactor
-//purpose  : 
-//=======================================================================
-static Standard_Boolean GetAngleConversionFactor(Handle(StepBasic_NamedUnit)& NU,
-                                                  Standard_Real& afact)
-{
-  afact=1.;
-  if( !NU->IsKind(STANDARD_TYPE(StepBasic_ConversionBasedUnitAndPlaneAngleUnit)) ) return Standard_False;
-  Handle(StepBasic_ConversionBasedUnitAndPlaneAngleUnit) CBULU =
-    Handle(StepBasic_ConversionBasedUnitAndPlaneAngleUnit)::DownCast(NU);
-  Handle(StepBasic_MeasureWithUnit) MWUCBU = CBULU->ConversionFactor();
-  afact = MWUCBU->ValueComponent();
-  StepBasic_Unit anUnit2 = MWUCBU->UnitComponent();
-  if(anUnit2.CaseNum(anUnit2.Value())==1) {
-    Handle(StepBasic_NamedUnit) NU2 = anUnit2.NamedUnit();
-    if(NU2->IsKind(STANDARD_TYPE(StepBasic_SiUnit))) {
-      Handle(StepBasic_SiUnit) SU = Handle(StepBasic_SiUnit)::DownCast(NU2);
-      if(SU->Name()==StepBasic_sunRadian) {
-        if(SU->HasPrefix()) 
-          afact *= STEPConstruct_UnitContext::ConvertSiPrefix (SU->Prefix());
-        // convert radian to deg
-        afact *= 180/M_PI;
-      }
-    }
-  }
-  return Standard_True;
-}
-
 //=======================================================================
 //function : GetMassConversionFactor
 //purpose  : 
@@ -1893,7 +1799,6 @@ Standard_Boolean readPMIPresentation(const Handle(Standard_Transient)& thePresen
 //purpose  : read annotation plane
 //=======================================================================
 Standard_Boolean readAnnotationPlane(const Handle(StepVisual_AnnotationPlane) theAnnotationPlane,
-                                     const Standard_Real theFact,
                                      gp_Ax2& thePlane)
 {
   if (theAnnotationPlane.IsNull())
@@ -1914,13 +1819,8 @@ Standard_Boolean readAnnotationPlane(const Handle(StepVisual_AnnotationPlane) th
   if (aA2P3D.IsNull())
     return Standard_False;
 
-  gp_Ax2 aPlaneAxes;
   Handle(Geom_Axis2Placement) anAxis = StepToGeom::MakeAxis2Placement(aA2P3D);
-  aPlaneAxes = anAxis->Ax2();
-  gp_XYZ aLocPos = aPlaneAxes.Location().XYZ();
-  aLocPos *= theFact;
-  aPlaneAxes.SetLocation(aLocPos);
-  thePlane = aPlaneAxes;
+  thePlane = anAxis->Ax2();
   return Standard_True;
 }
 
@@ -1958,9 +1858,10 @@ void readAnnotation(const Handle(XSControl_TransferReader)& theTR,
   // calculate units
   Handle(StepVisual_DraughtingModel) aDModel = 
     Handle(StepVisual_DraughtingModel)::DownCast(aDMIA->UsedRepresentation());
-  Standard_Real aFact = 1;
-  if (!aDModel.IsNull())
-    GetLengthConversionFactorFromContext(aDModel->ContextOfItems(), aFact);
+  XSAlgo::AlgoContainer()->PrepareForTransfer();
+  STEPControl_ActorRead anActor;
+  anActor.PrepareUnits(aDModel, aTP);
+  Standard_Real aFact = UnitsMethods::LengthFactor();
 
   // retrieve AnnotationPlane
   Handle(StepRepr_RepresentationItem) aDMIAE = aDMIA->IdentifiedItemValue(1);
@@ -1972,7 +1873,7 @@ void readAnnotation(const Handle(XSControl_TransferReader)& theTR,
   for (subs.Start(); subs.More() && anAnPlane.IsNull(); subs.Next()) {
     anAnPlane = Handle(StepVisual_AnnotationPlane)::DownCast(subs.Value());
   }
-  Standard_Boolean isHasPlane = readAnnotationPlane(anAnPlane, aFact, aPlaneAxes);
+  Standard_Boolean isHasPlane = readAnnotationPlane(anAnPlane, aPlaneAxes);
 
   // set plane axes to XCAF
   if (isHasPlane) {
@@ -2052,14 +1953,15 @@ void readConnectionPoints(const Handle(XSControl_TransferReader)& theTR,
   const Interface_Graph& aGraph = aTP->Graph();
 
   //calculate units
-  Standard_Real aFact = 1;
   Handle(StepShape_ShapeDimensionRepresentation) aSDR = NULL;
   for (Interface_EntityIterator anIt = aGraph.Sharings(theGDT); aSDR.IsNull() && anIt.More(); anIt.Next()) {
     aSDR = Handle(StepShape_ShapeDimensionRepresentation)::DownCast(anIt.Value());
   }
-  if (!aSDR.IsNull())
-    GetLengthConversionFactorFromContext(aSDR->ContextOfItems(), aFact);
-  
+  XSAlgo::AlgoContainer()->PrepareForTransfer();
+  STEPControl_ActorRead anActor;
+  anActor.PrepareUnits(aSDR, aTP);
+  Standard_Real aFact = UnitsMethods::LengthFactor();
+
   if (theGDT->IsKind(STANDARD_TYPE(StepShape_DimensionalSize))) {
     // retrieve derived geometry
     Handle(StepShape_DimensionalSize) aDim = Handle(StepShape_DimensionalSize)::DownCast(theGDT);
@@ -2459,6 +2361,9 @@ Standard_Boolean STEPCAFControl_Reader::setDatumToXCAF(const Handle(StepDimTol_D
               {
                 Handle(StepGeom_Axis2Placement3d) anAx
                   = Handle(StepGeom_Axis2Placement3d)::DownCast(aSRWP->ItemsValue(j));
+                XSAlgo::AlgoContainer()->PrepareForTransfer();
+                STEPControl_ActorRead anActor;
+                anActor.PrepareUnits(aSRWP, aTP);
                 Handle(Geom_Axis2Placement) anAxis = StepToGeom::MakeAxis2Placement(anAx);
                 aDatTargetObj->SetDatumTargetAxis(anAxis->Ax2());
               }
@@ -2468,14 +2373,14 @@ Standard_Boolean STEPCAFControl_Reader::setDatumToXCAF(const Handle(StepDimTol_D
                   Handle(StepRepr_ReprItemAndLengthMeasureWithUnit)::DownCast(aSRWP->ItemsValue(j));
                 Standard_Real aVal = aM->GetMeasureWithUnit()->ValueComponent();
                 StepBasic_Unit anUnit = aM->GetMeasureWithUnit()->UnitComponent();
-                Standard_Real aFact = 1.;
                 if (anUnit.IsNull())
                   continue;
                 Handle(StepBasic_NamedUnit) aNU = anUnit.NamedUnit();
                 if (aNU.IsNull())
                   continue;
-                if (GetLengthConversionFactor(aNU, aFact))
-                  aVal = aVal * aFact;
+                STEPConstruct_UnitContext anUnitCtx;
+                anUnitCtx.ComputeFactors(aNU);
+                aVal = aVal * anUnitCtx.LengthFactor();
                 if (aM->Name()->String().IsEqual("target length") ||
                   aM->Name()->String().IsEqual("target diameter"))
                   aDatTargetObj->SetDatumTargetLength(aVal);
@@ -2626,12 +2531,12 @@ Standard_Boolean STEPCAFControl_Reader::readDatumsAP242(const Handle(Standard_Tr
                   aXCAFModifWithVal = (XCAFDimTolObjects_DatumModifWithValue)(aModif->Value(m).DatumReferenceModifierWithValue()->ModifierType() + 1);
                   Standard_Real aVal = aModif->Value(m).DatumReferenceModifierWithValue()->ModifierValue()->ValueComponent();
                   StepBasic_Unit anUnit = aModif->Value(m).DatumReferenceModifierWithValue()->ModifierValue()->UnitComponent();
-                  Standard_Real aFact=1.;
                   if(anUnit.IsNull()) continue;
                   if( !(anUnit.CaseNum(anUnit.Value())==1) ) continue;
                   Handle(StepBasic_NamedUnit) NU = anUnit.NamedUnit();
-                  if(GetLengthConversionFactor(NU,aFact)) aVal=aVal*aFact;
-                  aModifValue = aVal;
+                  STEPConstruct_UnitContext anUnitCtx;
+                  anUnitCtx.ComputeFactors(NU);
+                  aModifValue = aVal * anUnitCtx.LengthFactor();
                 }
               }
             }
@@ -2663,12 +2568,12 @@ Standard_Boolean STEPCAFControl_Reader::readDatumsAP242(const Handle(Standard_Tr
                       aXCAFModifWithVal = (XCAFDimTolObjects_DatumModifWithValue)(aModifE->Value(k).DatumReferenceModifierWithValue()->ModifierType() + 1);
                       Standard_Real aVal = aModifE->Value(k).DatumReferenceModifierWithValue()->ModifierValue()->ValueComponent();
                       StepBasic_Unit anUnit = aModifE->Value(k).DatumReferenceModifierWithValue()->ModifierValue()->UnitComponent();
-                      Standard_Real aFact=1.;
                       if(anUnit.IsNull()) continue;
                       if( !(anUnit.CaseNum(anUnit.Value())==1) ) continue;
                       Handle(StepBasic_NamedUnit) NU = anUnit.NamedUnit();
-                      if(GetLengthConversionFactor(NU,aFact)) aVal=aVal*aFact;
-                      aModifValue = aVal;
+                      STEPConstruct_UnitContext anUnitCtx;
+                      anUnitCtx.ComputeFactors(NU);
+                      aModifValue = aVal * anUnitCtx.LengthFactor();
                     }
                   }
                 }
@@ -2863,11 +2768,12 @@ TDF_Label STEPCAFControl_Reader::createGDTObjectInXCAF(const Handle(Standard_Tra
                           Handle(StepRepr_ReprItemAndLengthMeasureWithUnit)::DownCast(RI1);
                         dim1 = RILMWU->GetMeasureWithUnit()->ValueComponent();
                         StepBasic_Unit anUnit = RILMWU->GetMeasureWithUnit()->UnitComponent();
-                        Standard_Real afact=1.;
                         if(anUnit.IsNull()) continue;
                         if( !(anUnit.CaseNum(anUnit.Value())==1) ) continue;
                         Handle(StepBasic_NamedUnit) NU = anUnit.NamedUnit();
-                        if(GetLengthConversionFactor(NU,afact)) dim1=dim1*afact;
+                        STEPConstruct_UnitContext anUnitCtx;
+                        anUnitCtx.ComputeFactors(NU);
+                        dim1 = dim1 * anUnitCtx.LengthFactor();
                       }
                     }
                     if(HARI->Length()>1) {
@@ -2878,11 +2784,12 @@ TDF_Label STEPCAFControl_Reader::createGDTObjectInXCAF(const Handle(Standard_Tra
                           Handle(StepRepr_ReprItemAndLengthMeasureWithUnit)::DownCast(RI2);
                         dim2 = RILMWU->GetMeasureWithUnit()->ValueComponent();
                         StepBasic_Unit anUnit = RILMWU->GetMeasureWithUnit()->UnitComponent();
-                        Standard_Real afact=1.;
                         if(anUnit.IsNull()) continue;
                         if( !(anUnit.CaseNum(anUnit.Value())==1) ) continue;
                         Handle(StepBasic_NamedUnit) NU = anUnit.NamedUnit();
-                        if(GetLengthConversionFactor(NU,afact)) dim2 = dim2*afact;
+                        STEPConstruct_UnitContext anUnitCtx;
+                        anUnitCtx.ComputeFactors(NU);
+                        dim2 = dim2 * anUnitCtx.LengthFactor();
                       }
                     }
                   }
@@ -2918,11 +2825,12 @@ TDF_Label STEPCAFControl_Reader::createGDTObjectInXCAF(const Handle(Standard_Tra
             if(dim3.IsNull()) continue;
             Standard_Real dim = dim3->ValueComponent();
             StepBasic_Unit anUnit = GT->Magnitude()->UnitComponent();
-            Standard_Real afact=1.;
             if(anUnit.IsNull()) continue;
             if( !(anUnit.CaseNum(anUnit.Value())==1) ) continue;
             Handle(StepBasic_NamedUnit) NU = anUnit.NamedUnit();
-            if(GetLengthConversionFactor(NU,afact)) dim = dim*afact;
+            STEPConstruct_UnitContext anUnitCtx;
+            anUnitCtx.ComputeFactors(NU);
+            dim = dim * anUnitCtx.LengthFactor();
             //cout<<"GeometricTolerance: Magnitude = "<<dim<<endl;
             Handle(TColStd_HArray1OfReal) arr = new TColStd_HArray1OfReal(1,1);
             arr->SetValue(1,dim);
@@ -3146,6 +3054,25 @@ TDF_Label STEPCAFControl_Reader::createGDTObjectInXCAF(const Handle(Standard_Tra
   return aGDTL;
 }
 
+//=======================================================================
+//function : convertAngleValue
+//purpose  : auxilary
+//=======================================================================
+void convertAngleValue(
+  const STEPConstruct_UnitContext& anUnitCtx,
+  Standard_Real& aVal)
+{
+  // convert radian to deg
+  Standard_Real aFact = anUnitCtx.PlaneAngleFactor() * 180 / M_PI;
+  // in order to avoid inaccuracy of calculation perform conversion
+  // only if aFact not eqaul 1 with some precision
+  if (fabs(1. - aFact) > Precision::Confusion())
+  {
+    aVal = aVal * aFact;
+  }
+}
+
+
 //=======================================================================
 //function : setDimObjectToXCAF
 //purpose  : 
@@ -3212,20 +3139,19 @@ static void setDimObjectToXCAF(const Handle(Standard_Transient)& theEnt,
                 Handle(StepRepr_ReprItemAndMeasureWithUnit)::DownCast(aDRI);
               Standard_Real aVal = aMWU->GetMeasureWithUnit()->ValueComponent();
               StepBasic_Unit anUnit = aMWU->GetMeasureWithUnit()->UnitComponent();
-              Standard_Real aFact = 1.;
               if (anUnit.IsNull()) 
                 continue;
               if (!(anUnit.CaseNum(anUnit.Value()) == 1)) 
                 continue;
               Handle(StepBasic_NamedUnit) NU = anUnit.NamedUnit();
+              STEPConstruct_UnitContext anUnitCtx;
+              anUnitCtx.ComputeFactors(NU);
               if (aMWU->IsKind(STANDARD_TYPE(StepRepr_ReprItemAndLengthMeasureWithUnit))) {
-                if (GetLengthConversionFactor(NU, aFact))
-                  aVal = aVal * aFact;
+                aVal = aVal * anUnitCtx.LengthFactor();
               }
               else
                 if (aMWU->IsKind(STANDARD_TYPE(StepRepr_ReprItemAndPlaneAngleMeasureWithUnit))) {
-                  if (GetAngleConversionFactor(NU, aFact))
-                    aVal = aVal * aFact;
+                  convertAngleValue(anUnitCtx, aVal);
                 }
               Handle(TCollection_HAsciiString) aName = aMWU->Name();
               if (aName->Search("upper") > 0) // upper limit
@@ -3239,20 +3165,19 @@ static void setDimObjectToXCAF(const Handle(Standard_Transient)& theEnt,
                 Handle(StepRepr_ReprItemAndMeasureWithUnitAndQRI)::DownCast(aDRI);
               Standard_Real aVal = aMWU->GetMeasureWithUnit()->ValueComponent();
               StepBasic_Unit anUnit = aMWU->GetMeasureWithUnit()->UnitComponent();
-              Standard_Real aFact = 1.;
               if(anUnit.IsNull())
                 continue;
               if( !(anUnit.CaseNum(anUnit.Value()) == 1) )
                 continue;
               Handle(StepBasic_NamedUnit) NU = anUnit.NamedUnit();
+              STEPConstruct_UnitContext anUnitCtx;
+              anUnitCtx.ComputeFactors(NU);
               if (aMWU->IsKind(STANDARD_TYPE(StepRepr_ReprItemAndLengthMeasureWithUnitAndQRI))) {
-                if (GetLengthConversionFactor(NU, aFact))
-                  aVal = aVal * aFact;
+                aVal = aVal * anUnitCtx.LengthFactor();
               }
               else
                 if (aMWU->IsKind(STANDARD_TYPE(StepRepr_ReprItemAndPlaneAngleMeasureWithUnitAndQRI))) {
-                  if (GetAngleConversionFactor(NU, aFact))
-                    aVal = aVal * aFact;
+                  convertAngleValue(anUnitCtx, aVal);
                 }
               Handle(StepShape_QualifiedRepresentationItem) aQRI = aMWU->GetQualifiedRepresentationItem();
               if (aQRI->Qualifiers()->Length() == 0) {
@@ -3305,22 +3230,43 @@ static void setDimObjectToXCAF(const Handle(Standard_Transient)& theEnt,
         aTV = aTMD.ToleranceValue();
         if (aTV.IsNull()) continue;
 
+        Handle(StepBasic_MeasureWithUnit) aMWU = aTV->UpperBound();
         Standard_Real aVal = aTV->UpperBound()->ValueComponent();
         StepBasic_Unit anUnit = aTV->UpperBound()->UnitComponent();
-        Standard_Real aFact=1.;
         if(anUnit.IsNull()) continue;
         if( !(anUnit.CaseNum(anUnit.Value())==1) ) continue;
         Handle(StepBasic_NamedUnit) NU = anUnit.NamedUnit();
-        if(GetLengthConversionFactor(NU,aFact)) aVal=aVal*aFact;
+        STEPConstruct_UnitContext anUnitCtx;
+        anUnitCtx.ComputeFactors(NU);
+        if (aMWU->IsKind(STANDARD_TYPE(StepBasic_LengthMeasureWithUnit)) ||
+          aMWU->IsKind(STANDARD_TYPE(StepRepr_ReprItemAndLengthMeasureWithUnitAndQRI)))
+        {
+          aVal = aVal * anUnitCtx.LengthFactor();
+        }
+        else if (aMWU->IsKind(STANDARD_TYPE(StepBasic_PlaneAngleMeasureWithUnit)) ||
+          aMWU->IsKind(STANDARD_TYPE(StepRepr_ReprItemAndPlaneAngleMeasureWithUnitAndQRI)))
+        {
+          convertAngleValue(anUnitCtx, aVal);
+        }
         aDim3 = aVal;
 
+        aMWU = aTV->LowerBound();
         aVal = aTV->LowerBound()->ValueComponent();
         anUnit = aTV->LowerBound()->UnitComponent();
-        aFact=1.;
         if(anUnit.IsNull()) continue;
         if( !(anUnit.CaseNum(anUnit.Value())==1) ) continue;
         NU = anUnit.NamedUnit();
-        if(GetLengthConversionFactor(NU,aFact)) aVal=aVal*aFact;
+        anUnitCtx.ComputeFactors(NU);
+        if (aMWU->IsKind(STANDARD_TYPE(StepBasic_LengthMeasureWithUnit)) ||
+          aMWU->IsKind(STANDARD_TYPE(StepRepr_ReprItemAndLengthMeasureWithUnitAndQRI)))
+        {
+          aVal = aVal * anUnitCtx.LengthFactor();
+        }
+        else if (aMWU->IsKind(STANDARD_TYPE(StepBasic_PlaneAngleMeasureWithUnit)) ||
+          aMWU->IsKind(STANDARD_TYPE(StepRepr_ReprItemAndPlaneAngleMeasureWithUnitAndQRI)))
+        {
+          convertAngleValue(anUnitCtx, aVal);
+        }
         aDim2 = Abs(aVal);
       }
       else
@@ -3664,12 +3610,12 @@ static void setGeomTolObjectToXCAF(const Handle(Standard_Transient)& theEnt,
     //get value
     Standard_Real aVal = aTolEnt->Magnitude()->ValueComponent();
     StepBasic_Unit anUnit = aTolEnt->Magnitude()->UnitComponent();
-    Standard_Real aFact=1.;
     if(anUnit.IsNull()) return;
     if( !(anUnit.CaseNum(anUnit.Value())==1) ) return;
     Handle(StepBasic_NamedUnit) NU = anUnit.NamedUnit();
-    if(GetLengthConversionFactor(NU,aFact))
-      aVal=aVal*aFact;
+    STEPConstruct_UnitContext anUnitCtx;
+    anUnitCtx.ComputeFactors(NU);
+    aVal = aVal * anUnitCtx.LengthFactor();
     aTolObj->SetValue(aVal);
   }
   //get modifiers
@@ -3689,12 +3635,12 @@ static void setGeomTolObjectToXCAF(const Handle(Standard_Transient)& theEnt,
           {
             Standard_Real aVal = aPZone->ProjectionLength()->ValueComponent();
             StepBasic_Unit anUnit = aPZone->ProjectionLength()->UnitComponent();
-            Standard_Real aFact=1.;
             if(anUnit.IsNull()) return;
             if( !(anUnit.CaseNum(anUnit.Value())==1) ) return;
             Handle(StepBasic_NamedUnit) NU = anUnit.NamedUnit();
-            if(GetLengthConversionFactor(NU,aFact))
-              aVal=aVal*aFact;
+            STEPConstruct_UnitContext anUnitCtx;
+            anUnitCtx.ComputeFactors(NU);
+            aVal = aVal * anUnitCtx.LengthFactor();
             aTolObj->SetValueOfZoneModifier(aVal);
             aTolObj->SetZoneModifier(XCAFDimTolObjects_GeomToleranceZoneModif_Projected);
           }
@@ -3707,11 +3653,12 @@ static void setGeomTolObjectToXCAF(const Handle(Standard_Transient)& theEnt,
           {
             Standard_Real aVal = aRZone->Orientation()->Angle()->ValueComponent();
             StepBasic_Unit anUnit = aRZone->Orientation()->Angle()->UnitComponent();
-            Standard_Real aFact=1.;
             if(anUnit.IsNull()) continue;
             if( !(anUnit.CaseNum(anUnit.Value())==1) ) continue;
             Handle(StepBasic_NamedUnit) NU = anUnit.NamedUnit();
-            if(GetAngleConversionFactor(NU,aFact)) aVal=aVal*aFact;
+            STEPConstruct_UnitContext anUnitCtx;
+            anUnitCtx.ComputeFactors(NU);
+            convertAngleValue(anUnitCtx, aVal);
             aTolObj->SetValueOfZoneModifier(aVal);
             aTolObj->SetZoneModifier(XCAFDimTolObjects_GeomToleranceZoneModif_Runout);
           }
@@ -3781,9 +3728,10 @@ static void setGeomTolObjectToXCAF(const Handle(Standard_Transient)& theEnt,
   }
   if (!anUnit.IsNull() && (anUnit.CaseNum(anUnit.Value()) == 1))
   {
-    Standard_Real aFact=1.;
     Handle(StepBasic_NamedUnit) NU = anUnit.NamedUnit();
-    if(GetAngleConversionFactor(NU,aFact)) aVal=aVal*aFact;
+    STEPConstruct_UnitContext anUnitCtx;
+    anUnitCtx.ComputeFactors(NU);
+    convertAngleValue(anUnitCtx, aVal);
     aTolObj->SetMaxValueModifier(aVal);
   }
   
@@ -3910,8 +3858,14 @@ Standard_Boolean STEPCAFControl_Reader::ReadGDTs(const Handle(XSControl_WorkSess
 
       // Calculate unit
       Standard_Real aFact = 1.0;
-      if (!aDMIA.IsNull() && !aDMIA->UsedRepresentation().IsNull())
-        GetLengthConversionFactorFromContext(aDMIA->UsedRepresentation()->ContextOfItems(), aFact);
+      if (!aDMIA.IsNull())
+      {
+        XSAlgo::AlgoContainer()->PrepareForTransfer();
+        STEPControl_ActorRead anActor;
+        Handle(Transfer_TransientProcess) aTP = aTR->TransientProcess();
+        anActor.PrepareUnits(aDMIA->UsedRepresentation(), aTP);
+        aFact = UnitsMethods::LengthFactor();
+      }
 
       // Presentation
       TopoDS_Shape aPresentation;
@@ -3944,7 +3898,7 @@ Standard_Boolean STEPCAFControl_Reader::ReadGDTs(const Handle(XSControl_WorkSess
       aDGTTool->SetDimension(aShapesL, anEmptySeq2, aGDTL);
       gp_Ax2 aPlaneAxes;
       if (!anAnPlane.IsNull()) {
-        if (readAnnotationPlane(anAnPlane, aFact, aPlaneAxes))
+        if (readAnnotationPlane(anAnPlane, aPlaneAxes))
           aDimObj->SetPlane(aPlaneAxes);
       }
       aDimObj->SetPresentation(aPresentation, aPresentName);
@@ -4064,15 +4018,23 @@ Standard_Boolean STEPCAFControl_Reader::ReadMaterials(const Handle(XSControl_Wor
               for(Standard_Integer idu=1; idu<=DU->NbElements(); idu++) {
                 Handle(StepBasic_DerivedUnitElement) DUE = DU->ElementsValue(idu);
                 Handle(StepBasic_NamedUnit) NU = DUE->Unit();
-                Standard_Real afact=1.;
-                if(NU->IsKind(STANDARD_TYPE(StepBasic_ConversionBasedUnitAndLengthUnit))) {
-                  if(GetLengthConversionFactor(NU,afact)) aDensity = aDensity/(afact*afact*afact);
+                if(NU->IsKind(STANDARD_TYPE(StepBasic_ConversionBasedUnitAndLengthUnit)) ||
+                   NU->IsKind(STANDARD_TYPE(StepBasic_SiUnitAndLengthUnit)))
+                {
+                  STEPConstruct_UnitContext anUnitCtx;
+                  anUnitCtx.ComputeFactors(NU);
+                  aDensity = aDensity / (anUnitCtx.LengthFactor()*anUnitCtx.LengthFactor()*anUnitCtx.LengthFactor());
                   // transfer length value for Density from millimeter to santimeter
                   // in order to result density has dimension gram/(sm*sm*sm)
-                  aDensity = aDensity*1000.;
+                  aDensity = aDensity*1000. / (UnitsMethods::GetCasCadeLengthUnit()
+                    * UnitsMethods::GetCasCadeLengthUnit() * UnitsMethods::GetCasCadeLengthUnit());
                 }
                 if(NU->IsKind(STANDARD_TYPE(StepBasic_ConversionBasedUnitAndMassUnit))) {
-                  if(GetMassConversionFactor(NU,afact)) aDensity=aDensity*afact;
+                  Standard_Real afact = 1.;
+                  if (GetMassConversionFactor(NU, afact))
+                  {
+                    aDensity = aDensity*afact;
+                  }
                 }
               }
             }
@@ -4226,6 +4188,28 @@ Standard_Boolean STEPCAFControl_Reader::ReadViews(const Handle(XSControl_WorkSes
     Handle(XCAFView_Object) anObj = new XCAFView_Object();
     // Import attributes of view
     Handle(StepVisual_CameraModelD3) aCameraModel = Handle(StepVisual_CameraModelD3)::DownCast(anEnt);
+
+    const Handle(XSControl_TransferReader)& aTR = theWS->TransferReader();
+    Handle(Transfer_TransientProcess) aTP = aTR->TransientProcess();
+    const Interface_Graph& aGraph = aTP->Graph();
+    // find the proper DraughtingModel
+    Interface_EntityIterator subs = aGraph.Sharings(aCameraModel);
+    Handle(StepVisual_DraughtingModel) aDModel;
+    for (subs.Start(); subs.More() && aDModel.IsNull(); subs.Next())
+    {
+      if (!subs.Value()->IsKind(STANDARD_TYPE(StepVisual_DraughtingModel)))
+      {
+        continue;
+      }
+      aDModel = Handle(StepVisual_DraughtingModel)::DownCast(subs.Value());
+    }
+    if (!aDModel.IsNull())
+    {
+      XSAlgo::AlgoContainer()->PrepareForTransfer();
+      STEPControl_ActorRead anActor;
+      anActor.PrepareUnits(aDModel, aTP);
+    }
+
     anObj->SetName(aCameraModel->Name());
     Handle(Geom_Axis2Placement) anAxis = StepToGeom::MakeAxis2Placement(aCameraModel->ViewReferenceSystem());
     anObj->SetViewDirection(anAxis->Direction());
@@ -4257,20 +4241,12 @@ Standard_Boolean STEPCAFControl_Reader::ReadViews(const Handle(XSControl_WorkSes
       aClippingExpression = buildClippingPlanes(aClippingCameraModel, aClippingPlanes, aClippingPlaneTool);
       anObj->SetClippingExpression(aClippingExpression);
     }
+
     // Collect shapes and GDTs
-    TDF_LabelSequence aShapes, aGDTs;
-    Handle(XSControl_TransferReader) aTR = theWS->TransferReader();
-    Handle(Transfer_TransientProcess) aTP = aTR->TransientProcess();
-    const Interface_Graph& aGraph = aTP->Graph();
-    Handle(StepVisual_DraughtingModel) aDModel;
-    Interface_EntityIterator anIter = aGraph.Sharings(aCameraModel);
-    for (; anIter.More() && aDModel.IsNull(); anIter.Next()) {
-      aDModel = Handle(StepVisual_DraughtingModel)::DownCast(anIter.Value());
-    }
     if (aDModel.IsNull())
       return Standard_False;
-
-    anIter = aGraph.Shareds(aDModel);
+    TDF_LabelSequence aShapes, aGDTs;
+    Interface_EntityIterator anIter = aGraph.Shareds(aDModel);
     for (; anIter.More(); anIter.Next()) {
       if (anIter.Value()->IsKind(STANDARD_TYPE(StepRepr_MappedItem))) {
         Handle(StepRepr_MappedItem) anItem = Handle(StepRepr_MappedItem)::DownCast(anIter.Value());

src/SWDRAW/SWDRAW_ShapeFix.cxx

@@ -401,11 +401,22 @@ static Standard_Integer reface (Draw_Interpretor& di, Standard_Integer argc, con
 //function : fixshape
 //purpose  : 
 //=======================================================================
-
+#include <ShapeFix_Edge.hxx>
 static Standard_Integer fixshape (Draw_Interpretor& di, Standard_Integer argc, const char** argv)
 {
+  TopoDS_Shape aShF =  DBRep::Get (argv[1]);
+  Handle(ShapeFix_Edge) anEdgeFixer = new ShapeFix_Edge();
+  for (TopExp_Explorer anEdgeIter (aShF, TopAbs_EDGE); anEdgeIter.More(); anEdgeIter.Next())
+  {
+    TopoDS_Edge anEdge = TopoDS::Edge (anEdgeIter.Current());
+    anEdgeFixer->FixAddCurve3d (anEdge);
+  }
+return 0;
+
   Handle(ShapeExtend_MsgRegistrator) msg = new ShapeExtend_MsgRegistrator;
   Handle(ShapeFix_Shape) sfs = new ShapeFix_Shape;
+sfs->FixWireTool()->FixAddCurve3dMode() = 1; ///
+sfs->FixFreeWireMode() = 1; ///
   sfs->SetMsgRegistrator ( msg );
   
   Standard_CString res = 0;

src/Select3D/Select3D_InteriorSensitivePointSet.cxx

@@ -259,12 +259,12 @@ void Select3D_InteriorSensitivePointSet::Swap (const Standard_Integer theIdx1,
 
 // =======================================================================
 // function : overlapsElement
-// purpose  : Checks whether the planar convex polygon with index theIdx
-//            in myPlanarPolygons overlaps the current selecting volume
+// purpose  :
 // =======================================================================
-Standard_Boolean Select3D_InteriorSensitivePointSet::overlapsElement (SelectBasics_SelectingVolumeManager& theMgr,
+Standard_Boolean Select3D_InteriorSensitivePointSet::overlapsElement (SelectBasics_PickResult& thePickResult,
+                                                                      SelectBasics_SelectingVolumeManager& theMgr,
                                                                       Standard_Integer theElemIdx,
-                                                                      SelectBasics_PickResult& thePickResult)
+                                                                      Standard_Boolean )
 {
   Standard_Integer aPolygIdx = myPolygonsIdxs->Value (theElemIdx);
   const Handle(Select3D_SensitivePoly)& aPolygon = myPlanarPolygons.Value (aPolygIdx);
@@ -278,10 +278,11 @@ Standard_Boolean Select3D_InteriorSensitivePointSet::overlapsElement (SelectBasi
 // purpose  :
 // =======================================================================
 Standard_Boolean Select3D_InteriorSensitivePointSet::elementIsInside (SelectBasics_SelectingVolumeManager& theMgr,
-                                                                      const Standard_Integer               theElemIdx)
+                                                                      Standard_Integer theElemIdx,
+                                                                      Standard_Boolean theIsFullInside)
 {
   SelectBasics_PickResult aDummy;
-  return overlapsElement (theMgr, theElemIdx, aDummy);
+  return overlapsElement (aDummy, theMgr, theElemIdx, theIsFullInside);
 }
 
 // =======================================================================

src/Select3D/Select3D_InteriorSensitivePointSet.hxx

@@ -76,13 +76,15 @@ protected:
 
   //! Checks whether the planar convex polygon with index theIdx
   //! in myPlanarPolygons overlaps the current selecting volume
-  Standard_EXPORT virtual Standard_Boolean overlapsElement (SelectBasics_SelectingVolumeManager& theMgr,
+  Standard_EXPORT virtual Standard_Boolean overlapsElement (SelectBasics_PickResult& thePickResult,
+                                                            SelectBasics_SelectingVolumeManager& theMgr,
                                                             Standard_Integer theElemIdx,
-                                                            SelectBasics_PickResult& thePickResult) Standard_OVERRIDE;
+                                                            Standard_Boolean theIsFullInside) Standard_OVERRIDE;
 
   //! Checks whether the entity with index theIdx is inside the current selecting volume
   Standard_EXPORT virtual Standard_Boolean elementIsInside (SelectBasics_SelectingVolumeManager& theMgr,
-                                                            const Standard_Integer               theElemIdx) Standard_OVERRIDE;
+                                                            Standard_Integer theElemIdx,
+                                                            Standard_Boolean theIsFullInside) Standard_OVERRIDE;
 
   //! Calculates distance from the 3d projection of used-picked
   //! screen point to center of the geometry

src/Select3D/Select3D_SensitiveGroup.cxx

@@ -326,9 +326,10 @@ Standard_Integer Select3D_SensitiveGroup::Size() const
 // purpose  : Checks whether the entity with index theIdx overlaps the
 //            current selecting volume
 // =======================================================================
-Standard_Boolean Select3D_SensitiveGroup::overlapsElement (SelectBasics_SelectingVolumeManager& theMgr,
+Standard_Boolean Select3D_SensitiveGroup::overlapsElement (SelectBasics_PickResult& thePickResult,
+                                                           SelectBasics_SelectingVolumeManager& theMgr,
                                                            Standard_Integer theElemIdx,
-                                                           SelectBasics_PickResult& thePickResult)
+                                                           Standard_Boolean )
 {
   const Standard_Integer aSensitiveIdx = myBVHPrimIndexes.Value (theElemIdx);
   if (myEntities.FindKey (aSensitiveIdx)->Matches (theMgr, thePickResult))
@@ -344,10 +345,11 @@ Standard_Boolean Select3D_SensitiveGroup::overlapsElement (SelectBasics_Selectin
 // purpose  :
 // =======================================================================
 Standard_Boolean Select3D_SensitiveGroup::elementIsInside (SelectBasics_SelectingVolumeManager& theMgr,
-                                                           const Standard_Integer               theElemIdx)
+                                                           Standard_Integer theElemIdx,
+                                                           Standard_Boolean theIsFullInside)
 {
   SelectBasics_PickResult aDummy;
-  return overlapsElement(theMgr, theElemIdx, aDummy);
+  return overlapsElement (aDummy, theMgr, theElemIdx, theIsFullInside);
 }
 
 // =======================================================================

src/Select3D/Select3D_SensitiveGroup.hxx

@@ -146,13 +146,15 @@ public:
 private:
 
   //! Checks whether the entity with index theIdx overlaps the current selecting volume
-  virtual Standard_Boolean overlapsElement (SelectBasics_SelectingVolumeManager& theMgr,
+  virtual Standard_Boolean overlapsElement (SelectBasics_PickResult& thePickResult,
+                                            SelectBasics_SelectingVolumeManager& theMgr,
                                             Standard_Integer theElemIdx,
-                                            SelectBasics_PickResult& thePickResult) Standard_OVERRIDE;
+                                            Standard_Boolean theIsFullInside) Standard_OVERRIDE;
 
   //! Checks whether the entity with index theIdx is inside the current selecting volume
   virtual Standard_Boolean elementIsInside (SelectBasics_SelectingVolumeManager& theMgr,
-                                            const Standard_Integer               theElemIdx) Standard_OVERRIDE;
+                                            Standard_Integer theElemIdx,
+                                            Standard_Boolean theIsFullInside) Standard_OVERRIDE;
 
   //! Calculates distance from the 3d projection of used-picked screen point to center of the geometry
   virtual Standard_Real distanceToCOG (SelectBasics_SelectingVolumeManager& theMgr) Standard_OVERRIDE;

src/Select3D/Select3D_SensitivePoly.cxx

@@ -220,17 +220,23 @@ void Select3D_SensitivePoly::Swap (const Standard_Integer theIdx1,
 //           theIdx overlaps the current selecting
 //           volume
 //==================================================
-Standard_Boolean Select3D_SensitivePoly::overlapsElement (SelectBasics_SelectingVolumeManager& theMgr,
+Standard_Boolean Select3D_SensitivePoly::overlapsElement (SelectBasics_PickResult& thePickResult,
+                                                          SelectBasics_SelectingVolumeManager& theMgr,
                                                           Standard_Integer theElemIdx,
-                                                          SelectBasics_PickResult& thePickResult)
+                                                          Standard_Boolean theIsFullInside)
 {
   if (mySegmentIndexes.IsNull())
+  {
     return Standard_False;
+  }
+  else if (theIsFullInside)
+  {
+    return Standard_True;
+  }
 
   const Standard_Integer aSegmentIdx = mySegmentIndexes->Value (theElemIdx);
   gp_Pnt aPnt1 = myPolyg.Pnt3d (aSegmentIdx);
   gp_Pnt aPnt2 = myPolyg.Pnt3d (aSegmentIdx + 1);
-
   return theMgr.Overlaps (aPnt1, aPnt2, thePickResult);
 }
 
@@ -239,10 +245,15 @@ Standard_Boolean Select3D_SensitivePoly::overlapsElement (SelectBasics_Selecting
 // Purpose  :
 //==================================================
 Standard_Boolean Select3D_SensitivePoly::elementIsInside (SelectBasics_SelectingVolumeManager& theMgr,
-                                                          const Standard_Integer               theElemIdx)
+                                                          Standard_Integer theElemIdx,
+                                                          Standard_Boolean theIsFullInside)
 {
-  const Standard_Integer aSegmentIdx = mySegmentIndexes->Value (theElemIdx);
+  if (theIsFullInside)
+  {
+    return Standard_True;
+  }
 
+  const Standard_Integer aSegmentIdx = mySegmentIndexes->Value (theElemIdx);
   return theMgr.Overlaps (myPolyg.Pnt3d (aSegmentIdx + 0))
       && theMgr.Overlaps (myPolyg.Pnt3d (aSegmentIdx + 1));
 }

src/Select3D/Select3D_SensitivePoly.hxx

@@ -95,13 +95,15 @@ public:
 private:
 
   //! Checks whether the segment with index theIdx overlaps the current selecting volume
-  virtual Standard_Boolean overlapsElement (SelectBasics_SelectingVolumeManager& theMgr,
+  virtual Standard_Boolean overlapsElement (SelectBasics_PickResult& thePickResult,
+                                            SelectBasics_SelectingVolumeManager& theMgr,
                                             Standard_Integer theElemIdx,
-                                            SelectBasics_PickResult& thePickResult) Standard_OVERRIDE;
+                                            Standard_Boolean theIsFullInside) Standard_OVERRIDE;
 
   //! Checks whether the entity with index theIdx is inside the current selecting volume
   virtual Standard_Boolean elementIsInside (SelectBasics_SelectingVolumeManager& theMgr,
-                                            const Standard_Integer               theElemIdx) Standard_OVERRIDE;
+                                            Standard_Integer theElemIdx,
+                                            Standard_Boolean theIsFullInside) Standard_OVERRIDE;
 
   //! Calculates distance from the 3d projection of used-picked screen point
   //! to center of the geometry

src/Select3D/Select3D_SensitivePrimitiveArray.cxx

@@ -908,7 +908,7 @@ Standard_Boolean Select3D_SensitivePrimitiveArray::Matches (SelectBasics_Selecti
    || theMgr.GetActiveSelectionType() == SelectBasics_SelectingVolumeManager::Point
    || !toDetectRange)
   {
-    if (!Select3D_SensitiveSet::Matches (theMgr, thePickResult))
+    if (!matches (theMgr, thePickResult, toDetectRange))
     {
       return Standard_False;
     }
@@ -929,35 +929,22 @@ Standard_Boolean Select3D_SensitivePrimitiveArray::Matches (SelectBasics_Selecti
   }
 
   SelectBasics_PickResult aPickResult;
-  bool isFailed = false;
-  const bool toMatchAll = !theMgr.IsOverlapAllowed();
+  bool hasResults = false;
   for (Standard_Integer aGroupIter = 0; aGroupIter < myBvhIndices.NbElements; ++aGroupIter)
   {
     const Standard_Integer anElemIdx = myBvhIndices.Index (aGroupIter);
     Handle(Select3D_SensitivePrimitiveArray)& aChild = myGroups->ChangeValue (anElemIdx);
-    const bool isMatched = aChild->Matches (theMgr, aPickResult);
-    if (!myDetectedElemMap.IsNull())
+    if (aChild->Matches (theMgr, aPickResult))
     {
-      myDetectedElemMap->ChangeMap().Unite (aChild->myDetectedElemMap->Map());
-    }
-    if (!myDetectedNodeMap.IsNull())
-    {
-      myDetectedNodeMap->ChangeMap().Unite (aChild->myDetectedNodeMap->Map());
-    }
-
-    if (!isMatched)
-    {
-      if (toMatchAll)
+      hasResults = true;
+      if (!myDetectedElemMap.IsNull())
       {
-        isFailed = true;
-        if (!toDetectRange)
-        {
-          break;
-        }
+        myDetectedElemMap->ChangeMap().Unite (aChild->myDetectedElemMap->Map());
+      }
+      if (!myDetectedNodeMap.IsNull())
+      {
+        myDetectedNodeMap->ChangeMap().Unite (aChild->myDetectedNodeMap->Map());
       }
-    }
-    else
-    {
       if (thePickResult.Depth() > aPickResult.Depth())
       {
         myDetectedIdx = aGroupIter;
@@ -965,7 +952,7 @@ Standard_Boolean Select3D_SensitivePrimitiveArray::Matches (SelectBasics_Selecti
       }
     }
   }
-  if (isFailed)
+  if (!hasResults)
   {
     return Standard_False;
   }
@@ -977,19 +964,15 @@ Standard_Boolean Select3D_SensitivePrimitiveArray::Matches (SelectBasics_Selecti
 // function : overlapsElement
 // purpose  :
 // =======================================================================
-Standard_Boolean Select3D_SensitivePrimitiveArray::overlapsElement (SelectBasics_SelectingVolumeManager& theMgr,
+Standard_Boolean Select3D_SensitivePrimitiveArray::overlapsElement (SelectBasics_PickResult& thePickResult,
+                                                                    SelectBasics_SelectingVolumeManager& theMgr,
                                                                     Standard_Integer theElemIdx,
-                                                                    SelectBasics_PickResult& thePickResult)
+                                                                    Standard_Boolean theIsFullInside)
 {
   const Standard_Integer anElemIdx = myBvhIndices.Index (theElemIdx);
   if (!myGroups.IsNull())
   {
-    if (myGroups->Value (anElemIdx)->Matches (theMgr, thePickResult))
-    {
-      return Standard_True;
-    }
-
-    return Standard_False;
+    return myGroups->Value (anElemIdx)->Matches (theMgr, thePickResult);
   }
 
   const Standard_Integer aPatchSize = myBvhIndices.PatchSize (theElemIdx);
@@ -1019,7 +1002,7 @@ Standard_Boolean Select3D_SensitivePrimitiveArray::overlapsElement (SelectBasics
         if (myToDetectNode
          || myToDetectElem)
         {
-          if (theMgr.Overlaps (aPoint, aPickResult))
+          if (theIsFullInside || theMgr.Overlaps (aPoint, aPickResult))
           {
             if (aPickResult.Depth() <= myMinDepthNode)
             {
@@ -1068,7 +1051,7 @@ Standard_Boolean Select3D_SensitivePrimitiveArray::overlapsElement (SelectBasics
 
         if (myToDetectElem)
         {
-          if (theMgr.Overlaps (aPnts[0], aPnts[1], aPnts[2], Select3D_TOS_INTERIOR, aPickResult))
+          if (theIsFullInside || theMgr.Overlaps (aPnts[0], aPnts[1], aPnts[2], Select3D_TOS_INTERIOR, aPickResult))
           {
             if (aPickResult.Depth() <= myMinDepthElem)
             {
@@ -1087,7 +1070,7 @@ Standard_Boolean Select3D_SensitivePrimitiveArray::overlapsElement (SelectBasics
         {
           for (int aNodeIter = 0; aNodeIter < 3; ++aNodeIter)
           {
-            if (theMgr.Overlaps (aPnts[aNodeIter], aPickResult))
+            if (theIsFullInside || theMgr.Overlaps (aPnts[aNodeIter], aPickResult))
             {
               if (aPickResult.Depth() <= myMinDepthNode)
               {
@@ -1109,7 +1092,7 @@ Standard_Boolean Select3D_SensitivePrimitiveArray::overlapsElement (SelectBasics
           {
             int aNode1 = aNodeIter == 0 ? 2 : (aNodeIter - 1);
             int aNode2 = aNodeIter;
-            if (theMgr.Overlaps (aPnts[aNode1], aPnts[aNode2], aPickResult))
+            if (theIsFullInside || theMgr.Overlaps (aPnts[aNode1], aPnts[aNode2], aPickResult))
             {
               if (aPickResult.Depth() <= myMinDepthEdge)
               {
@@ -1148,13 +1131,14 @@ Standard_Real Select3D_SensitivePrimitiveArray::distanceToCOG (SelectBasics_Sele
 // purpose  :
 // =======================================================================
 Standard_Boolean Select3D_SensitivePrimitiveArray::elementIsInside (SelectBasics_SelectingVolumeManager& theMgr,
-                                                                    const Standard_Integer               theElemIdx)
+                                                                    Standard_Integer theElemIdx,
+                                                                    Standard_Boolean theIsFullInside)
 {
   const Standard_Integer anElemIdx = myBvhIndices.Index (theElemIdx);
   if (!myGroups.IsNull())
   {
     SelectBasics_PickResult aDummy;
-    return overlapsElement (theMgr, theElemIdx, aDummy);
+    return myGroups->Value (anElemIdx)->Matches (theMgr, aDummy);
   }
 
   const Standard_Integer aPatchSize = myBvhIndices.PatchSize (theElemIdx);
@@ -1177,7 +1161,7 @@ Standard_Boolean Select3D_SensitivePrimitiveArray::elementIsInside (SelectBasics
         {
           aPoint = vecToPnt (getPosVec2 (aPointIndex));
         }
-        if (!theMgr.Overlaps (aPoint))
+        if (!theIsFullInside && !theMgr.Overlaps (aPoint))
         {
           return Standard_False;
         }
@@ -1218,9 +1202,9 @@ Standard_Boolean Select3D_SensitivePrimitiveArray::elementIsInside (SelectBasics
           aPnts[2] = vecToPnt (getPosVec2 (aTriNodes[2]));
         }
 
-        if (!theMgr.Overlaps (aPnts[0])
-         || !theMgr.Overlaps (aPnts[1])
-         || !theMgr.Overlaps (aPnts[2]))
+        if (!theIsFullInside && (   !theMgr.Overlaps (aPnts[0])
+                                 || !theMgr.Overlaps (aPnts[1])
+                                 || !theMgr.Overlaps (aPnts[2])))
         {
           return Standard_False;
         }

src/Select3D/Select3D_SensitivePrimitiveArray.hxx

@@ -278,16 +278,18 @@ protected:
   }
 
   //! Checks whether the element with index theIdx overlaps the current selecting volume
-  Standard_EXPORT virtual Standard_Boolean overlapsElement (SelectBasics_SelectingVolumeManager& theMgr,
+  Standard_EXPORT virtual Standard_Boolean overlapsElement (SelectBasics_PickResult& thePickResult,
+                                                            SelectBasics_SelectingVolumeManager& theMgr,
                                                             Standard_Integer theElemIdx,
-                                                            SelectBasics_PickResult& thePickResult) Standard_OVERRIDE;
+                                                            Standard_Boolean theIsFullInside) Standard_OVERRIDE;
 
   //! Calculates distance from the 3d projection of used-picked screen point to center of the geometry
   Standard_EXPORT virtual Standard_Real distanceToCOG (SelectBasics_SelectingVolumeManager& theMgr) Standard_OVERRIDE;
 
   //! Checks whether the entity with index theIdx is inside the current selecting volume
   Standard_EXPORT virtual Standard_Boolean elementIsInside (SelectBasics_SelectingVolumeManager& theMgr,
-                                                            const Standard_Integer               theElemIdx) Standard_OVERRIDE;
+                                                            Standard_Integer theElemIdx,
+                                                            Standard_Boolean theIsFullInside) Standard_OVERRIDE;
 
 private:
 

src/Select3D/Select3D_SensitiveSet.cxx

@@ -65,14 +65,26 @@ void Select3D_SensitiveSet::BVH()
   myContent.GetBVH();
 }
 
+namespace
+{
+  //! This structure describes the node in BVH
+  struct NodeInStack
+  {
+    NodeInStack (Standard_Integer theId = 0,
+                 Standard_Boolean theIsFullInside = false) : Id (theId), IsFullInside (theIsFullInside) {}
+
+    Standard_Integer Id;           //!< node identifier
+    Standard_Boolean IsFullInside; //!< if the node is completely inside the current selection volume
+  };
+}
+
 //=======================================================================
 // function : Matches
-// purpose  : Checks whether one or more entities of the set overlap
-//            current selecting volume. Implements the traverse of BVH
-//            tree built for the set
+// purpose  :
 //=======================================================================
-Standard_Boolean Select3D_SensitiveSet::Matches (SelectBasics_SelectingVolumeManager& theMgr,
-                                                 SelectBasics_PickResult& thePickResult)
+Standard_Boolean Select3D_SensitiveSet::matches (SelectBasics_SelectingVolumeManager& theMgr,
+                                                 SelectBasics_PickResult& thePickResult,
+                                                 Standard_Boolean theToCheckAllInside)
 {
   myDetectedIdx = -1;
   const BVH_Tree<Standard_Real, 3, BVH_BinaryTree>* aBVH = myContent.GetBVH().get();
@@ -82,50 +94,58 @@ Standard_Boolean Select3D_SensitiveSet::Matches (SelectBasics_SelectingVolumeMan
     return Standard_False;
   }
 
-  Standard_Integer aStack[BVH_Constants_MaxTreeDepth];
-  Standard_Integer aNode =  0;
+  NodeInStack aStack[BVH_Constants_MaxTreeDepth];
+  NodeInStack aNode;
+
   Standard_Integer aHead = -1;
 
   Standard_Integer aMatchesNb = -1;
   SelectBasics_PickResult aPickResult;
+  const bool toCheckFullInside = (theMgr.GetActiveSelectionType() != SelectBasics_SelectingVolumeManager::Point);
   for (;;)
   {
-    const BVH_Vec4i& aData = aBVH->NodeInfoBuffer()[aNode];
+    const BVH_Vec4i& aData = aBVH->NodeInfoBuffer()[aNode.Id];
 
     if (aData.x() == 0) // is inner node
     {
-      const Standard_Integer aLftIdx = aData.y();
-      const Standard_Integer aRghIdx = aData.z();
+      NodeInStack aLeft (aData.y(), toCheckFullInside), aRight(aData.z(), toCheckFullInside);
+      Standard_Boolean toCheckLft = Standard_True, toCheckRgh = Standard_True;
+      if (!aNode.IsFullInside)
+      {
+        toCheckLft = theMgr.Overlaps (aBVH->MinPoint (aLeft.Id), aBVH->MaxPoint (aLeft.Id), toCheckFullInside ? &aLeft.IsFullInside : NULL);
+        if (!toCheckLft)
+        {
+          aLeft.IsFullInside = Standard_False;
+        }
 
-      Standard_Boolean isLftInside = Standard_True;
-      Standard_Boolean isRghInside = Standard_True;
-
-      Standard_Boolean toCheckLft = theMgr.Overlaps (aBVH->MinPoint (aLftIdx),
-                                                     aBVH->MaxPoint (aLftIdx),
-                                                     theMgr.IsOverlapAllowed() ? NULL : &isLftInside);
-
-      Standard_Boolean toCheckRgh = theMgr.Overlaps (aBVH->MinPoint (aRghIdx),
-                                                     aBVH->MaxPoint (aRghIdx),
-                                                     theMgr.IsOverlapAllowed() ? NULL : &isRghInside);
+        toCheckRgh = theMgr.Overlaps (aBVH->MinPoint (aRight.Id), aBVH->MaxPoint (aRight.Id), toCheckFullInside ? &aRight.IsFullInside : NULL);
+        if (!toCheckRgh)
+        {
+          aRight.IsFullInside = Standard_False;
+        }
+      }
 
       if (!theMgr.IsOverlapAllowed()) // inclusion test
       {
-        if (!toCheckLft || !toCheckRgh)
+        if (!theToCheckAllInside)
         {
-          return Standard_False; // no inclusion
-        }
+          if (!toCheckLft || !toCheckRgh)
+          {
+            return Standard_False; // no inclusion
+          }
 
-        toCheckLft &= !isLftInside;
-        toCheckRgh &= !isRghInside;
+          // skip extra checks
+          toCheckLft &= !aLeft.IsFullInside;
+          toCheckRgh &= !aRight.IsFullInside;
+        }
       }
 
       if (toCheckLft || toCheckRgh)
       {
-        aNode = toCheckLft ? aLftIdx : aRghIdx;
-
+        aNode = toCheckLft ? aLeft : aRight;
         if (toCheckLft && toCheckRgh)
         {
-          aStack[++aHead] = aRghIdx;
+          aStack[++aHead] = aRight;
         }
       }
       else
@@ -142,14 +162,18 @@ Standard_Boolean Select3D_SensitiveSet::Matches (SelectBasics_SelectingVolumeMan
       {
         if (!theMgr.IsOverlapAllowed()) // inclusion test
         {
-          if (!elementIsInside (theMgr, anElemIdx))
+          if (!elementIsInside (theMgr, anElemIdx, aNode.IsFullInside))
           {
+            if (theToCheckAllInside)
+            {
+              continue;
+            }
             return Standard_False;
           }
         }
         else // overlap test
         {
-          if (!overlapsElement (theMgr, anElemIdx, aPickResult))
+          if (!overlapsElement (aPickResult, theMgr, anElemIdx, aNode.IsFullInside))
           {
             continue;
           }
@@ -159,9 +183,8 @@ Standard_Boolean Select3D_SensitiveSet::Matches (SelectBasics_SelectingVolumeMan
             thePickResult = aPickResult;
             myDetectedIdx = anElemIdx;
           }
-
-          ++aMatchesNb;
         }
+        ++aMatchesNb;
       }
 
       if (aHead < 0)
@@ -176,7 +199,8 @@ Standard_Boolean Select3D_SensitiveSet::Matches (SelectBasics_SelectingVolumeMan
     thePickResult.SetDistToGeomCenter(distanceToCOG(theMgr));
   }
 
-  return !theMgr.IsOverlapAllowed() || aMatchesNb != -1;
+  return aMatchesNb != -1
+     || (!theToCheckAllInside && !theMgr.IsOverlapAllowed());
 }
 
 //=======================================================================

src/Select3D/Select3D_SensitiveSet.hxx

@@ -64,8 +64,11 @@ public:
 
   //! Checks whether one or more entities of the set overlap current selecting volume.
   //! Implements the traverse of BVH tree built for the set
-  Standard_EXPORT virtual Standard_Boolean Matches (SelectBasics_SelectingVolumeManager& theMgr,
-                                                    SelectBasics_PickResult& thePickResult) Standard_OVERRIDE;
+  virtual Standard_Boolean Matches (SelectBasics_SelectingVolumeManager& theMgr,
+                                    SelectBasics_PickResult& thePickResult) Standard_OVERRIDE
+  {
+    return matches (theMgr, thePickResult, false);
+  }
 
   //! Builds BVH tree for sensitive set.
   //! Must be called manually to build BVH tree for any sensitive set
@@ -96,15 +99,36 @@ public:
 
 protected:
 
-  //! Checks whether the entity with index theIdx overlaps the current selecting volume.
-  //! @param theMatchDepth set to the current minimum depth by Select3D_SensitiveSet; should be set to the new depth when overlapping is detected
-  virtual Standard_Boolean overlapsElement (SelectBasics_SelectingVolumeManager& theMgr,
-                                            Standard_Integer theElemIdx,
-                                            SelectBasics_PickResult& thePickResult) = 0;
+  //! Checks whether one or more entities of the set overlap current selecting volume.
+  //! Implements the traverse of BVH tree built for the set
+  //! @param theMgr selection manager
+  //! @param thePickResult picking result (for picking by ray)
+  //! @param theToCheckAllInside flag indicating that even with SelectMgr_SelectingVolumeManager::IsOverlapAllowed() returning FALSE
+  //!        the method will return TRUE if at least one sub-element is fully inside selection volume ::elementIsInside();
+  //!        this is useful for entities allowing local selection of sub-elements using single Owner object.
+  Standard_EXPORT Standard_Boolean matches (SelectBasics_SelectingVolumeManager& theMgr,
+                                            SelectBasics_PickResult& thePickResult,
+                                            Standard_Boolean theToCheckAllInside);
 
-  //! Checks whether the entity with index theIdx is inside the current selecting volume
+  //! Checks whether the entity with index theIdx (partially) overlaps the current selecting volume.
+  //! @param thePickResult [OUT] picking result, should update minimum depth
+  //! @param theMgr [IN] selection manager
+  //! @param theElemIdx [IN] element index within BVH tree to check
+  //! @param theIsFullInside [IN] when TRUE indicates that entire BVH node is already inside selection volume (in case of rectangle selection);
+  //!                             in this case algorithm might skip checking the element and just register it as detected
+  virtual Standard_Boolean overlapsElement (SelectBasics_PickResult& thePickResult,
+                                            SelectBasics_SelectingVolumeManager& theMgr,
+                                            Standard_Integer theElemIdx,
+                                            Standard_Boolean theIsFullInside) = 0;
+
+  //! Checks whether the entity with index theIdx is (fully) inside the current selecting volume
+  //! @param theMgr [IN] selection manager
+  //! @param theElemIdx [IN] element index within BVH tree to check
+  //! @param theIsFullInside [IN] when TRUE indicates that entire BVH node is already inside selection volume (in case of rectangle selection);
+  //!                             in this case algorithm might skip checking the element and just register it as detected
   virtual Standard_Boolean elementIsInside (SelectBasics_SelectingVolumeManager& theMgr,
-                                            const Standard_Integer               theElemIdx) = 0;
+                                            Standard_Integer theElemIdx,
+                                            Standard_Boolean theIsFullInside) = 0;
 
   //! Calculates distance from the 3d projection of used-picked screen point to center of the geometry
   virtual Standard_Real distanceToCOG (SelectBasics_SelectingVolumeManager& theMgr) = 0;

src/Select3D/Select3D_SensitiveTriangulation.cxx

@@ -259,12 +259,17 @@ void Select3D_SensitiveTriangulation::Swap (const Standard_Integer theIdx1,
 // purpose  : Checks whether the element with index theIdx overlaps the
 //            current selecting volume
 //=======================================================================
-Standard_Boolean Select3D_SensitiveTriangulation::overlapsElement (SelectBasics_SelectingVolumeManager& theMgr,
+Standard_Boolean Select3D_SensitiveTriangulation::overlapsElement (SelectBasics_PickResult& thePickResult,
+                                                                   SelectBasics_SelectingVolumeManager& theMgr,
                                                                    Standard_Integer theElemIdx,
-                                                                   SelectBasics_PickResult& thePickResult)
+                                                                   Standard_Boolean theIsFullInside)
 {
-  const Standard_Integer& aPrimitiveIdx = myBVHPrimIndexes->Value (theElemIdx);
+  if (theIsFullInside)
+  {
+    return Standard_True;
+  }
 
+  const Standard_Integer aPrimitiveIdx = myBVHPrimIndexes->Value (theElemIdx);
   if (mySensType == Select3D_TOS_BOUNDARY)
   {
     Standard_Integer aSegmStartIdx = myFreeEdges->Value (aPrimitiveIdx * 2 + 1);
@@ -296,10 +301,15 @@ Standard_Boolean Select3D_SensitiveTriangulation::overlapsElement (SelectBasics_
 // Purpose  :
 //==================================================
 Standard_Boolean Select3D_SensitiveTriangulation::elementIsInside (SelectBasics_SelectingVolumeManager& theMgr,
-                                                                   const Standard_Integer               theElemIdx)
+                                                                   Standard_Integer theElemIdx,
+                                                                   Standard_Boolean theIsFullInside)
 {
-  const Standard_Integer& aPrimitiveIdx = myBVHPrimIndexes->Value (theElemIdx);
+  if (theIsFullInside)
+  {
+    return Standard_True;
+  }
 
+  const Standard_Integer aPrimitiveIdx = myBVHPrimIndexes->Value (theElemIdx);
   if (mySensType == Select3D_TOS_BOUNDARY)
   {
     const gp_Pnt& aSegmPnt1 = myTriangul->Nodes().Value (myFreeEdges->Value (aPrimitiveIdx * 2 + 1));

src/Select3D/Select3D_SensitiveTriangulation.hxx

@@ -102,16 +102,18 @@ protected:
 private:
 
   //! Checks whether the element with index theIdx overlaps the current selecting volume
-  virtual Standard_Boolean overlapsElement (SelectBasics_SelectingVolumeManager& theMgr,
+  virtual Standard_Boolean overlapsElement (SelectBasics_PickResult& thePickResult,
+                                            SelectBasics_SelectingVolumeManager& theMgr,
                                             Standard_Integer theElemIdx,
-                                            SelectBasics_PickResult& thePickResult) Standard_OVERRIDE;
+                                            Standard_Boolean theIsFullInside) Standard_OVERRIDE;
 
   //! Calculates distance from the 3d projection of used-picked screen point to center of the geometry
   virtual Standard_Real distanceToCOG (SelectBasics_SelectingVolumeManager& theMgr) Standard_OVERRIDE;
 
   //! Checks whether the entity with index theIdx is inside the current selecting volume
   virtual Standard_Boolean elementIsInside (SelectBasics_SelectingVolumeManager& theMgr,
-                                            const Standard_Integer               theElemIdx) Standard_OVERRIDE;
+                                            Standard_Integer theElemIdx,
+                                            Standard_Boolean theIsFullInside) Standard_OVERRIDE;
 
 private:
 

src/Select3D/Select3D_SensitiveWire.cxx

@@ -112,9 +112,10 @@ void Select3D_SensitiveWire::Swap (const Standard_Integer theIdx1,
 // purpose  : Checks whether the entity with index theIdx overlaps the
 //            current selecting volume
 // =======================================================================
-Standard_Boolean Select3D_SensitiveWire::overlapsElement (SelectBasics_SelectingVolumeManager& theMgr,
+Standard_Boolean Select3D_SensitiveWire::overlapsElement (SelectBasics_PickResult& thePickResult,
+                                                          SelectBasics_SelectingVolumeManager& theMgr,
                                                           Standard_Integer theElemIdx,
-                                                          SelectBasics_PickResult& thePickResult)
+                                                          Standard_Boolean )
 {
   const Standard_Integer aSensitiveIdx = myEntityIndexes.Value (theElemIdx);
   const Handle(SelectBasics_SensitiveEntity)& aSeg = myEntities.Value (aSensitiveIdx);
@@ -126,7 +127,8 @@ Standard_Boolean Select3D_SensitiveWire::overlapsElement (SelectBasics_Selecting
 // purpose  :
 // =======================================================================
 Standard_Boolean Select3D_SensitiveWire::elementIsInside (SelectBasics_SelectingVolumeManager& theMgr,
-                                                          const Standard_Integer               theElemIdx)
+                                                          Standard_Integer theElemIdx,
+                                                          Standard_Boolean )
 {
   SelectBasics_PickResult aMatchResult;
   return myEntities.Value (myEntityIndexes.Value (theElemIdx))->Matches (theMgr, aMatchResult);

src/Select3D/Select3D_SensitiveWire.hxx

@@ -73,13 +73,15 @@ public:
 protected:
 
   //! Checks whether the entity with index theIdx overlaps the current selecting volume
-  Standard_EXPORT virtual Standard_Boolean overlapsElement (SelectBasics_SelectingVolumeManager& theMgr,
+  Standard_EXPORT virtual Standard_Boolean overlapsElement (SelectBasics_PickResult& thePickResult,
+                                                            SelectBasics_SelectingVolumeManager& theMgr,
                                                             Standard_Integer theElemIdx,
-                                                            SelectBasics_PickResult& thePickResult) Standard_OVERRIDE;
+                                                            Standard_Boolean theIsFullInside) Standard_OVERRIDE;
 
   //! Checks whether the entity with index theIdx is inside the current selecting volume
   Standard_EXPORT virtual Standard_Boolean elementIsInside (SelectBasics_SelectingVolumeManager& theMgr,
-                                                            const Standard_Integer               theElemIdx) Standard_OVERRIDE;
+                                                            Standard_Integer theElemIdx,
+                                                            Standard_Boolean theIsFullInside) Standard_OVERRIDE;
 
   //! Calculates distance from the 3d projection of used-picked screen point to center of the geometry
   Standard_EXPORT virtual Standard_Real distanceToCOG (SelectBasics_SelectingVolumeManager& theMgr) Standard_OVERRIDE;

src/SelectBasics/SelectBasics_EntityOwner.cxx

@@ -27,3 +27,13 @@ SelectBasics_EntityOwner::SelectBasics_EntityOwner (const Standard_Integer thePr
 {
   //
 }
+
+//========================================
+// Function : SelectBasics_EntityOwner
+// Purpose  :
+//========================================
+SelectBasics_EntityOwner::SelectBasics_EntityOwner()
+: mypriority (0)
+{
+  //
+}

src/SelectBasics/SelectBasics_EntityOwner.hxx

@@ -62,7 +62,9 @@ public:
 
 protected:
 
-  Standard_EXPORT SelectBasics_EntityOwner (const Standard_Integer thePriority = 0);
+  Standard_EXPORT SelectBasics_EntityOwner (const Standard_Integer thePriority);
+
+  Standard_EXPORT SelectBasics_EntityOwner();
 
 protected:
 

src/SelectBasics/SelectBasics_SelectingVolumeManager.hxx

@@ -46,40 +46,40 @@ public:
   //! Returns true if selecting volume is overlapped by box theBox
   virtual Standard_Boolean Overlaps (const NCollection_Vec3<Standard_Real>& theBoxMin,
                                      const NCollection_Vec3<Standard_Real>& theBoxMax,
-                                     SelectBasics_PickResult& thePickResult) = 0;
+                                     SelectBasics_PickResult& thePickResult) const = 0;
 
   //! Returns true if selecting volume is overlapped by axis-aligned bounding box with minimum
   //! corner at point theMinPt and maximum at point theMaxPt
   virtual Standard_Boolean Overlaps (const NCollection_Vec3<Standard_Real>& theBoxMin,
                                      const NCollection_Vec3<Standard_Real>& theBoxMax,
-                                     Standard_Boolean*                      theInside = NULL) = 0;
+                                     Standard_Boolean*                      theInside = NULL) const = 0;
 
   //! Returns true if selecting volume is overlapped by point thePnt
   virtual Standard_Boolean Overlaps (const gp_Pnt& thePnt,
-                                     SelectBasics_PickResult& thePickResult) = 0;
+                                     SelectBasics_PickResult& thePickResult) const = 0;
 
   //! Returns true if selecting volume is overlapped by point thePnt.
   //! Does not perform depth calculation, so this method is defined as
   //! helper function for inclusion test.
-  virtual Standard_Boolean Overlaps (const gp_Pnt& thePnt) = 0;
+  virtual Standard_Boolean Overlaps (const gp_Pnt& thePnt) const = 0;
 
   //! Returns true if selecting volume is overlapped by planar convex polygon, which points
   //! are stored in theArrayOfPts, taking into account sensitivity type theSensType
   virtual Standard_Boolean Overlaps (const Handle(TColgp_HArray1OfPnt)& theArrayOfPts,
                                      Standard_Integer theSensType,
-                                     SelectBasics_PickResult& thePickResult) = 0;
+                                     SelectBasics_PickResult& thePickResult) const = 0;
 
   //! Returns true if selecting volume is overlapped by planar convex polygon, which points
   //! are stored in theArrayOfPts, taking into account sensitivity type theSensType
   virtual Standard_Boolean Overlaps (const TColgp_Array1OfPnt& theArrayOfPts,
                                      Standard_Integer theSensType,
-                                     SelectBasics_PickResult& thePickResult) = 0;
+                                     SelectBasics_PickResult& thePickResult) const = 0;
 
   //! Returns true if selecting volume is overlapped by line segment with start point at thePt1
   //! and end point at thePt2
   virtual Standard_Boolean Overlaps (const gp_Pnt& thePt1,
                                      const gp_Pnt& thePt2,
-                                     SelectBasics_PickResult& thePickResult) = 0;
+                                     SelectBasics_PickResult& thePickResult) const = 0;
 
   //! Returns true if selecting volume is overlapped by triangle with vertices thePt1,
   //! thePt2 and thePt3, taking into account sensitivity type theSensType
@@ -87,11 +87,11 @@ public:
                                      const gp_Pnt& thePt2,
                                      const gp_Pnt& thePt3,
                                      Standard_Integer theSensType,
-                                     SelectBasics_PickResult& thePickResult) = 0;
+                                     SelectBasics_PickResult& thePickResult) const = 0;
 
   //! Calculates distance from 3d projection of user-defined selection point
   //! to the given point theCOG
-  virtual Standard_Real DistToGeometryCenter (const gp_Pnt& theCOG) = 0;
+  virtual Standard_Real DistToGeometryCenter (const gp_Pnt& theCOG) const = 0;
 
   virtual gp_Pnt DetectedPoint (const Standard_Real theDepth) const = 0;
 

src/SelectMgr/SelectMgr_BaseFrustum.cxx

@@ -146,7 +146,7 @@ void SelectMgr_BaseFrustum::SetBuilder (const Handle(SelectMgr_FrustumBuilder)&
 //=======================================================================
 Standard_Boolean SelectMgr_BaseFrustum::Overlaps (const SelectMgr_Vec3& /*theBoxMin*/,
                                                   const SelectMgr_Vec3& /*theBoxMax*/,
-                                                  SelectBasics_PickResult& /*thePickResult*/)
+                                                  SelectBasics_PickResult& /*thePickResult*/) const
 {
   return Standard_False;
 }
@@ -157,7 +157,7 @@ Standard_Boolean SelectMgr_BaseFrustum::Overlaps (const SelectMgr_Vec3& /*theBox
 //=======================================================================
 Standard_Boolean SelectMgr_BaseFrustum::Overlaps (const SelectMgr_Vec3& /*theBoxMin*/,
                                                   const SelectMgr_Vec3& /*theBoxMax*/,
-                                                  Standard_Boolean*     /*theInside*/)
+                                                  Standard_Boolean*     /*theInside*/) const
 {
   return Standard_False;
 }
@@ -167,7 +167,7 @@ Standard_Boolean SelectMgr_BaseFrustum::Overlaps (const SelectMgr_Vec3& /*theBox
 // purpose  : Intersection test between defined volume and given point
 //=======================================================================
 Standard_Boolean SelectMgr_BaseFrustum::Overlaps (const gp_Pnt& /*thePnt*/,
-                                                  SelectBasics_PickResult& )
+                                                  SelectBasics_PickResult& ) const
 {
   return Standard_False;
 }
@@ -176,7 +176,7 @@ Standard_Boolean SelectMgr_BaseFrustum::Overlaps (const gp_Pnt& /*thePnt*/,
 // function : Overlaps
 // purpose  : Intersection test between defined volume and given point
 //=======================================================================
-Standard_Boolean SelectMgr_BaseFrustum::Overlaps (const gp_Pnt& /*thePnt*/)
+Standard_Boolean SelectMgr_BaseFrustum::Overlaps (const gp_Pnt& /*thePnt*/) const
 {
   return Standard_False;
 }
@@ -190,7 +190,7 @@ Standard_Boolean SelectMgr_BaseFrustum::Overlaps (const gp_Pnt& /*thePnt*/)
 //=======================================================================
 Standard_Boolean SelectMgr_BaseFrustum::Overlaps (const TColgp_Array1OfPnt& /*theArrayOfPnts*/,
                                                   Select3D_TypeOfSensitivity /*theSensType*/,
-                                                  SelectBasics_PickResult& )
+                                                  SelectBasics_PickResult& ) const
 {
   return Standard_False;
 }
@@ -206,7 +206,7 @@ Standard_Boolean SelectMgr_BaseFrustum::Overlaps (const gp_Pnt& /*thePt1*/,
                                                   const gp_Pnt& /*thePt2*/,
                                                   const gp_Pnt& /*thePt3*/,
                                                   Select3D_TypeOfSensitivity /*theSensType*/,
-                                                  SelectBasics_PickResult& )
+                                                  SelectBasics_PickResult& ) const
 {
   return Standard_False;
 }
@@ -217,7 +217,7 @@ Standard_Boolean SelectMgr_BaseFrustum::Overlaps (const gp_Pnt& /*thePt1*/,
 //=======================================================================
 Standard_Boolean SelectMgr_BaseFrustum::Overlaps (const gp_Pnt& /*thePnt1*/,
                                                   const gp_Pnt& /*thePnt2*/,
-                                                  SelectBasics_PickResult& )
+                                                  SelectBasics_PickResult& ) const
 {
   return Standard_False;
 }
@@ -227,7 +227,7 @@ Standard_Boolean SelectMgr_BaseFrustum::Overlaps (const gp_Pnt& /*thePnt1*/,
 // purpose  : Measures distance between 3d projection of user-picked
 //            screen point and given point theCOG
 //=======================================================================
-Standard_Real SelectMgr_BaseFrustum::DistToGeometryCenter (const gp_Pnt& /*theCOG*/)
+Standard_Real SelectMgr_BaseFrustum::DistToGeometryCenter (const gp_Pnt& /*theCOG*/) const
 {
   return DBL_MAX;
 }
@@ -247,7 +247,7 @@ gp_Pnt SelectMgr_BaseFrustum::DetectedPoint (const Standard_Real /*theDepth*/) c
 //            detected belongs to the region defined by clipping planes
 //=======================================================================
 Standard_Boolean SelectMgr_BaseFrustum::IsClipped (const Graphic3d_SequenceOfHClipPlane& /*thePlanes*/,
-                                                   const Standard_Real /*theDepth*/)
+                                                   const Standard_Real /*theDepth*/) const
 {
   return Standard_True;
 }

src/SelectMgr/SelectMgr_BaseFrustum.hxx

@@ -120,35 +120,35 @@ public:
   //! SAT intersection test between defined volume and given axis-aligned box
   Standard_EXPORT virtual Standard_Boolean Overlaps (const SelectMgr_Vec3& theBoxMin,
                                                      const SelectMgr_Vec3& theBoxMax,
-                                                     SelectBasics_PickResult& thePickResult);
+                                                     SelectBasics_PickResult& thePickResult) const;
 
   //! Returns true if selecting volume is overlapped by axis-aligned bounding box
   //! with minimum corner at point theMinPt and maximum at point theMaxPt
   Standard_EXPORT virtual Standard_Boolean Overlaps (const SelectMgr_Vec3& theBoxMin,
                                                      const SelectMgr_Vec3& theBoxMax,
-                                                     Standard_Boolean*     theInside = NULL);
+                                                     Standard_Boolean*     theInside = NULL) const;
 
   //! Intersection test between defined volume and given point
   Standard_EXPORT virtual Standard_Boolean Overlaps (const gp_Pnt& thePnt,
-                                                     SelectBasics_PickResult& thePickResult);
+                                                     SelectBasics_PickResult& thePickResult) const;
 
   //! Intersection test between defined volume and given point
   //! Does not perform depth calculation, so this method is defined as
   //! helper function for inclusion test. Therefore, its implementation
   //! makes sense only for rectangular frustum with box selection mode activated.
-  Standard_EXPORT virtual Standard_Boolean Overlaps (const gp_Pnt& thePnt);
+  Standard_EXPORT virtual Standard_Boolean Overlaps (const gp_Pnt& thePnt) const;
 
   //! SAT intersection test between defined volume and given ordered set of points,
   //! representing line segments. The test may be considered of interior part or
   //! boundary line defined by segments depending on given sensitivity type
   Standard_EXPORT virtual Standard_Boolean Overlaps (const TColgp_Array1OfPnt& theArrayOfPnts,
                                                      Select3D_TypeOfSensitivity theSensType,
-                                                     SelectBasics_PickResult& thePickResult);
+                                                     SelectBasics_PickResult& thePickResult) const;
 
   //! Checks if line segment overlaps selecting frustum
   Standard_EXPORT virtual Standard_Boolean Overlaps (const gp_Pnt& thePnt1,
                                                      const gp_Pnt& thePnt2,
-                                                     SelectBasics_PickResult& thePickResult);
+                                                     SelectBasics_PickResult& thePickResult) const;
 
   //! SAT intersection test between defined volume and given triangle. The test may
   //! be considered of interior part or boundary line defined by triangle vertices
@@ -157,18 +157,18 @@ public:
                                                      const gp_Pnt& thePt2,
                                                      const gp_Pnt& thePt3,
                                                      Select3D_TypeOfSensitivity theSensType,
-                                                     SelectBasics_PickResult& thePickResult);
+                                                     SelectBasics_PickResult& thePickResult) const;
 
   //! Measures distance between 3d projection of user-picked
   //! screen point and given point theCOG
-  Standard_EXPORT virtual Standard_Real DistToGeometryCenter (const gp_Pnt& theCOG);
+  Standard_EXPORT virtual Standard_Real DistToGeometryCenter (const gp_Pnt& theCOG) const;
 
   Standard_EXPORT virtual gp_Pnt DetectedPoint (const Standard_Real theDepth) const;
 
   //! Checks if the point of sensitive in which selection was detected belongs
   //! to the region defined by clipping planes
   Standard_EXPORT virtual Standard_Boolean IsClipped (const Graphic3d_SequenceOfHClipPlane& thePlanes,
-                                                      const Standard_Real theDepth);
+                                                      const Standard_Real theDepth) const;
 
   //! Valid for point selection only!
   //! Computes depth range for global (defined for the whole view) clipping planes.

src/SelectMgr/SelectMgr_Frustum.hxx

@@ -66,24 +66,24 @@ protected:
   //! with minimum corner at point theMinPt and maximum at point theMaxPt
   Standard_Boolean hasOverlap (const SelectMgr_Vec3& theBoxMin,
                                const SelectMgr_Vec3& theBoxMax,
-                               Standard_Boolean*     theInside = NULL);
+                               Standard_Boolean*     theInside = NULL) const;
 
   //! SAT intersection test between defined volume and given point
-  Standard_Boolean hasOverlap (const gp_Pnt& thePnt);
+  Standard_Boolean hasOverlap (const gp_Pnt& thePnt) const;
 
   //! SAT intersection test between defined volume and given segment
   Standard_Boolean hasOverlap (const gp_Pnt& thePnt1,
-                               const gp_Pnt& thePnt2);
+                               const gp_Pnt& thePnt2) const;
 
   //! SAT intersection test between frustum given and planar convex polygon represented as ordered point set
   Standard_Boolean hasOverlap (const TColgp_Array1OfPnt& theArrayOfPnts,
-                               gp_Vec& theNormal);
+                               gp_Vec& theNormal) const;
 
   //! SAT intersection test between defined volume and given triangle
   Standard_Boolean hasOverlap (const gp_Pnt& thePnt1,
                                const gp_Pnt& thePnt2,
                                const gp_Pnt& thePnt3,
-                               gp_Vec& theNormal);
+                               gp_Vec& theNormal) const;
 
 private:
 

src/SelectMgr/SelectMgr_Frustum.lxx

@@ -129,7 +129,7 @@ Standard_Boolean SelectMgr_Frustum<N>::isSeparated (const gp_Pnt& thePnt1,
 template <int N>
 Standard_Boolean SelectMgr_Frustum<N>::hasOverlap (const SelectMgr_Vec3& theMinPnt,
                                                    const SelectMgr_Vec3& theMaxPnt,
-                                                   Standard_Boolean*     theInside)
+                                                   Standard_Boolean*     theInside) const
 {
   for (Standard_Integer anAxis = 0; anAxis < 3; ++anAxis)
   {
@@ -203,7 +203,7 @@ Standard_Boolean SelectMgr_Frustum<N>::hasOverlap (const SelectMgr_Vec3& theMinP
 // purpose  : SAT intersection test between defined volume and given point
 // =======================================================================
 template <int N>
-Standard_Boolean SelectMgr_Frustum<N>::hasOverlap (const gp_Pnt& thePnt)
+Standard_Boolean SelectMgr_Frustum<N>::hasOverlap (const gp_Pnt& thePnt) const
 {
   const Standard_Integer anIncFactor = (myIsOrthographic && N == 4) ? 2 : 1;
 
@@ -227,7 +227,7 @@ Standard_Boolean SelectMgr_Frustum<N>::hasOverlap (const gp_Pnt& thePnt)
 // =======================================================================
 template <int N>
 Standard_Boolean SelectMgr_Frustum<N>::hasOverlap (const gp_Pnt& theStartPnt,
-                                                   const gp_Pnt& theEndPnt)
+                                                   const gp_Pnt& theEndPnt) const
 {
   const gp_XYZ& aDir = theEndPnt.XYZ() - theStartPnt.XYZ();
   if (aDir.Modulus() < Precision::Confusion())
@@ -309,7 +309,7 @@ Standard_Boolean SelectMgr_Frustum<N>::hasOverlap (const gp_Pnt& theStartPnt,
 // =======================================================================
 template <int N>
 Standard_Boolean SelectMgr_Frustum<N>::hasOverlap (const TColgp_Array1OfPnt& theArrayOfPnts,
-                                                   gp_Vec& theNormal)
+                                                   gp_Vec& theNormal) const
 {
   Standard_Integer aStartIdx = theArrayOfPnts.Lower();
   Standard_Integer anEndIdx = theArrayOfPnts.Upper();
@@ -406,7 +406,7 @@ template <int N>
 Standard_Boolean SelectMgr_Frustum<N>::hasOverlap (const gp_Pnt& thePnt1,
                                                    const gp_Pnt& thePnt2,
                                                    const gp_Pnt& thePnt3,
-                                                   gp_Vec& theNormal)
+                                                   gp_Vec& theNormal) const
 {
   const gp_XYZ aTrEdges[3] = { thePnt2.XYZ() - thePnt1.XYZ(),
                                thePnt3.XYZ() - thePnt2.XYZ(),

src/SelectMgr/SelectMgr_RectangularFrustum.cxx

@@ -24,7 +24,7 @@
 // =======================================================================
 void SelectMgr_RectangularFrustum::segmentSegmentDistance (const gp_Pnt& theSegPnt1,
                                                            const gp_Pnt& theSegPnt2,
-                                                           SelectBasics_PickResult& thePickResult)
+                                                           SelectBasics_PickResult& thePickResult) const
 {
   gp_XYZ anU = theSegPnt2.XYZ() - theSegPnt1.XYZ();
   gp_XYZ aV = myViewRayDir.XYZ();
@@ -95,7 +95,7 @@ void SelectMgr_RectangularFrustum::segmentSegmentDistance (const gp_Pnt& theSegP
 // =======================================================================
 bool SelectMgr_RectangularFrustum::segmentPlaneIntersection (const gp_Vec& thePlane,
                                                              const gp_Pnt& thePntOnPlane,
-                                                             SelectBasics_PickResult& thePickResult)
+                                                             SelectBasics_PickResult& thePickResult) const
 {
   gp_XYZ anU = myViewRayDir.XYZ();
   gp_XYZ aW = myNearPickedPnt.XYZ() - thePntOnPlane.XYZ();
@@ -429,7 +429,7 @@ Handle(SelectMgr_BaseFrustum) SelectMgr_RectangularFrustum::ScaleAndTransform (c
 // =======================================================================
 Standard_Boolean SelectMgr_RectangularFrustum::Overlaps (const SelectMgr_Vec3& theBoxMin,
                                                          const SelectMgr_Vec3& theBoxMax,
-                                                         Standard_Boolean*     theInside)
+                                                         Standard_Boolean*     theInside) const
 {
   return hasOverlap (theBoxMin, theBoxMax, theInside);
 }
@@ -441,7 +441,7 @@ Standard_Boolean SelectMgr_RectangularFrustum::Overlaps (const SelectMgr_Vec3& t
 // =======================================================================
 Standard_Boolean SelectMgr_RectangularFrustum::Overlaps (const SelectMgr_Vec3& theBoxMin,
                                                          const SelectMgr_Vec3& theBoxMax,
-                                                         SelectBasics_PickResult& thePickResult)
+                                                         SelectBasics_PickResult& thePickResult) const
 {
   if (!hasOverlap (theBoxMin, theBoxMax))
     return Standard_False;
@@ -461,7 +461,7 @@ Standard_Boolean SelectMgr_RectangularFrustum::Overlaps (const SelectMgr_Vec3& t
 // purpose  : Intersection test between defined volume and given point
 // =======================================================================
 Standard_Boolean SelectMgr_RectangularFrustum::Overlaps (const gp_Pnt& thePnt,
-                                                         SelectBasics_PickResult& thePickResult)
+                                                         SelectBasics_PickResult& thePickResult) const
 {
   if (!hasOverlap (thePnt))
     return Standard_False;
@@ -480,7 +480,7 @@ Standard_Boolean SelectMgr_RectangularFrustum::Overlaps (const gp_Pnt& thePnt,
 // function : Overlaps
 // purpose  : Intersection test between defined volume and given point
 // =======================================================================
-Standard_Boolean SelectMgr_RectangularFrustum::Overlaps (const gp_Pnt& thePnt)
+Standard_Boolean SelectMgr_RectangularFrustum::Overlaps (const gp_Pnt& thePnt) const
 {
   return hasOverlap (thePnt);
 }
@@ -491,7 +491,7 @@ Standard_Boolean SelectMgr_RectangularFrustum::Overlaps (const gp_Pnt& thePnt)
 // =======================================================================
 Standard_Boolean SelectMgr_RectangularFrustum::Overlaps (const gp_Pnt& thePnt1,
                                                          const gp_Pnt& thePnt2,
-                                                         SelectBasics_PickResult& thePickResult)
+                                                         SelectBasics_PickResult& thePickResult) const
 {
   if (!hasOverlap (thePnt1, thePnt2))
     return Standard_False;
@@ -510,7 +510,7 @@ Standard_Boolean SelectMgr_RectangularFrustum::Overlaps (const gp_Pnt& thePnt1,
 // =======================================================================
 Standard_Boolean SelectMgr_RectangularFrustum::Overlaps (const TColgp_Array1OfPnt& theArrayOfPnts,
                                                          Select3D_TypeOfSensitivity theSensType,
-                                                         SelectBasics_PickResult& thePickResult)
+                                                         SelectBasics_PickResult& thePickResult) const
 {
   if (theSensType == Select3D_TOS_BOUNDARY)
   {
@@ -560,7 +560,7 @@ Standard_Boolean SelectMgr_RectangularFrustum::Overlaps (const gp_Pnt& thePnt1,
                                                          const gp_Pnt& thePnt2,
                                                          const gp_Pnt& thePnt3,
                                                          Select3D_TypeOfSensitivity theSensType,
-                                                         SelectBasics_PickResult& thePickResult)
+                                                         SelectBasics_PickResult& thePickResult) const
 {
   if (theSensType == Select3D_TOS_BOUNDARY)
   {
@@ -639,7 +639,7 @@ Standard_Boolean SelectMgr_RectangularFrustum::Overlaps (const gp_Pnt& thePnt1,
 // purpose  : Measures distance between 3d projection of user-picked
 //            screen point and given point theCOG
 // =======================================================================
-Standard_Real SelectMgr_RectangularFrustum::DistToGeometryCenter (const gp_Pnt& theCOG)
+Standard_Real SelectMgr_RectangularFrustum::DistToGeometryCenter (const gp_Pnt& theCOG) const
 {
   return theCOG.Distance (myNearPickedPnt) * myScale;
 }
@@ -659,7 +659,7 @@ gp_Pnt SelectMgr_RectangularFrustum::DetectedPoint (const Standard_Real theDepth
 // purpose  :
 // =======================================================================
 void SelectMgr_RectangularFrustum::computeClippingRange (const Graphic3d_SequenceOfHClipPlane& thePlanes,
-                                                         SelectMgr_ViewClipRange& theRange)
+                                                         SelectMgr_ViewClipRange& theRange) const
 {
   Standard_Real aPlaneA, aPlaneB, aPlaneC, aPlaneD;
   for (Graphic3d_SequenceOfHClipPlane::Iterator aPlaneIt (thePlanes); aPlaneIt.More(); aPlaneIt.Next())
@@ -710,11 +710,11 @@ void SelectMgr_RectangularFrustum::computeClippingRange (const Graphic3d_Sequenc
       {
         if (aDotProduct < 0.0)
         {
-          theRange.ChangeMain().Add (Bnd_Range (aDistToPln, RealLast()));
+          theRange.ChangeUnclipRange().TrimTo (aDistToPln);
         }
         else
         {
-          theRange.ChangeMain().Add (Bnd_Range (RealFirst(), aDistToPln));
+          theRange.ChangeUnclipRange().TrimFrom (aDistToPln);
         }
       }
       else
@@ -733,7 +733,7 @@ void SelectMgr_RectangularFrustum::computeClippingRange (const Graphic3d_Sequenc
     if (!aSubRange.IsVoid()
       && aClipPlane->IsChain())
     {
-      theRange.AddSubRange (aSubRange);
+      theRange.AddClipSubRange (aSubRange);
     }
   }
 }
@@ -744,7 +744,7 @@ void SelectMgr_RectangularFrustum::computeClippingRange (const Graphic3d_Sequenc
 //            detected belongs to the region defined by clipping planes
 // =======================================================================
 Standard_Boolean SelectMgr_RectangularFrustum::IsClipped (const Graphic3d_SequenceOfHClipPlane& thePlanes,
-                                                          const Standard_Real theDepth)
+                                                          const Standard_Real theDepth) const
 {
   SelectMgr_ViewClipRange aRange;
   computeClippingRange (thePlanes, aRange);

src/SelectMgr/SelectMgr_RectangularFrustum.hxx

@@ -59,32 +59,32 @@ public:
   //! SAT intersection test between defined volume and given axis-aligned box
   Standard_EXPORT virtual Standard_Boolean Overlaps (const SelectMgr_Vec3& theBoxMin,
                                                      const SelectMgr_Vec3& theBoxMax,
-                                                     SelectBasics_PickResult& thePickResult) Standard_OVERRIDE;
+                                                     SelectBasics_PickResult& thePickResult) const Standard_OVERRIDE;
 
   //! Returns true if selecting volume is overlapped by axis-aligned bounding box
   //! with minimum corner at point theMinPt and maximum at point theMaxPt
   Standard_EXPORT virtual Standard_Boolean Overlaps (const SelectMgr_Vec3& theBoxMin,
                                                      const SelectMgr_Vec3& theBoxMax,
-                                                     Standard_Boolean*     theInside = NULL) Standard_OVERRIDE;
+                                                     Standard_Boolean*     theInside) const Standard_OVERRIDE;
 
   //! Intersection test between defined volume and given point
   Standard_EXPORT virtual Standard_Boolean Overlaps (const gp_Pnt& thePnt,
-                                                     SelectBasics_PickResult& thePickResult) Standard_OVERRIDE;
+                                                     SelectBasics_PickResult& thePickResult) const Standard_OVERRIDE;
 
   //! Intersection test between defined volume and given point
-  Standard_EXPORT virtual Standard_Boolean Overlaps (const gp_Pnt& thePnt) Standard_OVERRIDE;
+  Standard_EXPORT virtual Standard_Boolean Overlaps (const gp_Pnt& thePnt) const Standard_OVERRIDE;
 
   //! SAT intersection test between defined volume and given ordered set of points,
   //! representing line segments. The test may be considered of interior part or
   //! boundary line defined by segments depending on given sensitivity type
   Standard_EXPORT virtual Standard_Boolean Overlaps (const TColgp_Array1OfPnt& theArrayOfPnts,
                                                      Select3D_TypeOfSensitivity theSensType,
-                                                     SelectBasics_PickResult& thePickResult) Standard_OVERRIDE;
+                                                     SelectBasics_PickResult& thePickResult) const Standard_OVERRIDE;
 
   //! Checks if line segment overlaps selecting frustum
   Standard_EXPORT virtual Standard_Boolean Overlaps (const gp_Pnt& thePnt1,
                                                      const gp_Pnt& thePnt2,
-                                                     SelectBasics_PickResult& thePickResult) Standard_OVERRIDE;
+                                                     SelectBasics_PickResult& thePickResult) const Standard_OVERRIDE;
 
   //! SAT intersection test between defined volume and given triangle. The test may
   //! be considered of interior part or boundary line defined by triangle vertices
@@ -93,11 +93,11 @@ public:
                                                      const gp_Pnt& thePnt2,
                                                      const gp_Pnt& thePnt3,
                                                      Select3D_TypeOfSensitivity theSensType,
-                                                     SelectBasics_PickResult& thePickResult) Standard_OVERRIDE;
+                                                     SelectBasics_PickResult& thePickResult) const Standard_OVERRIDE;
 
   //! Measures distance between 3d projection of user-picked
   //! screen point and given point theCOG
-  Standard_EXPORT virtual Standard_Real DistToGeometryCenter (const gp_Pnt& theCOG) Standard_OVERRIDE;
+  Standard_EXPORT virtual Standard_Real DistToGeometryCenter (const gp_Pnt& theCOG) const Standard_OVERRIDE;
 
   //! Calculates the point on a view ray that was detected during the run of selection algo by given depth
   Standard_EXPORT virtual gp_Pnt DetectedPoint (const Standard_Real theDepth) const Standard_OVERRIDE;
@@ -105,7 +105,7 @@ public:
   //! Checks if the point of sensitive in which selection was detected belongs
   //! to the region defined by clipping planes
   Standard_EXPORT virtual Standard_Boolean IsClipped (const Graphic3d_SequenceOfHClipPlane& thePlanes,
-                                                      const Standard_Real theDepth) Standard_OVERRIDE;
+                                                      const Standard_Real theDepth) const Standard_OVERRIDE;
 
   //! Valid for point selection only!
   //! Computes depth range for global (defined for the whole view) clipping planes.
@@ -141,15 +141,15 @@ protected:
 
   Standard_EXPORT void segmentSegmentDistance (const gp_Pnt& theSegPnt1,
                                                const gp_Pnt& theSegPnt2,
-                                               SelectBasics_PickResult& thePickResult);
+                                               SelectBasics_PickResult& thePickResult) const;
 
   Standard_EXPORT bool segmentPlaneIntersection (const gp_Vec& thePlane,
                                                  const gp_Pnt& thePntOnPlane,
-                                                 SelectBasics_PickResult& thePickResult);
+                                                 SelectBasics_PickResult& thePickResult) const;
 
   //! Computes valid depth range for the given clipping planes
   Standard_EXPORT void computeClippingRange (const Graphic3d_SequenceOfHClipPlane& thePlanes,
-                                             SelectMgr_ViewClipRange& theRange);
+                                             SelectMgr_ViewClipRange& theRange) const;
 
   //! Returns false if theDepth must be clipped by current view clip range
   Standard_EXPORT Standard_Boolean isViewClippingOk (const SelectBasics_PickResult& thePickResult) const;

src/SelectMgr/SelectMgr_SelectingVolumeManager.cxx

@@ -236,7 +236,7 @@ void SelectMgr_SelectingVolumeManager::BuildSelectingVolume (const TColgp_Array1
 //=======================================================================
 Standard_Boolean SelectMgr_SelectingVolumeManager::Overlaps (const SelectMgr_Vec3& theBoxMin,
                                                              const SelectMgr_Vec3& theBoxMax,
-                                                             SelectBasics_PickResult& thePickResult)
+                                                             SelectBasics_PickResult& thePickResult) const
 {
   if (myActiveSelectionType == Unknown)
     return Standard_False;
@@ -250,7 +250,7 @@ Standard_Boolean SelectMgr_SelectingVolumeManager::Overlaps (const SelectMgr_Vec
 //=======================================================================
 Standard_Boolean SelectMgr_SelectingVolumeManager::Overlaps (const SelectMgr_Vec3& theBoxMin,
                                                              const SelectMgr_Vec3& theBoxMax,
-                                                             Standard_Boolean*     theInside)
+                                                             Standard_Boolean*     theInside) const
 {
   if (myActiveSelectionType == Unknown)
     return Standard_False;
@@ -263,7 +263,7 @@ Standard_Boolean SelectMgr_SelectingVolumeManager::Overlaps (const SelectMgr_Vec
 // purpose  : Intersection test between defined volume and given point
 //=======================================================================
 Standard_Boolean SelectMgr_SelectingVolumeManager::Overlaps (const gp_Pnt& thePnt,
-                                                             SelectBasics_PickResult& thePickResult)
+                                                             SelectBasics_PickResult& thePickResult) const
 {
   if (myActiveSelectionType == Unknown)
     return Standard_False;
@@ -276,7 +276,7 @@ Standard_Boolean SelectMgr_SelectingVolumeManager::Overlaps (const gp_Pnt& thePn
 // function : Overlaps
 // purpose  : Intersection test between defined volume and given point
 //=======================================================================
-Standard_Boolean SelectMgr_SelectingVolumeManager::Overlaps (const gp_Pnt& thePnt)
+Standard_Boolean SelectMgr_SelectingVolumeManager::Overlaps (const gp_Pnt& thePnt) const
 {
   if (myActiveSelectionType == Unknown)
     return Standard_False;
@@ -293,7 +293,7 @@ Standard_Boolean SelectMgr_SelectingVolumeManager::Overlaps (const gp_Pnt& thePn
 //=======================================================================
 Standard_Boolean SelectMgr_SelectingVolumeManager::Overlaps (const Handle(TColgp_HArray1OfPnt)& theArrayOfPnts,
                                                              Standard_Integer theSensType,
-                                                             SelectBasics_PickResult& thePickResult)
+                                                             SelectBasics_PickResult& thePickResult) const
 {
   if (myActiveSelectionType == Unknown)
     return Standard_False;
@@ -312,7 +312,7 @@ Standard_Boolean SelectMgr_SelectingVolumeManager::Overlaps (const Handle(TColgp
 //=======================================================================
 Standard_Boolean SelectMgr_SelectingVolumeManager::Overlaps (const TColgp_Array1OfPnt& theArrayOfPnts,
                                                              Standard_Integer theSensType,
-                                                             SelectBasics_PickResult& thePickResult)
+                                                             SelectBasics_PickResult& thePickResult) const
 {
   if (myActiveSelectionType == Unknown)
     return Standard_False;
@@ -328,7 +328,7 @@ Standard_Boolean SelectMgr_SelectingVolumeManager::Overlaps (const TColgp_Array1
 //=======================================================================
 Standard_Boolean SelectMgr_SelectingVolumeManager::Overlaps (const gp_Pnt& thePt1,
                                                              const gp_Pnt& thePt2,
-                                                             SelectBasics_PickResult& thePickResult)
+                                                             SelectBasics_PickResult& thePickResult) const
 {
   if (myActiveSelectionType == Unknown)
     return Standard_False;
@@ -347,7 +347,7 @@ Standard_Boolean SelectMgr_SelectingVolumeManager::Overlaps (const gp_Pnt& thePt
                                                              const gp_Pnt& thePt2,
                                                              const gp_Pnt& thePt3,
                                                              Standard_Integer theSensType,
-                                                             SelectBasics_PickResult& thePickResult)
+                                                             SelectBasics_PickResult& thePickResult) const
 {
   if (myActiveSelectionType == Unknown)
     return Standard_False;
@@ -364,7 +364,7 @@ Standard_Boolean SelectMgr_SelectingVolumeManager::Overlaps (const gp_Pnt& thePt
 // purpose  : Measures distance between 3d projection of user-picked
 //            screen point and given point theCOG
 //=======================================================================
-Standard_Real SelectMgr_SelectingVolumeManager::DistToGeometryCenter (const gp_Pnt& theCOG)
+Standard_Real SelectMgr_SelectingVolumeManager::DistToGeometryCenter (const gp_Pnt& theCOG) const
 {
   if (myActiveSelectionType == Unknown)
     return Standard_False;
@@ -394,7 +394,7 @@ gp_Pnt SelectMgr_SelectingVolumeManager::DetectedPoint (const Standard_Real theD
 //            detected belongs to the region defined by clipping planes
 //=======================================================================
 Standard_Boolean SelectMgr_SelectingVolumeManager::IsClipped (const Graphic3d_SequenceOfHClipPlane& thePlanes,
-                                                              const Standard_Real& theDepth)
+                                                              const Standard_Real& theDepth) const
 {
   if (myActiveSelectionType != Point)
     return Standard_False;

src/SelectMgr/SelectMgr_SelectingVolumeManager.hxx

@@ -106,39 +106,39 @@ public:
   //! SAT intersection test between defined volume and given axis-aligned box
   Standard_EXPORT virtual Standard_Boolean Overlaps (const SelectMgr_Vec3& theBoxMin,
                                                      const SelectMgr_Vec3& theBoxMax,
-                                                     SelectBasics_PickResult& thePickResult) Standard_OVERRIDE;
+                                                     SelectBasics_PickResult& thePickResult) const Standard_OVERRIDE;
 
   //! Returns true if selecting volume is overlapped by axis-aligned bounding box
   //! with minimum corner at point theMinPt and maximum at point theMaxPt
   Standard_EXPORT  virtual Standard_Boolean Overlaps (const SelectMgr_Vec3& theBoxMin,
                                                       const SelectMgr_Vec3& theBoxMax,
-                                                      Standard_Boolean*     theInside = NULL) Standard_OVERRIDE;
+                                                      Standard_Boolean*     theInside = NULL) const Standard_OVERRIDE;
 
   //! Intersection test between defined volume and given point
   Standard_EXPORT virtual Standard_Boolean Overlaps (const gp_Pnt& thePnt,
-                                                     SelectBasics_PickResult& thePickResult) Standard_OVERRIDE;
+                                                     SelectBasics_PickResult& thePickResult) const Standard_OVERRIDE;
 
   //! Intersection test between defined volume and given point
-  Standard_EXPORT virtual Standard_Boolean Overlaps (const gp_Pnt& thePnt) Standard_OVERRIDE;
+  Standard_EXPORT virtual Standard_Boolean Overlaps (const gp_Pnt& thePnt) const Standard_OVERRIDE;
 
   //! SAT intersection test between defined volume and given ordered set of points,
   //! representing line segments. The test may be considered of interior part or
   //! boundary line defined by segments depending on given sensitivity type
   Standard_EXPORT virtual Standard_Boolean Overlaps (const Handle(TColgp_HArray1OfPnt)& theArrayOfPts,
                                                      Standard_Integer theSensType,
-                                                     SelectBasics_PickResult& thePickResult) Standard_OVERRIDE;
+                                                     SelectBasics_PickResult& thePickResult) const Standard_OVERRIDE;
 
   //! SAT intersection test between defined volume and given ordered set of points,
   //! representing line segments. The test may be considered of interior part or
   //! boundary line defined by segments depending on given sensitivity type
   Standard_EXPORT virtual Standard_Boolean Overlaps (const TColgp_Array1OfPnt& theArrayOfPts,
                                                      Standard_Integer theSensType,
-                                                     SelectBasics_PickResult& thePickResult) Standard_OVERRIDE;
+                                                     SelectBasics_PickResult& thePickResult) const Standard_OVERRIDE;
 
   //! Checks if line segment overlaps selecting frustum
   Standard_EXPORT virtual Standard_Boolean Overlaps (const gp_Pnt& thePnt1,
                                                      const gp_Pnt& thePnt2,
-                                                     SelectBasics_PickResult& thePickResult) Standard_OVERRIDE;
+                                                     SelectBasics_PickResult& thePickResult) const Standard_OVERRIDE;
 
   //! SAT intersection test between defined volume and given triangle. The test may
   //! be considered of interior part or boundary line defined by triangle vertices
@@ -147,12 +147,12 @@ public:
                                                       const gp_Pnt& thePnt2,
                                                       const gp_Pnt& thePnt3,
                                                       Standard_Integer theSensType,
-                                                      SelectBasics_PickResult& thePickResult) Standard_OVERRIDE;
+                                                      SelectBasics_PickResult& thePickResult) const Standard_OVERRIDE;
 
 
   //! Measures distance between 3d projection of user-picked
   //! screen point and given point theCOG
-  Standard_EXPORT virtual Standard_Real DistToGeometryCenter (const gp_Pnt& theCOG) Standard_OVERRIDE;
+  Standard_EXPORT virtual Standard_Real DistToGeometryCenter (const gp_Pnt& theCOG) const Standard_OVERRIDE;
 
   //! Calculates the point on a view ray that was detected during the run of selection algo by given depth.
   //! Throws exception if active selection type is not Point.
@@ -161,7 +161,7 @@ public:
   //! Checks if the point of sensitive in which selection was detected belongs
   //! to the region defined by clipping planes
   Standard_EXPORT virtual Standard_Boolean IsClipped (const Graphic3d_SequenceOfHClipPlane& thePlanes,
-                                                      const Standard_Real& theDepth);
+                                                      const Standard_Real& theDepth) const;
 
   //! Is used for rectangular selection only
   //! If theIsToAllow is false, only fully included sensitives will be detected, otherwise the algorithm will

src/SelectMgr/SelectMgr_TriangularFrustum.cxx

@@ -169,7 +169,7 @@ Handle(SelectMgr_BaseFrustum) SelectMgr_TriangularFrustum::ScaleAndTransform (co
 //=======================================================================
 Standard_Boolean SelectMgr_TriangularFrustum::Overlaps (const SelectMgr_Vec3& theMinPt,
                                                         const SelectMgr_Vec3& theMaxPt,
-                                                        SelectBasics_PickResult& /*thePickResult*/)
+                                                        SelectBasics_PickResult& /*thePickResult*/) const
 {
   return hasOverlap (theMinPt, theMaxPt);
 }
@@ -182,7 +182,7 @@ Standard_Boolean SelectMgr_TriangularFrustum::Overlaps (const SelectMgr_Vec3& th
 // =======================================================================
 Standard_Boolean SelectMgr_TriangularFrustum::Overlaps (const SelectMgr_Vec3& theMinPt,
                                                         const SelectMgr_Vec3& theMaxPt,
-                                                        Standard_Boolean* /*theInside*/)
+                                                        Standard_Boolean* /*theInside*/) const
 {
   return hasOverlap (theMinPt, theMaxPt, NULL);
 }
@@ -192,7 +192,7 @@ Standard_Boolean SelectMgr_TriangularFrustum::Overlaps (const SelectMgr_Vec3& th
 // purpose  : Intersection test between defined volume and given point
 // =======================================================================
 Standard_Boolean SelectMgr_TriangularFrustum::Overlaps (const gp_Pnt& thePnt,
-                                                        SelectBasics_PickResult& /*thePickResult*/)
+                                                        SelectBasics_PickResult& /*thePickResult*/) const
 {
   return hasOverlap (thePnt);
 }
@@ -206,7 +206,7 @@ Standard_Boolean SelectMgr_TriangularFrustum::Overlaps (const gp_Pnt& thePnt,
 // =======================================================================
 Standard_Boolean SelectMgr_TriangularFrustum::Overlaps (const TColgp_Array1OfPnt& theArrayOfPnts,
                                                         Select3D_TypeOfSensitivity theSensType,
-                                                        SelectBasics_PickResult& /*thePickResult*/)
+                                                        SelectBasics_PickResult& /*thePickResult*/) const
 {
   if (theSensType == Select3D_TOS_BOUNDARY)
   {
@@ -237,7 +237,7 @@ Standard_Boolean SelectMgr_TriangularFrustum::Overlaps (const TColgp_Array1OfPnt
 // =======================================================================
 Standard_Boolean SelectMgr_TriangularFrustum::Overlaps (const gp_Pnt& thePnt1,
                                                         const gp_Pnt& thePnt2,
-                                                        SelectBasics_PickResult& /*thePickResult*/)
+                                                        SelectBasics_PickResult& /*thePickResult*/) const
 {
   return hasOverlap (thePnt1, thePnt2);
 }
@@ -253,7 +253,7 @@ Standard_Boolean SelectMgr_TriangularFrustum::Overlaps (const gp_Pnt& thePnt1,
                                                         const gp_Pnt& thePnt2,
                                                         const gp_Pnt& thePnt3,
                                                         Select3D_TypeOfSensitivity theSensType,
-                                                        SelectBasics_PickResult& thePickResult)
+                                                        SelectBasics_PickResult& thePickResult) const
 {
   if (theSensType == Select3D_TOS_BOUNDARY)
   {

src/SelectMgr/SelectMgr_TriangularFrustum.hxx

@@ -48,29 +48,29 @@ public:
   //! SAT intersection test between defined volume and given axis-aligned box
   Standard_EXPORT virtual Standard_Boolean Overlaps (const SelectMgr_Vec3& theMinPnt,
                                                      const SelectMgr_Vec3& theMaxPnt,
-                                                     SelectBasics_PickResult& thePickResult) Standard_OVERRIDE;
+                                                     SelectBasics_PickResult& thePickResult) const Standard_OVERRIDE;
 
   //! Returns true if selecting volume is overlapped by axis-aligned bounding box
   //! with minimum corner at point theMinPt and maximum at point theMaxPt
   Standard_EXPORT virtual Standard_Boolean Overlaps (const SelectMgr_Vec3& theMinPt,
                                                      const SelectMgr_Vec3& theMaxPt,
-                                                     Standard_Boolean* theInside) Standard_OVERRIDE;
+                                                     Standard_Boolean* theInside) const Standard_OVERRIDE;
 
   //! Intersection test between defined volume and given point
   Standard_EXPORT virtual Standard_Boolean Overlaps (const gp_Pnt& thePnt,
-                                                     SelectBasics_PickResult& thePickResult) Standard_OVERRIDE;
+                                                     SelectBasics_PickResult& thePickResult) const Standard_OVERRIDE;
 
   //! SAT intersection test between defined volume and given ordered set of points,
   //! representing line segments. The test may be considered of interior part or
   //! boundary line defined by segments depending on given sensitivity type
   Standard_EXPORT virtual Standard_Boolean Overlaps (const TColgp_Array1OfPnt& theArrayOfPnts,
                                                      Select3D_TypeOfSensitivity theSensType,
-                                                     SelectBasics_PickResult& thePickResult) Standard_OVERRIDE;
+                                                     SelectBasics_PickResult& thePickResult) const Standard_OVERRIDE;
 
   //! Checks if line segment overlaps selecting frustum
   Standard_EXPORT virtual Standard_Boolean Overlaps (const gp_Pnt& thePnt1,
                                                      const gp_Pnt& thePnt2,
-                                                     SelectBasics_PickResult& thePickResult) Standard_OVERRIDE;
+                                                     SelectBasics_PickResult& thePickResult) const Standard_OVERRIDE;
 
   //! SAT intersection test between defined volume and given triangle. The test may
   //! be considered of interior part or boundary line defined by triangle vertices
@@ -79,7 +79,7 @@ public:
                                                      const gp_Pnt& thePnt2,
                                                      const gp_Pnt& thePnt3,
                                                      Select3D_TypeOfSensitivity theSensType,
-                                                     SelectBasics_PickResult& thePickResult) Standard_OVERRIDE;
+                                                     SelectBasics_PickResult& thePickResult) const Standard_OVERRIDE;
 
   //! Nullifies the handle to corresponding builder instance to prevent memory leaks
   Standard_EXPORT void Clear();

src/SelectMgr/SelectMgr_TriangularFrustumSet.cxx

@@ -127,7 +127,7 @@ Handle(SelectMgr_BaseFrustum) SelectMgr_TriangularFrustumSet::ScaleAndTransform
 // =======================================================================
 Standard_Boolean SelectMgr_TriangularFrustumSet::Overlaps (const SelectMgr_Vec3& theMinPnt,
                                                            const SelectMgr_Vec3& theMaxPnt,
-                                                           SelectBasics_PickResult& thePickResult)
+                                                           SelectBasics_PickResult& thePickResult) const
 {
   for (SelectMgr_TriangFrustumsIter anIter (myFrustums); anIter.More(); anIter.Next())
   {
@@ -144,7 +144,7 @@ Standard_Boolean SelectMgr_TriangularFrustumSet::Overlaps (const SelectMgr_Vec3&
 // =======================================================================
 Standard_Boolean SelectMgr_TriangularFrustumSet::Overlaps (const SelectMgr_Vec3& theMinPnt,
                                                            const SelectMgr_Vec3& theMaxPnt,
-                                                           Standard_Boolean* /*theInside*/)
+                                                           Standard_Boolean* /*theInside*/) const
 {
   for (SelectMgr_TriangFrustumsIter anIter (myFrustums); anIter.More(); anIter.Next())
   {
@@ -160,7 +160,7 @@ Standard_Boolean SelectMgr_TriangularFrustumSet::Overlaps (const SelectMgr_Vec3&
 // purpose  :
 // =======================================================================
 Standard_Boolean SelectMgr_TriangularFrustumSet::Overlaps (const gp_Pnt& thePnt,
-                                                           SelectBasics_PickResult& thePickResult)
+                                                           SelectBasics_PickResult& thePickResult) const
 {
   for (SelectMgr_TriangFrustumsIter anIter (myFrustums); anIter.More(); anIter.Next())
   {
@@ -177,7 +177,7 @@ Standard_Boolean SelectMgr_TriangularFrustumSet::Overlaps (const gp_Pnt& thePnt,
 // =======================================================================
 Standard_Boolean SelectMgr_TriangularFrustumSet::Overlaps (const TColgp_Array1OfPnt& theArrayOfPts,
                                                            Select3D_TypeOfSensitivity theSensType,
-                                                           SelectBasics_PickResult& thePickResult)
+                                                           SelectBasics_PickResult& thePickResult) const
 {
   for (SelectMgr_TriangFrustumsIter anIter (myFrustums); anIter.More(); anIter.Next())
   {
@@ -194,7 +194,7 @@ Standard_Boolean SelectMgr_TriangularFrustumSet::Overlaps (const TColgp_Array1Of
 // =======================================================================
 Standard_Boolean SelectMgr_TriangularFrustumSet::Overlaps (const gp_Pnt& thePnt1,
                                                            const gp_Pnt& thePnt2,
-                                                           SelectBasics_PickResult& thePickResult)
+                                                           SelectBasics_PickResult& thePickResult) const
 {
   for (SelectMgr_TriangFrustumsIter anIter (myFrustums); anIter.More(); anIter.Next())
   {
@@ -213,7 +213,7 @@ Standard_Boolean SelectMgr_TriangularFrustumSet::Overlaps (const gp_Pnt& thePnt1
                                                            const gp_Pnt& thePnt2,
                                                            const gp_Pnt& thePnt3,
                                                            Select3D_TypeOfSensitivity theSensType,
-                                                           SelectBasics_PickResult& thePickResult)
+                                                           SelectBasics_PickResult& thePickResult) const
 {
   for (SelectMgr_TriangFrustumsIter anIter (myFrustums); anIter.More(); anIter.Next())
   {

src/SelectMgr/SelectMgr_TriangularFrustumSet.hxx

@@ -52,28 +52,28 @@ public:
 
   Standard_EXPORT virtual Standard_Boolean Overlaps (const SelectMgr_Vec3& theMinPnt,
                                                      const SelectMgr_Vec3& theMaxPnt,
-                                                     SelectBasics_PickResult& thePickResult) Standard_OVERRIDE;
+                                                     SelectBasics_PickResult& thePickResult) const Standard_OVERRIDE;
 
   Standard_EXPORT virtual Standard_Boolean Overlaps (const SelectMgr_Vec3& theMinPnt,
                                                      const SelectMgr_Vec3& theMaxPnt,
-                                                     Standard_Boolean* theInside) Standard_OVERRIDE;
+                                                     Standard_Boolean* theInside) const Standard_OVERRIDE;
 
   Standard_EXPORT virtual Standard_Boolean Overlaps (const gp_Pnt& thePnt,
-                                                     SelectBasics_PickResult& thePickResult) Standard_OVERRIDE;
+                                                     SelectBasics_PickResult& thePickResult) const Standard_OVERRIDE;
 
   Standard_EXPORT virtual Standard_Boolean Overlaps (const TColgp_Array1OfPnt& theArrayOfPnts,
                                                      Select3D_TypeOfSensitivity theSensType,
-                                                     SelectBasics_PickResult& thePickResult) Standard_OVERRIDE;
+                                                     SelectBasics_PickResult& thePickResult) const Standard_OVERRIDE;
 
   Standard_EXPORT virtual Standard_Boolean Overlaps (const gp_Pnt& thePnt1,
                                                      const gp_Pnt& thePnt2,
-                                                     SelectBasics_PickResult& thePickResult) Standard_OVERRIDE;
+                                                     SelectBasics_PickResult& thePickResult) const Standard_OVERRIDE;
 
   Standard_EXPORT virtual Standard_Boolean Overlaps (const gp_Pnt& thePnt1,
                                                      const gp_Pnt& thePnt2,
                                                      const gp_Pnt& thePnt3,
                                                      Select3D_TypeOfSensitivity theSensType,
-                                                     SelectBasics_PickResult& thePickResult) Standard_OVERRIDE;
+                                                     SelectBasics_PickResult& thePickResult) const Standard_OVERRIDE;
 
   //! Stores plane equation coefficients (in the following form:
   //! Ax + By + Cz + D = 0) to the given vector

src/SelectMgr/SelectMgr_ViewClipRange.hxx

@@ -35,9 +35,13 @@ public:
   //! e.g. TRUE means depth is clipped.
   Standard_Boolean IsClipped (const Standard_Real theDepth) const
   {
-    for (size_t aRangeIter = 0; aRangeIter < myRanges.size(); ++aRangeIter)
+    if (myUnclipRange.IsOut (theDepth))
     {
-      if (!myRanges[aRangeIter].IsOut (theDepth))
+      return Standard_True;
+    }
+    for (size_t aRangeIter = 0; aRangeIter < myClipRanges.size(); ++aRangeIter)
+    {
+      if (!myClipRanges[aRangeIter].IsOut (theDepth))
       {
         return Standard_True;
       }
@@ -48,19 +52,20 @@ public:
   //! Clears clipping range.
   void SetVoid()
   {
-    myRanges.resize (1);
-    myRanges[0].SetVoid();
+    myClipRanges.resize (0);
+    myUnclipRange = Bnd_Range (RealFirst(), RealLast());
   }
 
-  //! Returns the main range.
-  Bnd_Range& ChangeMain() { return myRanges[0]; }
+  //! Returns the main unclipped range; [-inf, inf] by default.
+  Bnd_Range& ChangeUnclipRange() { return myUnclipRange; }
 
-  //! Adds a sub-range.
-  void AddSubRange (const Bnd_Range& theRange) { myRanges.push_back (theRange); }
+  //! Adds a clipping sub-range (for clipping chains).
+  void AddClipSubRange (const Bnd_Range& theRange) { myClipRanges.push_back (theRange); }
 
 private:
 
-  std::vector<Bnd_Range> myRanges;
+  std::vector<Bnd_Range> myClipRanges;
+  Bnd_Range myUnclipRange;
 
 };
 

src/ShapeFix/ShapeFix_ComposeShell.cxx

@@ -1918,7 +1918,7 @@ static Standard_Integer IsShortSegment (const ShapeFix_WireSegment &seg,
                                         const Standard_Real VResolution)
 {
   TopoDS_Vertex Vf = seg.FirstVertex();
-  if ( ! Vf.IsSame ( seg.LastVertex() ) ) return Standard_False;
+  if ( ! Vf.IsSame ( seg.LastVertex() ) ) return 0;
 
   gp_Pnt pnt = BRep_Tool::Pnt(Vf);
   Standard_Real tol = BRep_Tool::Tolerance(Vf);
@@ -1929,7 +1929,7 @@ static Standard_Integer IsShortSegment (const ShapeFix_WireSegment &seg,
   Handle(ShapeExtend_WireData) sbwd = seg.WireData();
   for ( Standard_Integer i=1; i <= sbwd->NbEdges(); i++ ) {
     TopoDS_Edge edge = sbwd->Edge ( i );
-    if ( ! Vf.IsSame ( sae.LastVertex ( edge ) ) ) return Standard_False;
+    if ( ! Vf.IsSame ( sae.LastVertex ( edge ) ) ) return 0;
     Handle(Geom2d_Curve) c2d;
     Standard_Real f, l;
     if ( ! sae.PCurve ( edge, myFace, c2d, f, l ) ) continue;

src/StepToTopoDS/StepToTopoDS_GeometricTool.cxx

@@ -222,24 +222,29 @@ Standard_Boolean  StepToTopoDS_GeometricTool::IsLikeSeam
 //           This situation occurs when an edge crosses the parametric origin.
 // ----------------------------------------------------------------------------
 
-Standard_Boolean  StepToTopoDS_GeometricTool::UpdateParam3d
-(const Handle(Geom_Curve)& theCurve, Standard_Real& w1, Standard_Real& w2,
- const Standard_Real preci)
+Standard_Boolean  StepToTopoDS_GeometricTool::UpdateParam3d(
+  const Handle(Geom_Curve)& theCurve,
+  Standard_Real& w1,
+  Standard_Real& w2,
+  const Standard_Real preci)
 {
   // w1 et/ou w2 peuvent etre en dehors des bornes naturelles de la courbe.
   // On donnera alors la valeur en bout a w1 et/ou w2
-  
+
   Standard_Real cf = theCurve->FirstParameter();
   Standard_Real cl = theCurve->LastParameter();
 
-  if (theCurve->IsKind(STANDARD_TYPE(Geom_BoundedCurve)) && !theCurve->IsClosed()) {
-    if (w1 < cf) {
+  if (theCurve->IsKind(STANDARD_TYPE(Geom_BoundedCurve)) && !theCurve->IsClosed())
+  {
+    if (w1 < cf)
+    {
 #ifdef OCCT_DEBUG
       cout << "Update Edge First Parameter to Curve First Parameter" << endl;
 #endif
       w1 = cf;
     }
-    else if (w1 > cl) {
+    else if (w1 > cl)
+    {
 #ifdef OCCT_DEBUG
       cout << "Update Edge First Parameter to Curve Last Parameter" << endl;
 #endif
@@ -261,26 +266,47 @@ Standard_Boolean  StepToTopoDS_GeometricTool::UpdateParam3d
 
   if (w1 < w2) return Standard_True;
 
-  if (theCurve->IsPeriodic()) 
-    ElCLib::AdjustPeriodic(cf,cl,Precision::PConfusion(),w1,w2); //:a7 abv 11 Feb 98: preci -> PConfusion()
-  else if (theCurve->IsClosed()) {
+  if (theCurve->IsPeriodic())
+  {
+    ElCLib::AdjustPeriodic(cf, cl, Precision::PConfusion(), w1, w2); //:a7 abv 11 Feb 98: preci -> PConfusion()
+  }
+  else if (theCurve->IsClosed())
+  {
     // l'un des points projecte se trouve sur l'origine du parametrage
     // de la courbe 3D. L algo a donne cl +- preci au lieu de cf ou vice-versa
     // DANGER precision 3d applique a une espace 1d
 
     // w2 = cf au lieu de w2 = cl
-    if (Abs(w2 - cf) < Precision::PConfusion() /*preci*/)  w2 = cl;
+    if (Abs(w2 - cf) < Precision::PConfusion() /*preci*/)
+    {
+      w2 = cl;
+    }
     // w1 = cl au lieu de w1 = cf
-    else if (Abs(w1 - cl) < Precision::PConfusion() /*preci*/)  w1 = cf;
-
+    else if (Abs(w1 - cl) < Precision::PConfusion() /*preci*/)
+    {
+      w1 = cf;
+    }
     // on se trouve dans un cas ou l origine est traversee
     // illegal sur une courbe fermee non periodique
     // on inverse quand meme les parametres !!!!!!
-    else {
+    else
+    {
       //:S4136 abv 20 Apr 99: r0701_ug.stp #6230: add check in 3d
-      if (theCurve->Value(w1).Distance(theCurve->Value(cf)) < preci) w1 = cf;
-      if (theCurve->Value(w2).Distance(theCurve->Value(cl)) < preci) w2 = cl;
-      if (w1 > w2) {
+      if (theCurve->Value(w1).Distance(theCurve->Value(cf)) < preci)
+      {
+        w1 = cf;
+      }
+      if (theCurve->Value(w2).Distance(theCurve->Value(cl)) < preci)
+      {
+        w2 = cl;
+      }
+      if (fabs(w2 - w1) < Precision::PConfusion())
+      {
+        w1 = cf;
+        w2 = cl;
+      }
+      else if (w1 > w2)
+      {
 #ifdef OCCT_DEBUG
         cout << "Warning : parameter range of edge crossing non periodic curve origin" << endl;
 #endif
@@ -291,48 +317,60 @@ Standard_Boolean  StepToTopoDS_GeometricTool::UpdateParam3d
     }
   }
   // The curve is closed within the 3D tolerance
-  else if (theCurve->IsKind(STANDARD_TYPE(Geom_BSplineCurve))) {
-    Handle(Geom_BSplineCurve) aBSpline = 
+  else if (theCurve->IsKind(STANDARD_TYPE(Geom_BSplineCurve)))
+  {
+    Handle(Geom_BSplineCurve) aBSpline =
       Handle(Geom_BSplineCurve)::DownCast(theCurve);
-    if (aBSpline->StartPoint().Distance(aBSpline->EndPoint()) <= preci ) {
-//:S4136	<= BRepAPI::Precision()) {
-      // l'un des points projecte se trouve sur l'origine du parametrage
-      // de la courbe 3D. L algo a donne cl +- preci au lieu de cf ou vice-versa
-      // DANGER precision 3d applique a une espace 1d
-      
-      // w2 = cf au lieu de w2 = cl
-      if      (Abs(w2 - cf) < Precision::PConfusion()) w2 = cl ;
-      // w1 = cl au lieu de w1 = cf
-      else if (Abs(w1 - cl) < Precision::PConfusion()) w1 =  cf;
+    if (aBSpline->StartPoint().Distance(aBSpline->EndPoint()) <= preci)
+    {
+      //:S4136	<= BRepAPI::Precision()) {
+            // l'un des points projecte se trouve sur l'origine du parametrage
+            // de la courbe 3D. L algo a donne cl +- preci au lieu de cf ou vice-versa
+            // DANGER precision 3d applique a une espace 1d
 
+            // w2 = cf au lieu de w2 = cl
+      if (Abs(w2 - cf) < Precision::PConfusion())
+      {
+        w2 = cl;
+      }
+      // w1 = cl au lieu de w1 = cf
+      else if (Abs(w1 - cl) < Precision::PConfusion())
+      {
+        w1 = cf;
+      }
       // on se trouve dans un cas ou l origine est traversee
       // illegal sur une courbe fermee non periodique
       // on inverse quand meme les parametres !!!!!!
-      else {
+      else
+      {
 #ifdef OCCT_DEBUG
-	cout << "Warning : parameter range of edge crossing non periodic curve origin" << endl;
+        cout << "Warning : parameter range of edge crossing non periodic curve origin" << endl;
 #endif
-	Standard_Real tmp = w1;
-	w1 = w2;
-	w2 = tmp;
+        Standard_Real tmp = w1;
+        w1 = w2;
+        w2 = tmp;
       }
     }
     //abv 15.03.00 #72 bm1_pe_t4 protection of exceptions in draw
-    else if ( w1 > w2 ) {
+    else if (w1 > w2)
+    {
 #ifdef OCCT_DEBUG
       cout << "Warning: parameter range is bad; curve reversed" << endl;
 #endif
-      w1 = theCurve->ReversedParameter ( w1 );
-      w2 = theCurve->ReversedParameter ( w2 );
+      w1 = theCurve->ReversedParameter(w1);
+      w2 = theCurve->ReversedParameter(w2);
       theCurve->Reverse();
     }
-//:j9 abv 11 Dec 98: PRO7747 #4875, after :j8:    else 
-    if (w1 == w2) {  //gka 10.07.1998 file PRO7656 entity 33334
-      w1 = cf; w2 = cl;
+    //:j9 abv 11 Dec 98: PRO7747 #4875, after :j8:    else 
+    if (w1 == w2)
+    {  //gka 10.07.1998 file PRO7656 entity 33334
+      w1 = cf;
+      w2 = cl;
       return Standard_False;
     }
   }
-  else {
+  else
+  {
 #ifdef OCCT_DEBUG
     cout << "UpdateParam3d Failed" << endl;
     cout << "  - Curve Type : " << theCurve->DynamicType() << endl;
@@ -340,16 +378,18 @@ Standard_Boolean  StepToTopoDS_GeometricTool::UpdateParam3d
     cout << "  - Param 2    : " << w2 << endl;
 #endif
     //abv 15.03.00 #72 bm1_pe_t4 protection of exceptions in draw
-    if ( w1 > w2 ) {
+    if (w1 > w2)
+    {
 #ifdef OCCT_DEBUG
       cout << "Warning: parameter range is bad; curve reversed" << endl;
 #endif
-      w1 = theCurve->ReversedParameter ( w1 );
-      w2 = theCurve->ReversedParameter ( w2 );
+      w1 = theCurve->ReversedParameter(w1);
+      w2 = theCurve->ReversedParameter(w2);
       theCurve->Reverse();
     }
     //pdn 11.01.99 #144 bm1_pe_t4 protection of exceptions in draw
-    if (w1 == w2) {
+    if (w1 == w2)
+    {
       w1 -= Precision::PConfusion();
       w2 += Precision::PConfusion();
     }

src/V3d/V3d_View.hxx

@@ -805,17 +805,21 @@ public:
   //! grid in <me>
   Standard_EXPORT void SetGridActivity (const Standard_Boolean aFlag);
 
-  //! dump the full contents of the view at the same
-  //! scale in the file <theFile>. The file name
-  //! extension must be one of ".png",".bmp",".jpg",".gif".
-  //! Returns FALSE when the dump has failed
+  //! Dumps the full contents of the View into the image file. This is an alias for ToPixMap() with Image_AlienPixMap.
+  //! @param theFile destination image file (image format is determined by file extension like .png, .bmp, .jpg)
+  //! @param theBufferType buffer to dump
+  //! @return FALSE when the dump has failed
   Standard_EXPORT Standard_Boolean Dump (const Standard_CString theFile, const Graphic3d_BufferType& theBufferType = Graphic3d_BT_RGB);
 
   //! Dumps the full contents of the view to a pixmap with specified parameters.
+  //! Internally this method calls Redraw() with an offscreen render buffer of requested target size (theWidth x theHeight),
+  //! so that there is no need resizing a window control for making a dump of different size.
   Standard_EXPORT Standard_Boolean ToPixMap (Image_PixMap&               theImage,
                                              const V3d_ImageDumpOptions& theParams);
 
   //! Dumps the full contents of the view to a pixmap.
+  //! Internally this method calls Redraw() with an offscreen render buffer of requested target size (theWidth x theHeight),
+  //! so that there is no need resizing a window control for making a dump of different size.
   //! @param theImage          target image, will be re-allocated to match theWidth x theHeight
   //! @param theWidth          target image width
   //! @param theHeight         target image height

src/ViewerTest/ViewerTest_ObjectCommands.cxx

@@ -3445,20 +3445,12 @@ static int VDrawPArray (Draw_Interpretor& di, Standard_Integer argc, const char*
   Handle(AIS_InteractiveContext) aContextAIS = ViewerTest::GetAISContext();
   if (aContextAIS.IsNull())
   {
-    di << "Call vinit before!\n";
+    std::cout << "Error: no active Viewer\n";
     return 1;
   }
   else if (argc < 3)
   {
-    di << "Use: " << argv[0] << " Name TypeOfArray"
-       << " [vertex] ... [bounds] ... [edges]\n"
-       << "  TypeOfArray={ points | segments | polylines | triangles |\n"
-       << "                trianglefans | trianglestrips | quads |\n"
-       << "                quadstrips | polygons }\n"
-       << "  vertex={ 'v' x y z [normal={ 'n' nx ny nz }] [color={ 'c' r g b }]"
-       << " [texel={ 't' tx ty }] } \n"
-       << "  bounds={ 'b' verticies_count [color={ 'c' r g b }] }\n"
-       << "  edges={ 'e' vertex_id }\n";
+    std::cout << "Syntax error: wrong number of arguments\n";
     return 1;
   }
 
@@ -3466,6 +3458,26 @@ static int VDrawPArray (Draw_Interpretor& di, Standard_Integer argc, const char*
   Standard_Integer aArgIndex = 1;
   TCollection_AsciiString aName (argv[aArgIndex++]);
   TCollection_AsciiString anArrayType (argv[aArgIndex++]);
+  if (anArrayType == "-shape")
+  {
+    Standard_CString aShapeName = argv[aArgIndex++];
+    TopoDS_Shape aShape = DBRep::Get (aShapeName);
+    Handle(Graphic3d_ArrayOfPrimitives) aTris = StdPrs_ShadedShape::FillTriangles (aShape);
+    if (aShape.IsNull())
+    {
+      std::cout << "Syntax error: shape '" << aShapeName << "' is not found\n";
+      return 1;
+    }
+    else if (aTris.IsNull())
+    {
+      std::cout << "Syntax error: shape '" << aShapeName << "' is not triangulated\n";
+      return 1;
+    }
+
+    Handle(MyPArrayObject) aPObject = new MyPArrayObject (aTris);
+    ViewerTest::Display (aName, aPObject);
+    return 0;
+  }
 
   Standard_Boolean hasVertex = Standard_False;
 
@@ -6306,7 +6318,14 @@ void ViewerTest::ObjectCommands(Draw_Interpretor& theCommands)
     __FILE__, VComputeHLR, group);
 
   theCommands.Add("vdrawparray",
-    "vdrawparray : vdrawparray Name TypeOfArray [vertex = { 'v' x y z [vertex_normal = { 'n' x y z }] [vertex_color = { 'c' r g b }] ] ... [bound = { 'b' vertex_count [bound_color = { 'c' r g b }] ] ... [edge = { 'e' vertex_id ]",
+                "vdrawparray name TypeOfArray={points|segments|polylines|triangles"
+      "\n\t\t:                                |trianglefans|trianglestrips|quads|quadstrips|polygons}"
+      "\n\t\t:              [vertex={'v' x y z [normal={'n' nx ny nz}] [color={'c' r g b}] [texel={'t' tx ty}]]"
+      "\n\t\t:              [bound= {'b' nbVertices [bound_color={'c' r g b}]]"
+      "\n\t\t:              [edge=  {'e' vertexId]"
+      "\n\t\t:              [-shape shapeName]"
+      "\n\t\t: Commands create an Interactive Object for specified Primitive Array definition (Graphic3d_ArrayOfPrimitives)"
+      "\n\t\t: with the main purpose is covering various combinations by tests",
     __FILE__,VDrawPArray,group);
 
   theCommands.Add("vconnect", 

src/XCAFDoc/XCAFDoc_GraphNode.cxx

@@ -93,6 +93,7 @@ XCAFDoc_GraphNode::XCAFDoc_GraphNode ()
 { 
 }  
 
+
 //=======================================================================
 //function : SetGraphID
 //purpose  : 
@@ -104,6 +105,8 @@ void XCAFDoc_GraphNode::SetGraphID (const Standard_GUID& explicitID)
   myGraphID = explicitID;
 }
 
+
+
 //=======================================================================
 //function : SetFather
 //purpose  : 
@@ -139,10 +142,8 @@ void XCAFDoc_GraphNode::UnSetFather(const Handle(XCAFDoc_GraphNode)& F)
 {
   Standard_Integer Findex = FatherIndex(F);
   if (Findex != 0)
-  {
-    F->UnSetChildlink(this);
-    UnSetFatherlink(F);
-  }
+  F->UnSetChildlink(this);
+  UnSetFatherlink(F);
 }
 
 
@@ -154,11 +155,10 @@ void XCAFDoc_GraphNode::UnSetFather(const Handle(XCAFDoc_GraphNode)& F)
 void XCAFDoc_GraphNode::UnSetFather(const Standard_Integer Findex) 
 {
   if (Findex != 0)
-  {
-    UnSetFather( GetFather(Findex) );
-  }
+  UnSetFather( GetFather(Findex) );
 }
 
+
 //=======================================================================
 //function : UnSetFatherlink
 //purpose  : Remove link finily
@@ -167,11 +167,7 @@ void XCAFDoc_GraphNode::UnSetFather(const Standard_Integer Findex)
 void XCAFDoc_GraphNode::UnSetFatherlink(const Handle(XCAFDoc_GraphNode)& F) 
 {
   Backup();
-  Standard_Integer Findex = FatherIndex(F);
-  if (Findex != 0)
-  {
-    myFathers.Remove(Findex);
-  }
+  myFathers.Remove( FatherIndex(F) );
 }
 
 //=======================================================================
@@ -182,13 +178,12 @@ void XCAFDoc_GraphNode::UnSetFatherlink(const Handle(XCAFDoc_GraphNode)& F)
 void XCAFDoc_GraphNode::UnSetChild(const Handle(XCAFDoc_GraphNode)& Ch) 
 {
   Standard_Integer Chindex = ChildIndex(Ch);
-  if (Chindex != 0)
-  {
-    Ch->UnSetFatherlink(this);
-    UnSetChildlink(Ch);
-  }
+  if (Chindex != 0) 
+  Ch->UnSetFatherlink(this);
+  UnSetChildlink(Ch);
 }
 
+
 //=======================================================================
 //function : UnSetChild
 //purpose  : 
@@ -196,12 +191,11 @@ void XCAFDoc_GraphNode::UnSetChild(const Handle(XCAFDoc_GraphNode)& Ch)
 
  void XCAFDoc_GraphNode::UnSetChild(const Standard_Integer Chindex) 
 {
-  if (Chindex != 0)
-  {
-    UnSetChild( GetChild(Chindex) );
-  }
+  if (Chindex != 0 )
+  UnSetChild( GetChild(Chindex) );
 }
 
+
 //=======================================================================
 //function : UnSetChildlink
 //purpose  : Remove link finily
@@ -210,11 +204,7 @@ void XCAFDoc_GraphNode::UnSetChild(const Handle(XCAFDoc_GraphNode)& Ch)
 void XCAFDoc_GraphNode::UnSetChildlink(const Handle(XCAFDoc_GraphNode)& Ch) 
 {
   Backup();
-  Standard_Integer Chindex = ChildIndex(Ch);
-  if (Chindex != 0)
-  {
-    myChildren.Remove(Chindex);
-  }
+  myChildren.Remove( ChildIndex(Ch) );
 }
 
 //=======================================================================
@@ -358,9 +348,7 @@ void XCAFDoc_GraphNode::Paste(const Handle(TDF_Attribute)& into,
     if (!RT->HasRelocation(myFathers(i), func) && RT->AfterRelocate()) {
       func.Nullify();
     }
-    if (!func.IsNull()) {
-      intof->SetFather(func);
-    }
+    intof->SetFather(func);
   }
 
   i = 1;
@@ -368,9 +356,7 @@ void XCAFDoc_GraphNode::Paste(const Handle(TDF_Attribute)& into,
     if (!RT->HasRelocation(myChildren(i), func) && RT->AfterRelocate()) {
       func.Nullify();
     }
-    if (!func.IsNull()) {
-      intof->SetChild(func);
-    }
+    intof->SetFather(func);
   }
   intof->SetGraphID(myGraphID);
 }

tests/bugs/iges/bug28694_1

@@ -1,5 +1,3 @@
-puts "TODO OCC28694 ALL: ERROR: OCC28694 is reproduced."
-
 puts "========"
 puts "OCC28694"
 puts "========"

tests/bugs/step/bug55

@@ -1,3 +1,5 @@
+puts "TODO bug30075 ALL: Faulty shapes in variables faulty_1 to faulty_"
+
 puts "========================"
 puts " OCC55 "
 puts "========================"

tests/gdt/import/A1

@@ -79,9 +79,9 @@ set ref_data {
  0:1:1:1:22 Shape.23
  	 0:1:4:21 Dimension.23.1 ( N "diameter" T 15, V 20, VL 0.050000000000000003, VU 0.10000000000000001, P 0 )
  0:1:1:1:23 Shape.24
- 	 0:1:4:22 Dimension.24.1 ( N "angle" T 11, V 59.999999999851163, VL 0.5, VU 0.5, Q 3, P 0 )
+ 	 0:1:4:22 Dimension.24.1 ( N "angle" T 11, V 60, VL 0.5, VU 0.5, Q 3, P 0 )
  0:1:1:1:24 Shape.25
- 	 0:1:4:22 Dimension.25.1 ( N "angle" T 11, V 59.999999999851163, VL 0.5, VU 0.5, Q 3, P 0 )
+ 	 0:1:4:22 Dimension.25.1 ( N "angle" T 11, V 60, VL 0.5, VU 0.5, Q 3, P 0 )
  0:1:1:1:25 Shape.26
  	 0:1:4:23 Dimension.26.1 ( N "diameter" T 15, LB 34.799999999999997, UB 35.200000000000003, P 0 )
  0:1:1:1:26 Shape.27

tests/gdt/import/A3

@@ -12,45 +12,45 @@ set ref_data {
  0:1:1:2:2 Shape.5
  	 0:1:4:1 GeomTolerance.5.1 ( N "Feature Control Frame (4)" T 12 TV 0, V 0.254 )
  0:1:1:2:7 Shape.10
- 	 0:1:4:6 Dimension.10.1 ( N "linear distance" T 2, V 20.827999999999996, VL 64.515999999999991, VU 64.515999999999991, P 0 )
+ 	 0:1:4:6 Dimension.10.1 ( N "linear distance" T 2, V 20.827999999999996, VL 2.54, VU 2.54, P 0 )
  0:1:1:2:19 Shape.22
- 	 0:1:4:39 Dimension.22.1 ( N "diameter" T 15, V 11.1252, VL 64.515999999999991, VU 64.515999999999991, P 0 )
+ 	 0:1:4:39 Dimension.22.1 ( N "diameter" T 15, V 11.1252, VL 2.54, VU 2.54, P 0 )
  	 0:1:4:35 GeomTolerance.22.1 ( N "Feature Control Frame (40)" T 10 TV 1, V 1.27, MR 1 )
  	 	 0:1:4:36 Datum.22.1.1 ( N "Feature Control Frame (40)" )
  	 	 0:1:4:37 Datum.22.1.2 ( N "Feature Control Frame (40)", M 15 )
  	 	 0:1:4:38 Datum.22.1.3 ( N "Feature Control Frame (40)", M 15 )
  0:1:1:2:20 Shape.23
- 	 0:1:4:39 Dimension.23.1 ( N "diameter" T 15, V 11.1252, VL 64.515999999999991, VU 64.515999999999991, P 0 )
+ 	 0:1:4:39 Dimension.23.1 ( N "diameter" T 15, V 11.1252, VL 2.54, VU 2.54, P 0 )
  	 0:1:4:35 GeomTolerance.23.1 ( N "Feature Control Frame (40)" T 10 TV 1, V 1.27, MR 1 )
  	 	 0:1:4:36 Datum.23.1.1 ( N "Feature Control Frame (40)" )
  	 	 0:1:4:37 Datum.23.1.2 ( N "Feature Control Frame (40)", M 15 )
  	 	 0:1:4:38 Datum.23.1.3 ( N "Feature Control Frame (40)", M 15 )
  0:1:1:2:21 Shape.24
- 	 0:1:4:39 Dimension.24.1 ( N "diameter" T 15, V 11.1252, VL 64.515999999999991, VU 64.515999999999991, P 0 )
+ 	 0:1:4:39 Dimension.24.1 ( N "diameter" T 15, V 11.1252, VL 2.54, VU 2.54, P 0 )
  	 0:1:4:35 GeomTolerance.24.1 ( N "Feature Control Frame (40)" T 10 TV 1, V 1.27, MR 1 )
  	 	 0:1:4:36 Datum.24.1.1 ( N "Feature Control Frame (40)" )
  	 	 0:1:4:37 Datum.24.1.2 ( N "Feature Control Frame (40)", M 15 )
  	 	 0:1:4:38 Datum.24.1.3 ( N "Feature Control Frame (40)", M 15 )
  0:1:1:2:22 Shape.25
- 	 0:1:4:39 Dimension.25.1 ( N "diameter" T 15, V 11.1252, VL 64.515999999999991, VU 64.515999999999991, P 0 )
+ 	 0:1:4:39 Dimension.25.1 ( N "diameter" T 15, V 11.1252, VL 2.54, VU 2.54, P 0 )
  	 0:1:4:35 GeomTolerance.25.1 ( N "Feature Control Frame (40)" T 10 TV 1, V 1.27, MR 1 )
  	 	 0:1:4:36 Datum.25.1.1 ( N "Feature Control Frame (40)" )
  	 	 0:1:4:37 Datum.25.1.2 ( N "Feature Control Frame (40)", M 15 )
  	 	 0:1:4:38 Datum.25.1.3 ( N "Feature Control Frame (40)", M 15 )
  0:1:1:2:28 Shape.31
- 	 0:1:4:6 Dimension.31.1 ( N "linear distance" T 2, V 20.827999999999996, VL 64.515999999999991, VU 64.515999999999991, P 0 )
+ 	 0:1:4:6 Dimension.31.1 ( N "linear distance" T 2, V 20.827999999999996, VL 2.54, VU 2.54, P 0 )
  	 0:1:4:2 GeomTolerance.31.1 ( N "Feature Control Frame (24)" T 12 TV 0, V 0.76200000000000001 )
  	 	 0:1:4:3 Datum.31.1.1 ( N "Feature Control Frame (24)" )
  	 	 0:1:4:4 Datum.31.1.2 ( N "Feature Control Frame (24)" )
  	 	 0:1:4:5 Datum.31.1.3 ( N "Feature Control Frame (24)" )
  0:1:1:2:39 Shape.42
- 	 0:1:4:14 Dimension.42.1 ( N "diameter" T 15, V 50.799999999999997, VL 64.515999999999991, VU 64.515999999999991, P 0 )
+ 	 0:1:4:14 Dimension.42.1 ( N "diameter" T 15, V 50.799999999999997, VL 2.54, VU 2.54, P 0 )
  	 0:1:4:15 GeomTolerance.42.1 ( N "Feature Control Frame (16)" T 10 TV 1, V 1.524 )
  	 	 0:1:4:16 Datum.42.1.1 ( N "Feature Control Frame (16)" )
  	 	 0:1:4:17 Datum.42.1.2 ( N "Feature Control Frame (16)" )
  	 	 0:1:4:18 Datum.42.1.3 ( N "Feature Control Frame (16)" )
  0:1:1:2:40 Shape.43
- 	 0:1:4:14 Dimension.43.1 ( N "diameter" T 15, V 50.799999999999997, VL 64.515999999999991, VU 64.515999999999991, P 0 )
+ 	 0:1:4:14 Dimension.43.1 ( N "diameter" T 15, V 50.799999999999997, VL 2.54, VU 2.54, P 0 )
  	 0:1:4:15 GeomTolerance.43.1 ( N "Feature Control Frame (16)" T 10 TV 1, V 1.524 )
  	 	 0:1:4:16 Datum.43.1.1 ( N "Feature Control Frame (16)" )
  	 	 0:1:4:17 Datum.43.1.2 ( N "Feature Control Frame (16)" )
@@ -58,7 +58,7 @@ set ref_data {
  0:1:1:2:48 Shape.51
  	 0:1:4:30 Dimension.51.1 ( N "linear distance" T 2, V 19.049999999999997, P 0 )
  0:1:1:2:49 Shape.52
- 	 0:1:4:19 Dimension.52.1 ( N "diameter" T 15, V 38.099999999999994, VL 64.515999999999991, VU 64.515999999999991, P 0 )
+ 	 0:1:4:19 Dimension.52.1 ( N "diameter" T 15, V 38.099999999999994, VL 2.54, VU 2.54, P 0 )
  	 0:1:4:20 GeomTolerance.52.1 ( N "Feature Control Frame (18)" T 10 TV 1, V 2.032 )
  	 	 0:1:4:21 Datum.52.1.1 ( N "Feature Control Frame (18)" )
  	 	 0:1:4:22 Datum.52.1.2 ( N "Feature Control Frame (18)" )
@@ -68,7 +68,7 @@ set ref_data {
  	 	 0:1:4:27 Datum.52.2.2 ( N "Feature Control Frame (20)" )
  	 	 0:1:4:28 Datum.52.2.3 ( N "Feature Control Frame (20)" )
  0:1:1:2:50 Shape.53
- 	 0:1:4:19 Dimension.53.1 ( N "diameter" T 15, V 38.099999999999994, VL 64.515999999999991, VU 64.515999999999991, P 0 )
+ 	 0:1:4:19 Dimension.53.1 ( N "diameter" T 15, V 38.099999999999994, VL 2.54, VU 2.54, P 0 )
  	 0:1:4:24 Dimension.53.2 ( N "linear distance" T 2, V 38.099999999999994, P 0 )
  	 0:1:4:20 GeomTolerance.53.1 ( N "Feature Control Frame (18)" T 10 TV 1, V 2.032 )
  	 	 0:1:4:21 Datum.53.1.1 ( N "Feature Control Frame (18)" )
@@ -79,49 +79,49 @@ set ref_data {
  	 	 0:1:4:27 Datum.53.2.2 ( N "Feature Control Frame (20)" )
  	 	 0:1:4:28 Datum.53.2.3 ( N "Feature Control Frame (20)" )
  0:1:1:2:51 Shape.54
- 	 0:1:4:29 Dimension.54.1 ( N "diameter" T 15, V 15.875, VL 64.515999999999991, VU 64.515999999999991, P 0 )
+ 	 0:1:4:29 Dimension.54.1 ( N "diameter" T 15, V 15.875, VL 2.54, VU 2.54, P 0 )
  	 0:1:4:31 GeomTolerance.54.1 ( N "Feature Control Frame (36)" T 10 TV 1, V 1.27, MR 1 )
  	 	 0:1:4:32 Datum.54.1.1 ( N "Feature Control Frame (36)" )
  	 	 0:1:4:33 Datum.54.1.2 ( N "Feature Control Frame (36)" )
  	 	 0:1:4:34 Datum.54.1.3 ( N "Feature Control Frame (36)" )
  0:1:1:2:52 Shape.55
- 	 0:1:4:29 Dimension.55.1 ( N "diameter" T 15, V 15.875, VL 64.515999999999991, VU 64.515999999999991, P 0 )
+ 	 0:1:4:29 Dimension.55.1 ( N "diameter" T 15, V 15.875, VL 2.54, VU 2.54, P 0 )
  	 0:1:4:31 GeomTolerance.55.1 ( N "Feature Control Frame (36)" T 10 TV 1, V 1.27, MR 1 )
  	 	 0:1:4:32 Datum.55.1.1 ( N "Feature Control Frame (36)" )
  	 	 0:1:4:33 Datum.55.1.2 ( N "Feature Control Frame (36)" )
  	 	 0:1:4:34 Datum.55.1.3 ( N "Feature Control Frame (36)" )
  0:1:1:2:53 Shape.56
- 	 0:1:4:29 Dimension.56.1 ( N "diameter" T 15, V 15.875, VL 64.515999999999991, VU 64.515999999999991, P 0 )
+ 	 0:1:4:29 Dimension.56.1 ( N "diameter" T 15, V 15.875, VL 2.54, VU 2.54, P 0 )
  	 0:1:4:31 GeomTolerance.56.1 ( N "Feature Control Frame (36)" T 10 TV 1, V 1.27, MR 1 )
  	 	 0:1:4:32 Datum.56.1.1 ( N "Feature Control Frame (36)" )
  	 	 0:1:4:33 Datum.56.1.2 ( N "Feature Control Frame (36)" )
  	 	 0:1:4:34 Datum.56.1.3 ( N "Feature Control Frame (36)" )
  0:1:1:2:54 Shape.57
- 	 0:1:4:29 Dimension.57.1 ( N "diameter" T 15, V 15.875, VL 64.515999999999991, VU 64.515999999999991, P 0 )
+ 	 0:1:4:29 Dimension.57.1 ( N "diameter" T 15, V 15.875, VL 2.54, VU 2.54, P 0 )
  	 0:1:4:31 GeomTolerance.57.1 ( N "Feature Control Frame (36)" T 10 TV 1, V 1.27, MR 1 )
  	 	 0:1:4:32 Datum.57.1.1 ( N "Feature Control Frame (36)" )
  	 	 0:1:4:33 Datum.57.1.2 ( N "Feature Control Frame (36)" )
  	 	 0:1:4:34 Datum.57.1.3 ( N "Feature Control Frame (36)" )
  0:1:1:2:55 Shape.58
- 	 0:1:4:29 Dimension.58.1 ( N "diameter" T 15, V 15.875, VL 64.515999999999991, VU 64.515999999999991, P 0 )
+ 	 0:1:4:29 Dimension.58.1 ( N "diameter" T 15, V 15.875, VL 2.54, VU 2.54, P 0 )
  	 0:1:4:31 GeomTolerance.58.1 ( N "Feature Control Frame (36)" T 10 TV 1, V 1.27, MR 1 )
  	 	 0:1:4:32 Datum.58.1.1 ( N "Feature Control Frame (36)" )
  	 	 0:1:4:33 Datum.58.1.2 ( N "Feature Control Frame (36)" )
  	 	 0:1:4:34 Datum.58.1.3 ( N "Feature Control Frame (36)" )
  0:1:1:2:56 Shape.59
- 	 0:1:4:29 Dimension.59.1 ( N "diameter" T 15, V 15.875, VL 64.515999999999991, VU 64.515999999999991, P 0 )
+ 	 0:1:4:29 Dimension.59.1 ( N "diameter" T 15, V 15.875, VL 2.54, VU 2.54, P 0 )
  	 0:1:4:31 GeomTolerance.59.1 ( N "Feature Control Frame (36)" T 10 TV 1, V 1.27, MR 1 )
  	 	 0:1:4:32 Datum.59.1.1 ( N "Feature Control Frame (36)" )
  	 	 0:1:4:33 Datum.59.1.2 ( N "Feature Control Frame (36)" )
  	 	 0:1:4:34 Datum.59.1.3 ( N "Feature Control Frame (36)" )
  0:1:1:2:57 Shape.60
- 	 0:1:4:29 Dimension.60.1 ( N "diameter" T 15, V 15.875, VL 64.515999999999991, VU 64.515999999999991, P 0 )
+ 	 0:1:4:29 Dimension.60.1 ( N "diameter" T 15, V 15.875, VL 2.54, VU 2.54, P 0 )
  	 0:1:4:31 GeomTolerance.60.1 ( N "Feature Control Frame (36)" T 10 TV 1, V 1.27, MR 1 )
  	 	 0:1:4:32 Datum.60.1.1 ( N "Feature Control Frame (36)" )
  	 	 0:1:4:33 Datum.60.1.2 ( N "Feature Control Frame (36)" )
  	 	 0:1:4:34 Datum.60.1.3 ( N "Feature Control Frame (36)" )
  0:1:1:2:58 Shape.61
- 	 0:1:4:29 Dimension.61.1 ( N "diameter" T 15, V 15.875, VL 64.515999999999991, VU 64.515999999999991, P 0 )
+ 	 0:1:4:29 Dimension.61.1 ( N "diameter" T 15, V 15.875, VL 2.54, VU 2.54, P 0 )
  	 0:1:4:31 GeomTolerance.61.1 ( N "Feature Control Frame (36)" T 10 TV 1, V 1.27, MR 1 )
  	 	 0:1:4:32 Datum.61.1.1 ( N "Feature Control Frame (36)" )
  	 	 0:1:4:33 Datum.61.1.2 ( N "Feature Control Frame (36)" )
@@ -137,28 +137,28 @@ set ref_data {
  0:1:1:2:129 Shape.132
  	 0:1:4:1 GeomTolerance.132.1 ( N "Feature Control Frame (4)" T 12 TV 0, V 0.254 )
  0:1:1:2:134 Shape.137
- 	 0:1:4:40 Dimension.137.1 ( N "diameter" T 15, V 27.050999999999998, VL 64.515999999999991, VU 64.515999999999991, P 0 )
+ 	 0:1:4:40 Dimension.137.1 ( N "diameter" T 15, V 27.050999999999998, VL 2.54, VU 2.54, P 0 )
  	 0:1:4:41 GeomTolerance.137.1 ( N "Feature Control Frame (30)" T 9 TV 1, V 0.254 )
  	 	 0:1:4:42 Datum.137.1.1 ( N "Feature Control Frame (30)" )
  0:1:1:2:135 Shape.138
- 	 0:1:4:40 Dimension.138.1 ( N "diameter" T 15, V 27.050999999999998, VL 64.515999999999991, VU 64.515999999999991, P 0 )
+ 	 0:1:4:40 Dimension.138.1 ( N "diameter" T 15, V 27.050999999999998, VL 2.54, VU 2.54, P 0 )
  	 0:1:4:41 GeomTolerance.138.1 ( N "Feature Control Frame (30)" T 9 TV 1, V 0.254 )
  	 	 0:1:4:42 Datum.138.1.1 ( N "Feature Control Frame (30)" )
  0:1:1:2:153 Shape.156
- 	 0:1:4:7 Dimension.156.1 ( N "diameter" T 15, V 11.1252, VL 64.515999999999991, VU 64.515999999999991, P 0 )
+ 	 0:1:4:7 Dimension.156.1 ( N "diameter" T 15, V 11.1252, VL 2.54, VU 2.54, P 0 )
  	 0:1:4:9 GeomTolerance.156.1 ( N "Feature Control Frame (10)" T 9 TV 1, V 0.254 )
  	 	 0:1:4:10 Datum.156.1.1 ( N "Feature Control Frame (10)" )
  0:1:1:2:154 Shape.157
- 	 0:1:4:7 Dimension.157.1 ( N "diameter" T 15, V 11.1252, VL 64.515999999999991, VU 64.515999999999991, P 0 )
+ 	 0:1:4:7 Dimension.157.1 ( N "diameter" T 15, V 11.1252, VL 2.54, VU 2.54, P 0 )
  	 0:1:4:9 GeomTolerance.157.1 ( N "Feature Control Frame (10)" T 9 TV 1, V 0.254 )
  	 	 0:1:4:10 Datum.157.1.1 ( N "Feature Control Frame (10)" )
  0:1:1:2:155 Shape.158
- 	 0:1:4:8 Dimension.158.1 ( N "diameter" T 15, V 11.1252, VL 64.515999999999991, VU 64.515999999999991, P 0 )
+ 	 0:1:4:8 Dimension.158.1 ( N "diameter" T 15, V 11.1252, VL 2.54, VU 2.54, P 0 )
  	 0:1:4:11 GeomTolerance.158.1 ( N "Feature Control Frame (11)" T 10 TV 1, V 0.50800000000000001 )
  	 	 0:1:4:12 Datum.158.1.1 ( N "Feature Control Frame (11)" )
  	 	 0:1:4:13 Datum.158.1.2 ( N "Feature Control Frame (11)" )
  0:1:1:2:156 Shape.159
- 	 0:1:4:8 Dimension.159.1 ( N "diameter" T 15, V 11.1252, VL 64.515999999999991, VU 64.515999999999991, P 0 )
+ 	 0:1:4:8 Dimension.159.1 ( N "diameter" T 15, V 11.1252, VL 2.54, VU 2.54, P 0 )
  	 0:1:4:11 GeomTolerance.159.1 ( N "Feature Control Frame (11)" T 10 TV 1, V 0.50800000000000001 )
  	 	 0:1:4:12 Datum.159.1.1 ( N "Feature Control Frame (11)" )
  	 	 0:1:4:13 Datum.159.1.2 ( N "Feature Control Frame (11)" )

tests/gdt/import/A4

@@ -414,9 +414,9 @@ set ref_data {
  0:1:1:2:157 Shape.160
  	 0:1:4:32 Dimension.160.1 ( N "diameter" T 15, V 20, VL 0.29999999999999999, VU 0.29999999999999999, P 0 )
  0:1:1:2:158 Shape.161
- 	 0:1:4:33 Dimension.161.1 ( N "angle" T 11, V 89.999999999776747, VL 1, VU 1, Q 3, P 0 )
+ 	 0:1:4:33 Dimension.161.1 ( N "angle" T 11, V 90, VL 1, VU 1, Q 3, P 0 )
  0:1:1:2:159 Shape.162
- 	 0:1:4:33 Dimension.162.1 ( N "angle" T 11, V 89.999999999776747, VL 1, VU 1, Q 3, P 0 )
+ 	 0:1:4:33 Dimension.162.1 ( N "angle" T 11, V 90, VL 1, VU 1, Q 3, P 0 )
  0:1:1:3:1 Shape.163
  	 0:1:4:19 GeomTolerance.163.1 ( N "Position surface profile.4" T 12 TV 0, V 0.5 )
  	 	 0:1:4:20 Datum.163.1.1 ( N "Position surface profile.4" )

tests/gdt/import/A5

@@ -10,9 +10,9 @@ set ref_data {
  NbOfDatumTarget         : 2
 
  0:1:1:2:2 Shape.5
- 	 0:1:4:14 Dimension.5.1 ( N "linear distance" T 2, V 127, VL 64.515999999999991, VU 64.515999999999991, P 0 )
+ 	 0:1:4:14 Dimension.5.1 ( N "linear distance" T 2, V 127, VL 2.54, VU 2.54, P 0 )
  0:1:1:2:8 Shape.11
- 	 0:1:4:14 Dimension.11.1 ( N "linear distance" T 2, V 127, VL 64.515999999999991, VU 64.515999999999991, P 0 )
+ 	 0:1:4:14 Dimension.11.1 ( N "linear distance" T 2, V 127, VL 2.54, VU 2.54, P 0 )
  0:1:1:2:9 Shape.12
  	 0:1:4:1 GeomTolerance.12.1 ( N "Feature Control Frame (11)" T 13 TV 0, V 0.127 )
  0:1:1:2:66 Shape.69
@@ -57,9 +57,9 @@ set ref_data {
  	 0:1:4:7 GeomTolerance.203.1 ( N "Feature Control Frame (4)" T 2 TV 0, V 0.050799999999999998 )
  	 	 0:1:4:8 Datum.203.1.1 ( N "Feature Control Frame (4)" )
  0:1:1:2:206 Shape.209
- 	 0:1:4:11 Dimension.209.1 ( N "linear distance" T 2, V 254, VL 64.515999999999991, VU 64.515999999999991, P 0 )
+ 	 0:1:4:11 Dimension.209.1 ( N "linear distance" T 2, V 254, VL 2.54, VU 2.54, P 0 )
  0:1:1:2:207 Shape.210
- 	 0:1:4:11 Dimension.210.1 ( N "linear distance" T 2, V 254, VL 64.515999999999991, VU 64.515999999999991, P 0 )
+ 	 0:1:4:11 Dimension.210.1 ( N "linear distance" T 2, V 254, VL 2.54, VU 2.54, P 0 )
  0:1:1:3:1 Shape.211
  	 0:1:4:1 GeomTolerance.211.1 ( N "Feature Control Frame (11)" T 13 TV 0, V 0.127 )
 }

tests/gdt/view/A3

@@ -1,7 +1,7 @@
 set filename bug27645_nist_ftc_06_asme1_cr3000_rd.prt.stp
 
 set ref_data {
-D_First 0:1:7:1 2 18 0 MBD_A parallel 1003.2130229675 933.1983040089 -966.2677894877 -0.5983635664 -0.5566034856 0.5763276865  -0.34864265817483364 0.82851635272424506 0.43818825882182255 20.0 40.0 40.0
-D_First 0:1:7:2 2 3 0 MBD_B parallel -1003.2130229675 933.1983040089 966.2677894877 0.5983635664 -0.5566034856 -0.5763276865  0.34864265817483364 0.82851635272424506 -0.43818825882182255 20.0 40.0 40.0
-D_First 0:1:7:3 2 8 0 MBD_C parallel 0.0 1359.2608224096 -1359.2608224096 -0.0 -0.7071067812 0.7071067812  0 0.70710678118654757 0.70710678118654757 20.0 40.0 40.0
+D_First 0:1:7:1 2 18 0 MBD_A parallel 25481.6107833745 23703.2369218261 -24543.2018529876 -0.5983635664 -0.5566034856 0.5763276865  -0.34864265817483364 0.82851635272424506 0.43818825882182255 20.0 40.0 40.0
+D_First 0:1:7:2 2 3 0 MBD_B parallel -25481.6107833745 23703.2369218261 24543.2018529876 0.5983635664 -0.5566034856 -0.5763276865  0.34864265817483364 0.82851635272424506 -0.43818825882182255 20.0 40.0 40.0
+D_First 0:1:7:3 2 8 0 MBD_C parallel 0 34525.2248892038 -34525.22488920386 -0.0 -0.7071067812 0.7071067812  0 0.70710678118654757 0.70710678118654757 20.0 40.0 40.0
 }

tests/gdt/view/A4

@@ -1,7 +1,7 @@
 set filename bug27808_nist_ftc_06_asme1_ct5240_rd.stp
 
 set ref_data {
-D_First 0:1:7:1 2 30 0 MBD_A parallel 30.8084683155 26.0037688008 -25.0004637711 0.5773502692 0.5773502692 -0.5773502692 -0.40824829046386307 0.81649658092772615 0.40824829046386307 1104.2341308594 530.2063197413 530.2063197413
-D_First 0:1:7:2 2 16 0 MBD_B central -31.9257504921 33.3287805272 27.9693987989 -0.5773502692 0.5773502692 0.5773502692 0.40824829046386307 0.81649658092772615 -0.40824829046386307 1349.3127441406 647.8826584485 647.8826584485
-D_First 0:1:7:3 2 24 0 MBD_C central -0.4196386262 31.1460383858 -33.088921975 0.0 0.6979703596 -0.7161266488 0 0.71612664879940147 0.69797035959941667 1053.7369384766 505.9597131727 505.9597131727
+D_First 0:1:7:1 2 30 0 MBD_A parallel 782.5350952137 660.49572754032 -635.01177978594 0.5773502692 0.5773502692 -0.5773502692 -0.40824829046386307 0.81649658092772615 0.40824829046386307 1104.2341308594 530.2063197413 530.2063197413
+D_First 0:1:7:2 2 16 0 MBD_B central -810.91406249934 846.55102539088 710.42272949206 -0.5773502692 0.5773502692 0.5773502692 0.40824829046386307 0.81649658092772615 -0.40824829046386307 1349.3127441406 647.8826584485 647.8826584485
+D_First 0:1:7:3 2 24 0 MBD_C central -10.65882110548 791.10937499932 -840.45861816 0.0 0.6979703596 -0.7161266488 0 0.71612664879940147 0.69797035959941667 1053.7369384766 505.9597131727 505.9597131727
 }

tests/gdt/view/A5

@@ -1,6 +1,6 @@
 set filename bug27645_nist_ftc_06_asme1_ct5240_rd-1.stp
 
 set ref_data {
-D_First 0:1:7:1 2 29 0 MBD_A parallel 782.5350952148 660.4957275391 -635.0117797852 0.5773502692 0.5773502692 -0.5773502692 -0.40824829046386307 0.81649658092772615 0.40824829046386307 1104.2341308594 530.2063197413 530.2063197413
-D_First 0:1:7:2 2 18 0 MBD_C central -10.658821106 791.109375 -840.4586181641 0.0 0.6979703596 -0.7161266488 0 0.71612664879940147 0.69797035959941667 1053.7369384766 505.9597131727 505.9597131727
+D_First 0:1:7:1 2 29 0 MBD_A parallel 19876.3914184559 16776.5914794931 -16129.2992065441 0.5773502692 0.5773502692 -0.5773502692 -0.40824829046386307 0.81649658092772615 0.40824829046386307 1104.2341308594 530.2063197413 530.2063197413
+D_First 0:1:7:2 2 18 0 MBD_C central -270.7340560924 20094.178125 -21347.6489013681 0.0 0.6979703596 -0.7161266488 0 0.71612664879940147 0.69797035959941667 1053.7369384766 505.9597131727 505.9597131727
 }

tests/gdt/view/A6

@@ -1,8 +1,8 @@
 set filename bug27645_nist_ftc_08_asme1_cr3000_rc.prt.stp
 
 set ref_data {
-D_First 0:1:7:1 3 8 0 MBD_A parallel 960.208198256 960.2081982559 -996.2072738181 -0.5701373455 -0.5701373455 0.5915123113  -0.41826236649918141 -0.41826236649918141 -0.80629596646703439 20.0 40.0 40.0
-D_First 0:1:7:2 3 6 0 MBD_B parallel 960.208198256 -960.2081982559 996.2072738181 -0.5701373455 0.5701373455 -0.5915123113 -0.41826236649918141 0.41826236649918141 0.80629596646703439 20.0 40.0 40.0
-D_First 0:1:7:3 3 3 0 MBD_C parallel 960.208198256 -960.2081982559 996.2072738181 -0.5701373455 0.5701373455 -0.5915123113  -0.41826236649918141 0.41826236649918141 0.80629596646703439 20.0 40.0 40.0
-D_First 0:1:7:4 3 8 0 MBD_D parallel 960.2081982559 960.2081982559 996.2072738181 -0.5701373455 -0.5701373455 -0.5915123113 -0.41826236649918141 -0.41826236649918141 0.80629596646703439 20.0 40.0 40.0
+D_First 0:1:7:1 3 8 0 MBD_A parallel 24389.2882357024 24389.2882356999 -25303.6647549797 -0.5701373455 -0.5701373455 0.5915123113  -0.41826236649918141 -0.41826236649918141 -0.80629596646703439 20.0 40.0 40.0
+D_First 0:1:7:2 3 6 0 MBD_B parallel 24389.2882357024 -24389.2882356999 25303.6647549797 -0.5701373455 0.5701373455 -0.5915123113 -0.41826236649918141 0.41826236649918141 0.80629596646703439 20.0 40.0 40.0
+D_First 0:1:7:3 3 3 0 MBD_C parallel 24389.2882357024 -24389.2882356999 25303.664754979 -0.5701373455 0.5701373455 -0.5915123113  -0.41826236649918141 0.41826236649918141 0.80629596646703439 20.0 40.0 40.0
+D_First 0:1:7:4 3 8 0 MBD_D parallel 24389.2882356999 24389.2882356999 25303.6647549797 -0.5701373455 -0.5701373455 -0.5915123113 -0.41826236649918141 -0.41826236649918141 0.80629596646703439 20.0 40.0 40.0
 }

tests/gdt/view/A7

@@ -1,8 +1,8 @@
 set filename bug27808_nist_ftc_08_asme1_ct5240_rc.stp
 
 set ref_data {
-D_First 0:1:7:1 3 15 0 MBD_A parallel 20.6276528666 24.7090209 -21.2968288632 0.5773502692 0.5773502692 -0.5773502692  -0.40824829046386302 -0.40824829046386302 -0.81649658092772603 1133.0983886719 544.065710136 544.065710136
-D_First 0:1:7:2 3 18 0 MBD_B parallel 21.6691096749 -22.3932077002 22.6894396684 0.5773502692 -0.5773502692 0.5773502692 -0.40824829046386302 0.40824829046386302 0.81649658092772603 972.7067871094 467.0524767961 467.0524767961
-D_First 0:1:7:3 3 6 0 MBD_C central 22.5691379337 -20.4109059732 21.0932597964 0.5773502692 -0.5773502692 0.5773502692 -0.40824829046386302 0.40824829046386302 0.81649658092772603 856.7503051758 411.3751002162 411.3751002162
-D_First 0:1:7:4 3 14 0 MBD_D parallel 23.6742659441 21.3498117041 22.1304297259 0.5773502692 0.5773502692 0.5773502692 -0.40824829046386302 -0.40824829046386302 0.81649658092772603 891.8790283203 428.2424207374 428.2424207374
+D_First 0:1:7:1 3 15 0 MBD_A parallel 523.94238281164 627.60913086 -540.93945312528 0.5773502692 0.5773502692 -0.5773502692  -0.40824829046386302 -0.40824829046386302 -0.81649658092772603 1133.0983886719 544.065710136 544.065710136
+D_First 0:1:7:2 3 18 0 MBD_B parallel 550.39538574246 -568.78747558508 576.31176757736 0.5773502692 -0.5773502692 0.5773502692 -0.40824829046386302 0.40824829046386302 0.81649658092772603 972.7067871094 467.0524767961 467.0524767961
+D_First 0:1:7:3 3 6 0 MBD_C central 573.25610351598 -518.43701171928 535.76879882856 0.5773502692 -0.5773502692 0.5773502692 -0.40824829046386302 0.40824829046386302 0.81649658092772603 856.7503051758 411.3751002162 411.3751002162
+D_First 0:1:7:4 3 14 0 MBD_D parallel 601.32635498014 542.28521728414 562.11291503786 0.5773502692 0.5773502692 0.5773502692 -0.40824829046386302 -0.40824829046386302 0.81649658092772603 891.8790283203 428.2424207374 428.2424207374
 }

tests/gdt/view/A8

@@ -1,5 +1,5 @@
 set filename bug27645_nist_ftc_08_asme1_ct5240_rc-1.stp
 
 set ref_data {
-D_First 0:1:7:1 3 18 0 MBD_B parallel 550.3953857422 -568.7874755859 576.3117675781 0.5773502692 -0.5773502692 0.5773502692 -0.40824829046386302 0.40824829046386302 0.81649658092772603 972.7067871094 467.0524767961 467.0524767961
+D_First 0:1:7:1 3 18 0 MBD_B parallel 13980.0427978519 -14447.2018798819 14638.318896483 0.5773502692 -0.5773502692 0.5773502692 -0.40824829046386302 0.40824829046386302 0.81649658092772603 972.7067871094 467.0524767961 467.0524767961
 }

tests/gdt/view/A9

@@ -1,8 +1,8 @@
 set filename bug27645_nist_ftc_09_asme1_cr3000_rd.prt.stp
 
 set ref_data {
-D_First 0:1:7:1 2 11 0 MBD_A parallel -1175.8873057482 925.9850617285 1405.1817250125 0.5727731186 -0.4510460731 -0.6844621206 0.29048014152512924 0.89249988323766694 -0.34505832231709999 20.0 40.0 40.0
-D_First 0:1:7:2 2 8 0 MBD_B parallel -1175.8873057482 925.9850617285 1405.1817250125 0.5727731186 -0.4510460731 -0.6844621206 0.29048014152512924 0.89249988323766694 -0.34505832231709999 20.0 40.0 40.0
-D_First 0:1:7:3 2 6 0 MBD_C parallel -951.665243989 749.4151823838 1137.2370486915 0.5727731186 -0.4510460731 -0.6844621206 0.29048014152512924 0.89249988323766694 -0.34505832231709999 20.0 40.0 40.0
-D_First 0:1:7:4 2 8 0 MBD_D parallel 1052.959289197 925.9850617285 1499.5077096909 -0.5128950478 -0.4510460731 -0.7304081804 -0.25811895222709652 0.89249988325203511 -0.3698899361922266 20.0 40.0 40.0
+D_First 0:1:7:1 2 11 0 MBD_A parallel -29867.5375660043 23520.0205679039 35691.6158153175 0.5727731186 -0.4510460731 -0.6844621206 0.29048014152512924 0.89249988323766694 -0.34505832231709999 20.0 40.0 40.0
+D_First 0:1:7:2 2 8 0 MBD_B parallel -29867.5375660043 23520.0205679039 35691.6158153175 0.5727731186 -0.4510460731 -0.6844621206 0.29048014152512924 0.89249988323766694 -0.34505832231709999 20.0 40.0 40.0
+D_First 0:1:7:3 2 6 0 MBD_C parallel -24172.2971973206 19035.1456325485 28885.8210367641 0.5727731186 -0.4510460731 -0.6844621206 0.29048014152512924 0.89249988323766694 -0.34505832231709999 20.0 40.0 40.0
+D_First 0:1:7:4 2 8 0 MBD_D parallel 26745.1659456038 23520.0205679039 38087.4958261489 -0.5128950478 -0.4510460731 -0.7304081804 -0.25811895222709652 0.89249988325203511 -0.3698899361922266 20.0 40.0 40.0
 }

tests/gdt/view/B1

@@ -1,8 +1,8 @@
 set filename bug27808_nist_ftc_09_asme1_ct5240_rd.stp
 
 set ref_data {
-D_First 0:1:7:1 2 21 0 MBD_A central -20.8553716705 19.0487334484 16.8668443575 -0.5773502692 0.5773502692 0.5773502692 0.40824829046386307 0.81649658092772615 -0.40824829046386307 948.7595214844 455.5540171668 455.5540171668
-D_First 0:1:7:2 2 10 0 MBD_B parallel -16.8234421137 16.8832385446 16.8234313004 -0.5773502692 0.5773502692 0.5773502692 0.40824829046386307 0.81649658092772615 -0.40824829046386307 740.1318359375 355.3798654551 355.3798654551
-D_First 0:1:7:3 2 16 0 MBD_C central -10.8134556568 14.3968068521 12.8345579613 -0.5773502692 0.5773502692 0.5773502692 0.40824829046386307 0.81649658092772615 -0.40824829046386307 557.039855957 267.4668747527 267.4668747527
-D_First 0:1:7:4 2 17 0 MBD_D central 16.8234325018 16.8832397461 16.8234373078 0.5773502692 0.5773502692 0.5773502692 -0.40824829046386307 0.81649658092772615 -0.40824829046386307 740.1318359375 355.3798654551 355.3798654551
+D_First 0:1:7:1 2 21 0 MBD_A central -529.7264404307 483.83782958936 428.417846680 -0.5773502692 0.5773502692 0.5773502692 0.40824829046386307 0.81649658092772615 -0.40824829046386307 948.7595214844 455.5540171668 455.5540171668
+D_First 0:1:7:2 2 10 0 MBD_B parallel -427.31542968798 428.83425903284 427.3151550301 -0.5773502692 0.5773502692 0.5773502692 0.40824829046386307 0.81649658092772615 -0.40824829046386307 740.1318359375 355.3798654551 355.3798654551
+D_First 0:1:7:3 2 16 0 MBD_C central -274.66177368272 365.67889404334 325.99777221702 -0.5773502692 0.5773502692 0.5773502692 0.40824829046386307 0.81649658092772615 -0.40824829046386307 557.039855957 267.4668747527 267.4668747527
+D_First 0:1:7:4 2 17 0 MBD_D central 427.31518554572 428.83428955094 427.31530761812 0.5773502692 0.5773502692 0.5773502692 -0.40824829046386307 0.81649658092772615 -0.40824829046386307 740.1318359375 355.3798654551 355.3798654551
 }

tests/gdt/view/B2

@@ -1,8 +1,8 @@
 set filename bug27645_nist_ftc_09_asme1_ct5240_rd-1.stp
 
 set ref_data {
-D_First 0:1:7:1 2 21 0 MBD_A central -529.7264404297 483.8378295898 428.4178466797 -0.5773502692 0.5773502692 0.5773502692 0.40824829046386307 0.81649658092772615 -0.40824829046386307 948.7595214844 455.5540171668 455.5540171668
-D_First 0:1:7:2 2 10 0 MBD_B parallel -427.3154296875 428.8342590332 427.3151550293 -0.5773502692 0.5773502692 0.5773502692 0.40824829046386307 0.81649658092772615 -0.40824829046386307 740.1318359375 355.3798654551 355.3798654551
-D_First 0:1:7:3 2 16 0 MBD_C central -274.6617736816 365.678894043 325.9977722168 -0.5773502692 0.5773502692 0.5773502692 0.40824829046386307 0.81649658092772615 -0.40824829046386307 557.039855957 267.4668747527 267.4668747527
-D_First 0:1:7:4 2 17 0 MBD_D central 427.3151855469 428.8342895508 427.3153076172 0.5773502692 0.5773502692 0.5773502692 -0.40824829046386307 0.81649658092772615 -0.40824829046386307 740.1318359375 355.3798654551 355.3798654551
+D_First 0:1:7:1 2 21 0 MBD_A central -13455.0515869144 12289.4808715809 10881.8133056644 -0.5773502692 0.5773502692 0.5773502692 0.40824829046386307 0.81649658092772615 -0.40824829046386307 948.7595214844 455.5540171668 455.5540171668
+D_First 0:1:7:2 2 10 0 MBD_B parallel -10853.8119140625 10892.3901794433 10853.8049377442 -0.5773502692 0.5773502692 0.5773502692 0.40824829046386307 0.81649658092772615 -0.40824829046386307 740.1318359375 355.3798654551 355.3798654551
+D_First 0:1:7:3 2 16 0 MBD_C central -6976.40905151264 9288.2439086922 8280.34341430672 -0.5773502692 0.5773502692 0.5773502692 0.40824829046386307 0.81649658092772615 -0.40824829046386307 557.039855957 267.4668747527 267.4668747527
+D_First 0:1:7:4 2 17 0 MBD_D central 10853.8057128913 10892.3909545903 10853.8088134769 0.5773502692 0.5773502692 0.5773502692 -0.40824829046386307 0.81649658092772615 -0.40824829046386307 740.1318359375 355.3798654551 355.3798654551
 }