0033099: Data Exchange, Step Import - Wrong PMI values in GDT

Create StepRepr_MeasureWithUnit class for select type of measure.

src/AIS/AIS_AnimationAxisRotation.cxx

@@ -0,0 +1,51 @@
+// Copyright (c) 2023 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <AIS_AnimationAxisRotation.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(AIS_AnimationAxisRotation, AIS_BaseAnimationObject)
+
+//=============================================================================
+//function : Constructor
+//purpose  :
+//=============================================================================
+AIS_AnimationAxisRotation::AIS_AnimationAxisRotation (const TCollection_AsciiString& theAnimationName,
+                                                      const Handle(AIS_InteractiveContext)& theContext,
+                                                      const Handle(AIS_InteractiveObject)& theObject,
+                                                      const gp_Ax1& theAxis,
+                                                      const Standard_Real theAngleStart,
+                                                      const Standard_Real theAngleEnd)
+: AIS_BaseAnimationObject (theAnimationName, theContext, theObject),
+  myRotAxis    (theAxis),
+  myAngleStart (theAngleStart),
+  myAngleEnd   (theAngleEnd)
+{
+  //
+}
+
+//=============================================================================
+//function : update
+//purpose  :
+//=============================================================================
+void AIS_AnimationAxisRotation::update (const AIS_AnimationProgress& theProgress)
+{
+  if (myObject.IsNull())
+  {
+    return;
+  }
+
+  gp_Trsf aTrsf;
+  Standard_Real aCurrentAngle = (1.0 - theProgress.LocalNormalized) * myAngleStart + theProgress.LocalNormalized * myAngleEnd;
+  aTrsf.SetRotation (myRotAxis, aCurrentAngle);
+  updateTrsf (aTrsf);
+}

src/AIS/AIS_AnimationAxisRotation.hxx

@@ -0,0 +1,53 @@
+// Copyright (c) 2023 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _AIS_AnimationAxisRotation_HeaderFile
+#define _AIS_AnimationAxisRotation_HeaderFile
+
+#include <AIS_BaseAnimationObject.hxx>
+#include <gp_TrsfNLerp.hxx>
+
+//! Animation defining object transformation.
+class AIS_AnimationAxisRotation : public AIS_BaseAnimationObject
+{
+  DEFINE_STANDARD_RTTIEXT(AIS_AnimationAxisRotation, AIS_BaseAnimationObject)
+public:
+
+  //! Constructor with initialization.
+  //! @param[in] theAnimationName animation identifier
+  //! @param[in] theContext       interactive context where object have been displayed
+  //! @param[in] theObject        object to apply rotation
+  //! @param[in] theAxis          rotation axis
+  //! @param[in] theAngleStart    rotation angle at the start of animation
+  //! @param[in] theAngleEnd      rotation angle at the end   of animation
+  Standard_EXPORT AIS_AnimationAxisRotation (const TCollection_AsciiString& theAnimationName,
+                                             const Handle(AIS_InteractiveContext)& theContext,
+                                             const Handle(AIS_InteractiveObject)& theObject,
+                                             const gp_Ax1& theAxis,
+                                             const Standard_Real theAngleStart,
+                                             const Standard_Real theAngleEnd);
+
+protected:
+
+  //! Update the progress.
+  Standard_EXPORT virtual void update (const AIS_AnimationProgress& theProgress) Standard_OVERRIDE;
+
+private:
+
+  gp_Ax1         myRotAxis;     //!< rotation axis
+  Standard_Real  myAngleStart;  //!< start angle for rotation
+  Standard_Real  myAngleEnd;    //!< end angle for rotation
+
+};
+
+#endif // _AIS_AnimationAxisRotation_HeaderFile

src/AIS/AIS_AnimationObject.cxx

@@ -14,10 +14,7 @@
 
 #include <AIS_AnimationObject.hxx>
 
-#include <AIS_InteractiveContext.hxx>
-#include <V3d_View.hxx>
-
-IMPLEMENT_STANDARD_RTTIEXT(AIS_AnimationObject, AIS_Animation)
+IMPLEMENT_STANDARD_RTTIEXT(AIS_AnimationObject, AIS_BaseAnimationObject)
 
 //=============================================================================
 //function : Constructor
@@ -28,9 +25,7 @@ AIS_AnimationObject::AIS_AnimationObject (const TCollection_AsciiString& theAnim
                                           const Handle(AIS_InteractiveObject)&  theObject,
                                           const gp_Trsf& theTrsfStart,
                                           const gp_Trsf& theTrsfEnd)
-: AIS_Animation (theAnimationName),
-  myContext  (theContext),
-  myObject   (theObject),
+: AIS_BaseAnimationObject (theAnimationName, theContext, theObject),
   myTrsfLerp (theTrsfStart, theTrsfEnd)
 {
   //
@@ -49,52 +44,5 @@ void AIS_AnimationObject::update (const AIS_AnimationProgress& theProgress)
 
   gp_Trsf aTrsf;
   myTrsfLerp.Interpolate (theProgress.LocalNormalized, aTrsf);
-  if (!myContext.IsNull())
-  {
-    myContext->SetLocation (myObject, aTrsf);
-    invalidateViewer();
-  }
-  else
-  {
-    myObject->SetLocalTransformation (aTrsf);
-  }
-}
-
-//=============================================================================
-//function : invalidateViewer
-//purpose  :
-//=============================================================================
-void AIS_AnimationObject::invalidateViewer()
-{
-  if (myContext.IsNull())
-  {
-    return;
-  }
-
-  const Standard_Boolean isImmediate = myContext->CurrentViewer()->ZLayerSettings (myObject->ZLayer()).IsImmediate();
-  if (!isImmediate)
-  {
-    myContext->CurrentViewer()->Invalidate();
-    return;
-  }
-
-  // Invalidate immediate view only if it is going out of z-fit range.
-  // This might be sub-optimal performing this for each animated objects in case of many animated objects.
-  for (V3d_ListOfView::Iterator aDefViewIter = myContext->CurrentViewer()->DefinedViewIterator();
-       aDefViewIter.More(); aDefViewIter.Next())
-  {
-    const Handle(V3d_View)& aView = aDefViewIter.Value();
-    const Bnd_Box aMinMaxBox  = aView->View()->MinMaxValues (Standard_False);
-    const Bnd_Box aGraphicBox = aView->View()->MinMaxValues (Standard_True);
-    Standard_Real aZNear = 0.0;
-    Standard_Real aZFar  = 0.0;
-    if (aView->Camera()->ZFitAll (aDefViewIter.Value()->AutoZFitScaleFactor(), aMinMaxBox, aGraphicBox, aZNear, aZFar))
-    {
-      if (aZNear < aView->Camera()->ZNear()
-       || aZFar  > aView->Camera()->ZFar())
-      {
-        aDefViewIter.Value()->Invalidate();
-      }
-    }
-  }
+  updateTrsf (aTrsf);
 }

src/AIS/AIS_AnimationObject.hxx

@@ -15,24 +15,23 @@
 #ifndef _AIS_AnimationObject_HeaderFile
 #define _AIS_AnimationObject_HeaderFile
 
-#include <AIS_Animation.hxx>
-#include <AIS_InteractiveContext.hxx>
+#include <AIS_BaseAnimationObject.hxx>
 #include <gp_TrsfNLerp.hxx>
 
 //! Animation defining object transformation.
-class AIS_AnimationObject : public AIS_Animation
+class AIS_AnimationObject : public AIS_BaseAnimationObject
 {
-  DEFINE_STANDARD_RTTIEXT(AIS_AnimationObject, AIS_Animation)
+  DEFINE_STANDARD_RTTIEXT(AIS_AnimationObject, AIS_BaseAnimationObject)
 public:
 
   //! Constructor with initialization.
   //! Note that start/end transformations specify exactly local transformation of the object,
   //! not the transformation to be applied to existing local transformation.
-  //! @param theAnimationName animation identifier
-  //! @param theContext       interactive context where object have been displayed
-  //! @param theObject        object to apply local transformation
-  //! @param theTrsfStart     local transformation at the start of animation (e.g. theObject->LocalTransformation())
-  //! @param theTrsfEnd       local transformation at the end   of animation
+  //! @param[in] theAnimationName animation identifier
+  //! @param[in] theContext       interactive context where object have been displayed
+  //! @param[in] theObject        object to apply local transformation
+  //! @param[in] theTrsfStart     local transformation at the start of animation (e.g. theObject->LocalTransformation())
+  //! @param[in] theTrsfEnd       local transformation at the end   of animation
   Standard_EXPORT AIS_AnimationObject (const TCollection_AsciiString& theAnimationName,
                                        const Handle(AIS_InteractiveContext)& theContext,
                                        const Handle(AIS_InteractiveObject)&  theObject,
@@ -44,17 +43,10 @@ protected:
   //! Update the progress.
   Standard_EXPORT virtual void update (const AIS_AnimationProgress& theProgress) Standard_OVERRIDE;
 
-  //! Invalidate the viewer for proper update.
-  Standard_EXPORT void invalidateViewer();
+private:
 
-protected:
-
-  Handle(AIS_InteractiveContext) myContext;   //!< context where object is displayed
-  Handle(AIS_InteractiveObject)  myObject;    //!< presentation object to set location
-  gp_TrsfNLerp                   myTrsfLerp;  //!< interpolation tool
+  gp_TrsfNLerp  myTrsfLerp; //!< interpolation tool
 
 };
 
-DEFINE_STANDARD_HANDLE(AIS_AnimationObject, AIS_Animation)
-
 #endif // _AIS_AnimationObject_HeaderFile

src/AIS/AIS_BaseAnimationObject.cxx

@@ -0,0 +1,88 @@
+// Copyright (c) 2023 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <AIS_BaseAnimationObject.hxx>
+
+#include <V3d_View.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(AIS_BaseAnimationObject, AIS_Animation)
+
+//=============================================================================
+//function : Constructor
+//purpose  :
+//=============================================================================
+AIS_BaseAnimationObject::AIS_BaseAnimationObject (const TCollection_AsciiString& theAnimationName,
+                                                  const Handle(AIS_InteractiveContext)& theContext,
+                                                  const Handle(AIS_InteractiveObject)&  theObject)
+: AIS_Animation (theAnimationName),
+  myContext  (theContext),
+  myObject   (theObject)
+{
+  //
+}
+
+//=============================================================================
+//function : updateTrsf
+//purpose  :
+//=============================================================================
+void AIS_BaseAnimationObject::updateTrsf (const gp_Trsf& theTrsf)
+{
+  if (!myContext.IsNull())
+  {
+    myContext->SetLocation (myObject, theTrsf);
+    invalidateViewer();
+  }
+  else
+  {
+    myObject->SetLocalTransformation (theTrsf);
+  }
+}
+
+//=============================================================================
+//function : invalidateViewer
+//purpose  :
+//=============================================================================
+void AIS_BaseAnimationObject::invalidateViewer()
+{
+  if (myContext.IsNull())
+  {
+    return;
+  }
+
+  const Standard_Boolean isImmediate = myContext->CurrentViewer()->ZLayerSettings (myObject->ZLayer()).IsImmediate();
+  if (!isImmediate)
+  {
+    myContext->CurrentViewer()->Invalidate();
+    return;
+  }
+
+  // Invalidate immediate view only if it is going out of z-fit range.
+  // This might be sub-optimal performing this for each animated objects in case of many animated objects.
+  for (V3d_ListOfView::Iterator aDefViewIter = myContext->CurrentViewer()->DefinedViewIterator();
+       aDefViewIter.More(); aDefViewIter.Next())
+  {
+    const Handle(V3d_View)& aView = aDefViewIter.Value();
+    const Bnd_Box aMinMaxBox  = aView->View()->MinMaxValues (Standard_False);
+    const Bnd_Box aGraphicBox = aView->View()->MinMaxValues (Standard_True);
+    Standard_Real aZNear = 0.0;
+    Standard_Real aZFar  = 0.0;
+    if (aView->Camera()->ZFitAll (aDefViewIter.Value()->AutoZFitScaleFactor(), aMinMaxBox, aGraphicBox, aZNear, aZFar))
+    {
+      if (aZNear < aView->Camera()->ZNear()
+       || aZFar  > aView->Camera()->ZFar())
+      {
+        aDefViewIter.Value()->Invalidate();
+      }
+    }
+  }
+}

src/AIS/AIS_BaseAnimationObject.hxx

@@ -0,0 +1,49 @@
+// Copyright (c) 2023 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _AIS_BaseAnimationObject_HeaderFile
+#define _AIS_BaseAnimationObject_HeaderFile
+
+#include <AIS_Animation.hxx>
+#include <AIS_InteractiveContext.hxx>
+
+//! Animation defining object transformation.
+class AIS_BaseAnimationObject : public AIS_Animation
+{
+  DEFINE_STANDARD_RTTIEXT(AIS_BaseAnimationObject, AIS_Animation)
+protected:
+
+  //! Constructor with initialization.
+  //! @param[in] theAnimationName animation identifier
+  //! @param[in] theContext       interactive context where object have been displayed
+  //! @param[in] theObject        object to apply local transformation
+  Standard_EXPORT AIS_BaseAnimationObject (const TCollection_AsciiString& theAnimationName,
+                                           const Handle(AIS_InteractiveContext)& theContext,
+                                           const Handle(AIS_InteractiveObject)&  theObject);
+
+  //! Update the transformation.
+  Standard_EXPORT void updateTrsf (const gp_Trsf& theTrsf);
+
+private:
+
+  //! Invalidate the viewer for proper update.
+  Standard_EXPORT void invalidateViewer();
+
+protected:
+
+  Handle(AIS_InteractiveContext) myContext;   //!< context where object is displayed
+  Handle(AIS_InteractiveObject)  myObject;    //!< presentation object to set location
+
+};
+
+#endif // _AIS_BaseAnimationObject_HeaderFile

src/AIS/AIS_Manipulator.cxx

@@ -1116,18 +1116,23 @@ void AIS_Manipulator::ComputeSelection (const Handle(SelectMgr_Selection)& theSe
                                         const Standard_Integer theMode)
 {
   //Check mode
-  AIS_ManipulatorMode aMode = (AIS_ManipulatorMode) theMode;
+  const AIS_ManipulatorMode aMode = (AIS_ManipulatorMode) theMode;
   if (aMode == AIS_MM_None)
   {
     return;
   }
   Handle(SelectMgr_EntityOwner) anOwner;
-  if (aMode == AIS_MM_None)
-  {
-    anOwner = new SelectMgr_EntityOwner (this, 5);
-  }
 
-  if (aMode == AIS_MM_Translation || aMode == AIS_MM_None)
+  // Sensitivity calculation for manipulator parts allows to avoid
+  // overlapping of sensitive areas when size of manipulator is small.
+  // Sensitivity is calculated relative to the default size of the manipulator (100.0f).
+  const Standard_ShortReal aSensitivityCoef = myAxes[0].Size() / 100.0f;
+  const Standard_Integer aHighSensitivity = Max (Min (RealToInt (aSensitivityCoef * 15), 15), 3); // clamp sensitivity within range [3, 15]
+  const Standard_Integer aLowSensitivity  = Max (Min (RealToInt (aSensitivityCoef * 10), 10), 2); // clamp sensitivity within range [2, 10]
+
+  switch (aMode)
+  {
+  case AIS_MM_Translation:
   {
     for (Standard_Integer anIt = 0; anIt < 3; ++anIt)
     {
@@ -1136,23 +1141,21 @@ void AIS_Manipulator::ComputeSelection (const Handle(SelectMgr_Selection)& theSe
         continue;
       }
       const Axis& anAxis = myAxes[anIt];
-      if (aMode != AIS_MM_None)
-      {
-        anOwner = new AIS_ManipulatorOwner (this, anIt, AIS_MM_Translation, 9);
-      }
+      anOwner = new AIS_ManipulatorOwner(this, anIt, AIS_MM_Translation, 9);
+
       // define sensitivity by line
-      Handle(Select3D_SensitiveSegment) aLine = new Select3D_SensitiveSegment (anOwner, gp::Origin(), anAxis.TranslatorTipPosition());
-      aLine->SetSensitivityFactor (15);
+      Handle(Select3D_SensitiveSegment) aLine = new Select3D_SensitiveSegment(anOwner, gp::Origin(), anAxis.TranslatorTipPosition());
+      aLine->SetSensitivityFactor (aHighSensitivity);
       theSelection->Add (aLine);
 
       // enlarge sensitivity by triangulation
-      Handle(Select3D_SensitivePrimitiveArray) aTri = new Select3D_SensitivePrimitiveArray (anOwner);
+      Handle(Select3D_SensitivePrimitiveArray) aTri = new Select3D_SensitivePrimitiveArray(anOwner);
       aTri->InitTriangulation (anAxis.TriangleArray()->Attributes(), anAxis.TriangleArray()->Indices(), TopLoc_Location());
       theSelection->Add (aTri);
     }
+    break;
   }
-
-  if (aMode == AIS_MM_Rotation || aMode == AIS_MM_None)
+  case AIS_MM_Rotation:
   {
     for (Standard_Integer anIt = 0; anIt < 3; ++anIt)
     {
@@ -1161,22 +1164,20 @@ void AIS_Manipulator::ComputeSelection (const Handle(SelectMgr_Selection)& theSe
         continue;
       }
       const Axis& anAxis = myAxes[anIt];
-      if (aMode != AIS_MM_None)
-      {
-        anOwner = new AIS_ManipulatorOwner (this, anIt, AIS_MM_Rotation, 9);
-      }
+      anOwner = new AIS_ManipulatorOwner(this, anIt, AIS_MM_Rotation, 9);
+
       // define sensitivity by circle
-      const gp_Circ aGeomCircle (gp_Ax2 (gp::Origin(), anAxis.ReferenceAxis().Direction()), anAxis.RotatorDiskRadius());
-      Handle(Select3D_SensitiveCircle) aCircle = new ManipSensCircle (anOwner, aGeomCircle);
-      aCircle->SetSensitivityFactor (15);
-      theSelection->Add (aCircle);
+      const gp_Circ aGeomCircle (gp_Ax2(gp::Origin(), anAxis.ReferenceAxis().Direction()), anAxis.RotatorDiskRadius());
+      Handle(Select3D_SensitiveCircle) aCircle = new ManipSensCircle(anOwner, aGeomCircle);
+      aCircle->SetSensitivityFactor (aLowSensitivity);
+      theSelection->Add(aCircle);
       // enlarge sensitivity by triangulation
-      Handle(Select3D_SensitiveTriangulation) aTri = new ManipSensTriangulation (anOwner, myAxes[anIt].RotatorDisk().Triangulation(), anAxis.ReferenceAxis().Direction());
+      Handle(Select3D_SensitiveTriangulation) aTri = new ManipSensTriangulation(anOwner, myAxes[anIt].RotatorDisk().Triangulation(), anAxis.ReferenceAxis().Direction());
       theSelection->Add (aTri);
     }
+    break;
   }
-
-  if (aMode == AIS_MM_Scaling || aMode == AIS_MM_None)
+  case AIS_MM_Scaling:
   {
     for (Standard_Integer anIt = 0; anIt < 3; ++anIt)
     {
@@ -1184,21 +1185,19 @@ void AIS_Manipulator::ComputeSelection (const Handle(SelectMgr_Selection)& theSe
       {
         continue;
       }
-      if (aMode != AIS_MM_None)
-      {
-        anOwner = new AIS_ManipulatorOwner (this, anIt, AIS_MM_Scaling, 9);
-      }
+      anOwner = new AIS_ManipulatorOwner(this, anIt, AIS_MM_Scaling, 9);
+
       // define sensitivity by point
-      Handle(Select3D_SensitivePoint) aPnt = new Select3D_SensitivePoint (anOwner, myAxes[anIt].ScalerCubePosition());
-      aPnt->SetSensitivityFactor (15);
+      Handle(Select3D_SensitivePoint) aPnt = new Select3D_SensitivePoint(anOwner, myAxes[anIt].ScalerCubePosition());
+      aPnt->SetSensitivityFactor (aHighSensitivity);
       theSelection->Add (aPnt);
       // enlarge sensitivity by triangulation
-      Handle(Select3D_SensitiveTriangulation) aTri = new Select3D_SensitiveTriangulation (anOwner, myAxes[anIt].ScalerCube().Triangulation(), TopLoc_Location(), Standard_True);
+      Handle(Select3D_SensitiveTriangulation) aTri = new Select3D_SensitiveTriangulation(anOwner, myAxes[anIt].ScalerCube().Triangulation(), TopLoc_Location(), Standard_True);
       theSelection->Add (aTri);
     }
+    break;
   }
-
-  if (aMode == AIS_MM_TranslationPlane || aMode == AIS_MM_None)
+  case AIS_MM_TranslationPlane:
   {
     for (Standard_Integer anIt = 0; anIt < 3; ++anIt)
     {
@@ -1206,28 +1205,33 @@ void AIS_Manipulator::ComputeSelection (const Handle(SelectMgr_Selection)& theSe
       {
         continue;
       }
-      if (aMode != AIS_MM_None)
-      {
-        anOwner = new AIS_ManipulatorOwner(this, anIt, AIS_MM_TranslationPlane, 9);
-      }
+      anOwner = new AIS_ManipulatorOwner(this, anIt, AIS_MM_TranslationPlane, 9);
 
       // define sensitivity by two crossed lines
-      gp_Pnt aP1, aP2;
-      aP1 = myAxes[((anIt + 1) % 3)].TranslatorTipPosition();
-      aP2 = myAxes[((anIt + 2) % 3)].TranslatorTipPosition();
+      Standard_Real aSensitivityOffset = ZoomPersistence() ? aHighSensitivity * (0.5 + M_SQRT2) : 0.0;
+      gp_Pnt aP1 = myAxes[((anIt + 1) % 3)].TranslatorTipPosition().Translated (myAxes[((anIt + 2) % 3)].ReferenceAxis().Direction().XYZ() * aSensitivityOffset);
+      gp_Pnt aP2 = myAxes[((anIt + 2) % 3)].TranslatorTipPosition().Translated (myAxes[((anIt + 1) % 3)].ReferenceAxis().Direction().XYZ() * aSensitivityOffset);
       gp_XYZ aMidP = (aP1.XYZ() + aP2.XYZ()) / 2.0;
+      gp_XYZ anOrig = aMidP.Normalized().Multiplied (aSensitivityOffset);
 
       Handle(Select3D_SensitiveSegment) aLine1 = new Select3D_SensitiveSegment(anOwner, aP1, aP2);
-      aLine1->SetSensitivityFactor(10);
-      theSelection->Add(aLine1);
-      Handle(Select3D_SensitiveSegment) aLine2 = new Select3D_SensitiveSegment(anOwner, gp::Origin(), aMidP);
-      aLine2->SetSensitivityFactor(10);
-      theSelection->Add(aLine2);
+      aLine1->SetSensitivityFactor(aLowSensitivity);
+      theSelection->Add (aLine1);
+      Handle(Select3D_SensitiveSegment) aLine2 = new Select3D_SensitiveSegment(anOwner, anOrig, aMidP);
+      aLine2->SetSensitivityFactor (aLowSensitivity);
+      theSelection->Add (aLine2);
 
       // enlarge sensitivity by triangulation
-      Handle(Select3D_SensitiveTriangulation) aTri = new Select3D_SensitiveTriangulation(anOwner, myAxes[anIt].DraggerSector().Triangulation(), TopLoc_Location(), Standard_True);
-      theSelection->Add(aTri);
+      Handle(Select3D_SensitiveTriangulation) aTri = new Select3D_SensitiveTriangulation(anOwner, myAxes[anIt].DraggerSector().Triangulation(), TopLoc_Location(), Standard_True); 
+      theSelection->Add (aTri);
     }
+    break;
+  }
+  default:
+  {
+    anOwner = new SelectMgr_EntityOwner(this, 5);
+    break;
+  }
   }
 }
 

src/AIS/FILES

@@ -2,6 +2,8 @@ AIS.hxx
 AIS_Animation.cxx
 AIS_Animation.hxx
 AIS_AnimationTimer.hxx
+AIS_AnimationAxisRotation.cxx
+AIS_AnimationAxisRotation.hxx
 AIS_AnimationCamera.cxx
 AIS_AnimationCamera.hxx
 AIS_AnimationObject.cxx
@@ -12,6 +14,8 @@ AIS_Axis.cxx
 AIS_Axis.hxx
 AIS_BadEdgeFilter.cxx
 AIS_BadEdgeFilter.hxx
+AIS_BaseAnimationObject.cxx
+AIS_BaseAnimationObject.hxx
 AIS_C0RegularityFilter.cxx
 AIS_C0RegularityFilter.hxx
 AIS_CameraFrustum.cxx

src/BOPAlgo/BOPAlgo_ShellSplitter.cxx

@@ -248,167 +248,178 @@ void BOPAlgo_ShellSplitter::SplitBlock(BOPTools_ConnexityBlock& aCB)
   //
   // Build the shells
   aItF.Initialize (aLFConnected);
-  for (i = 1; aItF.More() && !bAllFacesTaken; aItF.Next(), ++i) {
+  for (i = 1; aItF.More() && !bAllFacesTaken; aItF.Next(), ++i)
+  {
     const TopoDS_Shape& aFF = aItF.Value();
     if (!AddedFacesMap.Add(aFF)) {
       continue;
     }
     //
     // make a new shell
-    TopoDS_Shell aShellStart;
-    aBB.MakeShell(aShellStart);
-    aBB.Add(aShellStart, aFF);
+    TopoDS_Shell aShell;
+    aBB.MakeShell(aShell);
+    aBB.Add(aShell, aFF);
+
+    aMEFP.Clear();
+    TopExp::MapShapesAndAncestors(aShell, TopAbs_EDGE, TopAbs_FACE, aMEFP);
     //
-    TopTools_ListOfShape aLShells;
-    aLShells.Append(aShellStart);
-    //
-    TopTools_ListIteratorOfListOfShape aItLShells(aLShells);
-    for (; aItLShells.More(); aItLShells.Next()) {
-      TopoDS_Shell& aShell = TopoDS::Shell(aItLShells.ChangeValue());
+    // loop on faces added to Shell; 
+    // add their neighbor faces to Shell and so on
+    aItS.Initialize(aShell);
+    for (; aItS.More(); aItS.Next()) {
+      const TopoDS_Face& aF = (*(TopoDS_Face*)(&aItS.Value()));
+      Standard_Boolean isBoundary = aBoundaryFaces.Contains (aF);
       //
-      aMEFP.Clear();
-      TopExp::MapShapesAndAncestors(aShell, TopAbs_EDGE, TopAbs_FACE, aMEFP);
-      //
-      // loop on faces added to Shell; 
-      // add their neighbor faces to Shell and so on
-      aItS.Initialize(aShell);
-      for (; aItS.More(); aItS.Next()) {
-        const TopoDS_Face& aF = (*(TopoDS_Face*)(&aItS.Value()));
-        Standard_Boolean isBoundary = aBoundaryFaces.Contains (aF);
+      // loop on edges of aF; find a good neighbor face of aF by aE
+      aExp.Init(aF, TopAbs_EDGE);
+      for (; aExp.More(); aExp.Next()) {
+        const TopoDS_Edge& aE = (*(TopoDS_Edge*)(&aExp.Current()));
         //
-        // loop on edges of aF; find a good neighbor face of aF by aE
-        aExp.Init(aF, TopAbs_EDGE);
-        for (; aExp.More(); aExp.Next()) {
-          const TopoDS_Edge& aE = (*(TopoDS_Edge*)(&aExp.Current()));
-          //
-          // proceed only free edges in this shell
-          if (aMEFP.Contains(aE)) {
-            const TopTools_ListOfShape& aLFP = aMEFP.FindFromKey(aE);
-            aNbFP = aLFP.Extent();
-            if (aNbFP > 1) {
-              continue;
-            }
-          }
-          // avoid processing of internal edges
-          anOr = aE.Orientation();
-          if (anOr == TopAbs_INTERNAL) {
+        // proceed only free edges in this shell
+        if (aMEFP.Contains(aE)) {
+          const TopTools_ListOfShape& aLFP = aMEFP.FindFromKey(aE);
+          aNbFP = aLFP.Extent();
+          if (aNbFP > 1) {
             continue;
           }
-          // avoid processing of degenerated edges
-          if (BRep_Tool::Degenerated(aE)) {
+        }
+        // avoid processing of internal edges
+        anOr = aE.Orientation();
+        if (anOr == TopAbs_INTERNAL) {
+          continue;
+        }
+        // avoid processing of degenerated edges
+        if (BRep_Tool::Degenerated(aE)) {
+          continue;
+        }
+        //
+        // candidate faces list
+        const TopTools_ListOfShape& aLF = aEFMap.FindFromKey(aE);
+        aNbLF = aLF.Extent();
+        if (!aNbLF) {
+          continue;
+        }
+        //
+        // prepare for selecting the next face
+        // take only not-processed faces as a candidates
+        BOPTools_ListOfCoupleOfShape aLCSOff;
+        //
+        Standard_Integer aNbWaysInside = 0;
+        TopoDS_Face aSelF;
+        TopTools_ListIteratorOfListOfShape aItLF(aLF);
+        for (; aItLF.More(); aItLF.Next()) {
+          const TopoDS_Face& aFL = (*(TopoDS_Face*)(&aItLF.Value()));
+          if (aF.IsSame(aFL) || AddedFacesMap.Contains(aFL)) {
             continue;
           }
           //
-          // candidate faces list
-          const TopTools_ListOfShape& aLF = aEFMap.FindFromKey(aE);
-          aNbLF = aLF.Extent();
-          if (!aNbLF) {
+          // find current edge in the face
+          if (!BOPTools_AlgoTools::GetEdgeOff(aE, aFL, aEL)) {
             continue;
           }
           //
-          // prepare for selecting the next face
-          // take only not-processed faces as a candidates
-          BOPTools_ListOfCoupleOfShape aLCSOff;
-          //
-          Standard_Integer aNbWaysInside = 0;
-          TopoDS_Face aSelF;
-          TopTools_ListIteratorOfListOfShape aItLF(aLF);
-          for (; aItLF.More(); aItLF.Next()) {
-            const TopoDS_Face& aFL = (*(TopoDS_Face*)(&aItLF.Value()));
-            if (aF.IsSame(aFL) || AddedFacesMap.Contains(aFL)) {
-              continue;
-            }
-            //
-            // find current edge in the face
-            if (!BOPTools_AlgoTools::GetEdgeOff(aE, aFL, aEL)) {
-              continue;
-            }
-            //
-            if (isBoundary && !aBoundaryFaces.Contains (aFL))
-            {
-              ++aNbWaysInside;
-              aSelF = aFL;
-            }
-            aCSOff.SetShape1(aEL);
-            aCSOff.SetShape2(aFL);
-            aLCSOff.Append(aCSOff);
-          }//for (; aItLF.More(); aItLF.Next()) { 
-          //
-          aNbOff = aLCSOff.Extent();
-          if (!aNbOff){
-            continue;
-          }
-          //
-          // among all the adjacent faces chose one with the minimal
-          // angle to the current one
-          if (!isBoundary || aNbWaysInside != 1)
+          if (isBoundary && !aBoundaryFaces.Contains (aFL))
           {
-            if (aNbOff == 1) {
-              aSelF = (*(TopoDS_Face*)(&aLCSOff.First().Shape2()));
-            }
-            else if (aNbOff > 1) {
-              BOPTools_AlgoTools::GetFaceOff(aE, aF, aLCSOff, aSelF, aContext);
-            }
+            ++aNbWaysInside;
+            aSelF = aFL;
           }
-          //
-          if (!aSelF.IsNull() && AddedFacesMap.Add(aSelF)) {
-            aBB.Add(aShell, aSelF);
-            TopExp::MapShapesAndAncestors(aSelF, TopAbs_EDGE, TopAbs_FACE, aMEFP);
-          }
-        } // for (; aExp.More(); aExp.Next()) {
-      } // for (; aItS.More(); aItS.Next()) {
-      //
-      // split the shell on multi-connected edges
-      TopTools_ListOfShape aLShSp;
-      RefineShell(aShell, aMEFP, aLShSp);
-      //
-      // collect the not closed shells for further processing
-      TopTools_ListOfShape aLShNC;
-      //
-      TopTools_ListIteratorOfListOfShape aItLShSp(aLShSp);
-      for (; aItLShSp.More(); aItLShSp.Next()) {
-        TopoDS_Shell& aShSp = *((TopoDS_Shell*)&aItLShSp.Value());
+          aCSOff.SetShape1(aEL);
+          aCSOff.SetShape2(aFL);
+          aLCSOff.Append(aCSOff);
+        }//for (; aItLF.More(); aItLF.Next()) { 
         //
-        if (BRep_Tool::IsClosed(aShSp)) {
-          aShSp.Closed(Standard_True);
-          myLoops.Append(aShSp);
+        aNbOff = aLCSOff.Extent();
+        if (!aNbOff){
+          continue;
         }
-        else {
-          aLShNC.Append(aShSp);
-        }
-      }
-      //
-      bAllFacesTaken = (AddedFacesMap.Extent() == aNbShapes);
-      if (bAllFacesTaken) {
-        break;
-      }
-      //
-      if (aLShSp.Extent() == 1) {
-        // not further processing of not closed shells is needed,
-        // as it will not bring any new results
-        continue;
-      }
-      //
-      Standard_Integer aNbShNC = aLShNC.Extent();
-      if (aNbShNC == 1) {
-        // try to complete the shell with other faces
-        aLShells.Append(aLShNC);
-      }
-      else if (aNbShNC > 1) {
-        // remove th faces of not closed shells from the map of processed faces
-        // and try to rebuild the shells using all not processed faces,
-        // because faces of one shell might be needed for building the other
-        TopTools_ListIteratorOfListOfShape aItLShNC(aLShNC);
-        for (; aItLShNC.More(); aItLShNC.Next()) {
-          TopoDS_Iterator aItNC(aItLShNC.Value());
-          for (; aItNC.More(); aItNC.Next()) {
-            AddedFacesMap.Remove(aItNC.Value());
+        //
+        // among all the adjacent faces chose one with the minimal
+        // angle to the current one
+        if (!isBoundary || aNbWaysInside != 1)
+        {
+          if (aNbOff == 1) {
+            aSelF = (*(TopoDS_Face*)(&aLCSOff.First().Shape2()));
+          }
+          else if (aNbOff > 1) {
+            BOPTools_AlgoTools::GetFaceOff(aE, aF, aLCSOff, aSelF, aContext);
           }
         }
+        //
+        if (!aSelF.IsNull() && AddedFacesMap.Add(aSelF)) {
+          aBB.Add(aShell, aSelF);
+          TopExp::MapShapesAndAncestors(aSelF, TopAbs_EDGE, TopAbs_FACE, aMEFP);
+        }
+      } // for (; aExp.More(); aExp.Next()) {
+    } // for (; aItS.More(); aItS.Next()) {
+    //
+    // split the shell on multi-connected edges
+    TopTools_ListOfShape aLShSp;
+    RefineShell(aShell, aMEFP, aLShSp);
+    //
+    // collect the not closed shells for further processing
+    TopTools_ListOfShape aLShNC;
+    //
+    TopTools_ListIteratorOfListOfShape aItLShSp(aLShSp);
+    for (; aItLShSp.More(); aItLShSp.Next()) {
+      TopoDS_Shell& aShSp = *((TopoDS_Shell*)&aItLShSp.Value());
+      //
+      if (BRep_Tool::IsClosed(aShSp)) {
+        aShSp.Closed(Standard_True);
+        myLoops.Append(aShSp);
+      }
+      else {
+        aLShNC.Append(aShSp);
+      }
+    }
+    //
+    bAllFacesTaken = (AddedFacesMap.Extent() == aNbShapes);
+    if (bAllFacesTaken) {
+      break;
+    }
+    //
+    if (aLShSp.Extent() == 1) {
+      // not further processing of not closed shells is needed,
+      // as it will not bring any new results
+      continue;
+    }
+    //
+    
+    // remove th faces of not closed shells from the map of processed faces
+    // and try to rebuild the shells using all not processed faces,
+    // because faces of one shell might be needed for building the other
+    TopTools_ListIteratorOfListOfShape aItLShNC(aLShNC);
+    for (; aItLShNC.More(); aItLShNC.Next()) 
+    {
+      TopoDS_Iterator aItNC(aItLShNC.Value());
+      for (; aItNC.More(); aItNC.Next()) 
+      {
+        AddedFacesMap.Remove(aItNC.Value());
       }
     }
   } // for (; aItF.More(); aItF.Next()) {
 }
+
+//=======================================================================
+//function : FindShape
+//purpose  : 
+//=======================================================================
+TopoDS_Shape FindShape (const TopoDS_Shape& theShapeToFind,
+                        const TopoDS_Shape& theShape)
+{
+  TopoDS_Shape aRes;
+  TopExp_Explorer anExp(theShape, theShapeToFind.ShapeType());
+  for (; anExp.More(); anExp.Next())
+  {
+    const TopoDS_Shape& aShape = anExp.Current();
+    if (aShape.IsSame(theShapeToFind))
+    {
+      aRes = aShape;
+      break;
+    }
+  }
+  return aRes;
+}
+
 //=======================================================================
 //function : RefineShell
 //purpose  : 
@@ -434,6 +445,21 @@ void RefineShell(TopoDS_Shell& theShell,
       aMEStop.Add(aE);
       continue;
     }
+
+    if (aLF.Extent() == 2)
+    {
+      const TopoDS_Face& aF1 = TopoDS::Face(aLF.First());
+      const TopoDS_Face& aF2 = TopoDS::Face(aLF.Last());
+
+      TopoDS_Shape aE1 = FindShape(aE, aF1);
+      TopoDS_Shape aE2 = FindShape(aE, aF2);
+
+      if (aE1.Orientation() == aE2.Orientation())
+      {
+        aMEStop.Add(aE);
+        continue;
+      }
+    }
     //
     // check for internal edges - count faces, in which the edge
     // is internal, twice

src/BOPTools/BOPTools_PairSelector.hxx

@@ -60,7 +60,7 @@ public: //! @name public interfaces
   //! Clears the indices
   void Clear()
   {
-    myPairs.Clear();
+    myPairs.clear();
   }
 
   //! Sorts the indices

src/BRepBlend/BRepBlend_CSWalking.hxx

@@ -51,7 +51,7 @@ public:
   
   Standard_EXPORT BRepBlend_CSWalking(const Handle(Adaptor3d_Curve)& Curv, const Handle(Adaptor3d_Surface)& Surf, const Handle(Adaptor3d_TopolTool)& Domain);
   
-  Standard_EXPORT void Perform (Blend_CSFunction& F, const Standard_Real Pdep, const Standard_Real Pmax, const Standard_Real MaxStep, const Standard_Real TolGuide, const math_Vector& Soldep, const Standard_Real Tolesp, const Standard_Real Fleche, const Standard_Boolean Appro = Standard_False);
+  Standard_EXPORT void Perform (Blend_CSFunction& F, const Standard_Real Pdep, const Standard_Real Pmax, const Standard_Real MaxStep, const Standard_Real Tol3d, const Standard_Real TolGuide, const math_Vector& Soldep, const Standard_Real Fleche, const Standard_Boolean Appro = Standard_False);
   
   Standard_EXPORT Standard_Boolean Complete (Blend_CSFunction& F, const Standard_Real Pmin);
   
@@ -80,7 +80,7 @@ private:
   Handle(Adaptor3d_Surface) surf;
   Handle(Adaptor3d_Curve) curv;
   Handle(Adaptor3d_TopolTool) domain;
-  Standard_Real tolesp;
+  Standard_Real tolpoint3d;
   Standard_Real tolgui;
   Standard_Real pasmax;
   Standard_Real fleche;

src/BRepBlend/BRepBlend_RstRstLineBuilder.cxx

@@ -173,7 +173,7 @@ BRepBlend_RstRstLineBuilder::BRepBlend_RstRstLineBuilder
  done(Standard_False), sol(1, 2), surf1(Surf1),
  domain1(Domain1), surf2(Surf2),
  domain2(Domain2), rst1(Rst1), rst2(Rst2),
- tolesp(0.0), tolgui(0.0), pasmax(0.0),
+ tolpoint3d(0.0), tolgui(0.0), pasmax(0.0),
  fleche(0.0), param(0.0), rebrou(Standard_False),
  iscomplete(Standard_False), comptra(Standard_False), sens(0.0),
  decrochdeb(Blend_NoDecroch), decrochfin(Blend_NoDecroch)
@@ -193,9 +193,9 @@ void BRepBlend_RstRstLineBuilder::Perform(Blend_RstRstFunction&   Func,
 					  const Standard_Real     Pdep,
 					  const Standard_Real     Pmax,
 					  const Standard_Real     MaxStep,
+            const Standard_Real     Tol3d,
 					  const Standard_Real     TolGuide,
 					  const math_Vector&      ParDep,
-					  const Standard_Real     Tolesp,
 					  const Standard_Real     Fleche,
 					  const Standard_Boolean  Appro) 
 {
@@ -203,7 +203,7 @@ void BRepBlend_RstRstLineBuilder::Perform(Blend_RstRstFunction&   Func,
   iscomplete = Standard_False;
   comptra    = Standard_False;
   line       = new BRepBlend_Line();
-  tolesp     = Abs(Tolesp);
+  tolpoint3d   = Tol3d;
   tolgui     = Abs(TolGuide);
   fleche     = Abs(Fleche);
   rebrou     = Standard_False;
@@ -225,7 +225,7 @@ void BRepBlend_RstRstLineBuilder::Perform(Blend_RstRstFunction&   Func,
     TopAbs_State siturst1, siturst2;
     Blend_DecrochStatus decroch;
     math_Vector tolerance(1, 2), infbound(1, 2), supbound(1, 2);
-    Func.GetTolerance(tolerance, tolesp);
+    Func.GetTolerance(tolerance, tolpoint3d);
     Func.GetBounds(infbound, supbound);
     math_FunctionSetRoot rsnld(Func, tolerance, 30);
     
@@ -258,9 +258,9 @@ void BRepBlend_RstRstLineBuilder::Perform(Blend_RstRstFunction&   Func,
   U = previousP.ParameterOnC1();
   V = previousP.ParameterOnC2();
   BRepBlend_Extremity ptf1 (previousP.PointOnC1(),
-			    U, previousP.Parameter(),tolesp);
+			    U, previousP.Parameter(),tolpoint3d);
   BRepBlend_Extremity ptf2 (previousP.PointOnC2(),
-			    V, previousP.Parameter(),tolesp);
+			    V, previousP.Parameter(),tolpoint3d);
   if (!previousP.IsTangencyPoint()) {
     ptf1.SetTangent(previousP.TangentOnC1());
     ptf2.SetTangent(previousP.TangentOnC2());
@@ -291,7 +291,7 @@ Standard_Boolean BRepBlend_RstRstLineBuilder::PerformFirstSection
  const Standard_Real     Pdep,
  const Standard_Real     Pmax,
  const math_Vector&      ParDep,
- const Standard_Real     Tolesp,
+ const Standard_Real     Tol3d,
  const Standard_Real     TolGuide,
  const Standard_Boolean  RecRst1,
  const Standard_Boolean  RecP1,
@@ -304,7 +304,7 @@ Standard_Boolean BRepBlend_RstRstLineBuilder::PerformFirstSection
   iscomplete = Standard_False;
   comptra    = Standard_False;
   line       = new BRepBlend_Line();
-  tolesp     = Abs(Tolesp);
+  tolpoint3d   = Tol3d;
   tolgui     = Abs(TolGuide);
   rebrou     = Standard_False;
   
@@ -327,7 +327,7 @@ Standard_Boolean BRepBlend_RstRstLineBuilder::PerformFirstSection
   wp1   = wp2 = wrst1 = wrst2 = Pmax;
   param = Pdep;
   Func.Set(param);
-  Func.GetTolerance(tolerance, tolesp);
+  Func.GetTolerance(tolerance, tolpoint3d);
   Func.GetBounds(infbound, supbound);
 
   math_FunctionSetRoot rsnld(Func, tolerance, 30);
@@ -573,7 +573,7 @@ void BRepBlend_RstRstLineBuilder::InternalPerform(Blend_RstRstFunction&   Func,
 
   //IntSurf_Transition Tline, Tarc;
 
-  Func.GetTolerance(tolerance, tolesp);
+  Func.GetTolerance(tolerance, tolpoint3d);
   Func.GetBounds(infbound, supbound);
 
   math_FunctionSetRoot rsnld(Func, tolerance, 30);
@@ -595,14 +595,14 @@ void BRepBlend_RstRstLineBuilder::InternalPerform(Blend_RstRstFunction&   Func,
     if (rsnld.IsDone()) {
       rsnld.Root(sol);
       Blend_Point bp1;
-      if(BBPP(param, Func, sol, tolesp, bp1)){
+      if(BBPP(param, Func, sol, tolpoint3d, bp1)){
 	Standard_Real dw = 1.e-10;
 	Func.Set(param + dw);
 	rsnld.Perform(Func, parinit, infbound, supbound);
 	if (rsnld.IsDone()) {
 	  rsnld.Root(sol);
 	  Blend_Point bp2;
-	  if(BBPP(param + dw, Func, sol, tolesp, bp2)){
+	  if(BBPP(param + dw, Func, sol, tolpoint3d, bp2)){
 	    tracederiv(Func, bp1, bp2);
 	  }
 	}
@@ -854,7 +854,7 @@ void BRepBlend_RstRstLineBuilder::InternalPerform(Blend_RstRstFunction&   Func,
 	  Arrive = Standard_True;
 	  Extrst1.SetValue(previousP.PointOnC1(),
 			   previousP.ParameterOnC1(),
-			   previousP.Parameter(), tolesp);
+			   previousP.Parameter(), tolpoint3d);
 	  MakeExtremity(Extrst2, Standard_False, rst2, sol(2), IsVtxrst2, Vtxrst2);
 	  // Show that end is on Bound.
 	}
@@ -873,10 +873,10 @@ void BRepBlend_RstRstLineBuilder::InternalPerform(Blend_RstRstFunction&   Func,
 	if (Abs(stepw) < tolgui) {
 	  Extrst1.SetValue(previousP.PointOnC1(),
 			   previousP.ParameterOnC1(),
-			   previousP.Parameter(), tolesp);
+			   previousP.Parameter(), tolpoint3d);
 	  Extrst2.SetValue(previousP.PointOnC2(),
 			   previousP.ParameterOnC2(),
-			   previousP.Parameter(), tolesp);
+			   previousP.Parameter(), tolpoint3d);
 	  Arrive = Standard_True;
 #ifdef OCCT_DEBUG
 	  if (line->NbPoints()>=2) {
@@ -913,7 +913,7 @@ void BRepBlend_RstRstLineBuilder::InternalPerform(Blend_RstRstFunction&   Func,
 	  Arrive = Standard_True;
 	  Extrst1.SetValue(previousP.PointOnC1(),
 			   previousP.ParameterOnC1(),
-			   previousP.Parameter(), tolesp);
+			   previousP.Parameter(), tolpoint3d);
 	  MakeExtremity(Extrst2, Standard_False, rst2, sol(2), IsVtxrst2, Vtxrst2);
 	  // Indicate that end is on Bound.
 	}
@@ -993,10 +993,10 @@ void BRepBlend_RstRstLineBuilder::InternalPerform(Blend_RstRstFunction&   Func,
 #endif
 	Extrst1.SetValue(previousP.PointOnC1(),
 			 previousP.ParameterOnC1(),
-			 previousP.Parameter(), tolesp);
+			 previousP.Parameter(), tolpoint3d);
 	Extrst2.SetValue(previousP.PointOnC2(),
 			 previousP.ParameterOnC2(),
-			 previousP.Parameter(), tolesp);
+			 previousP.Parameter(), tolpoint3d);
 	Arrive = Standard_True;
       }
       break;
@@ -1029,7 +1029,7 @@ Standard_Boolean BRepBlend_RstRstLineBuilder::Recadre1(Blend_RstRstFunction&
 						       Handle(Adaptor3d_HVertex)& Vtx) 
 {
   math_Vector toler(1, 3), infb(1, 3), supb(1, 3);
-  Finv.GetTolerance(toler, tolesp);
+  Finv.GetTolerance(toler, tolpoint3d);
   Finv.GetBounds(infb, supb);
   Solinv(1) = param;
   Solinv(2) = sol(2);
@@ -1049,7 +1049,7 @@ Standard_Boolean BRepBlend_RstRstLineBuilder::Recadre1(Blend_RstRstFunction&
 
   // It is necessary to check if the function value meets the
   // second restriction
-  if (Finv.IsSolution(Solinv, tolesp)) {
+  if (Finv.IsSolution(Solinv, tolpoint3d)) {
     Standard_Real w = Solinv(2);
     if(w < rst2->FirstParameter() - toler(2)||
        w > rst2->LastParameter() + toler(2)){
@@ -1079,7 +1079,7 @@ Standard_Boolean BRepBlend_RstRstLineBuilder::Recadre1(Blend_RstRstFunction&
 
     math_Vector infbound(1, 2), supbound(1, 2);
     math_Vector parinit(1, 2), tolerance(1, 2);
-    Func.GetTolerance(tolerance, tolesp);
+    Func.GetTolerance(tolerance, tolpoint3d);
     Func.GetBounds(infbound, supbound);
 
     math_FunctionSetRoot rsnld2(Func, tolerance, 30);
@@ -1112,7 +1112,7 @@ Standard_Boolean BRepBlend_RstRstLineBuilder::Recadre2(Blend_RstRstFunction&
 						       Handle(Adaptor3d_HVertex)& Vtx) 
 {
   math_Vector toler(1, 3), infb(1, 3), supb(1, 3);
-  Finv.GetTolerance(toler, tolesp);
+  Finv.GetTolerance(toler, tolpoint3d);
   Finv.GetBounds(infb, supb);
   Solinv(1) = param;
   Solinv(2) = sol(1);
@@ -1130,7 +1130,7 @@ Standard_Boolean BRepBlend_RstRstLineBuilder::Recadre2(Blend_RstRstFunction&
   rsnld.Root(Solinv);
 
   // It is necessary to check the value of the function
-  if (Finv.IsSolution(Solinv, tolesp)) {
+  if (Finv.IsSolution(Solinv, tolpoint3d)) {
     Standard_Real w = Solinv(2);
     if(w < rst1->FirstParameter() - toler(2)||
        w > rst1->LastParameter() + toler(2)){
@@ -1159,7 +1159,7 @@ Standard_Boolean BRepBlend_RstRstLineBuilder::Recadre2(Blend_RstRstFunction&
    
     math_Vector infbound(1, 2), supbound(1, 2);
     math_Vector parinit(1,2), tolerance(1,2);
-    Func.GetTolerance(tolerance, tolesp);
+    Func.GetTolerance(tolerance, tolpoint3d);
     Func.GetBounds(infbound, supbound);
 
     math_FunctionSetRoot rsnld2(Func, tolerance, 30);
@@ -1199,7 +1199,7 @@ Standard_Boolean BRepBlend_RstRstLineBuilder::Recadre1(Blend_CurvPointFuncInv&
 
   FinvP.Set(thepoint);
   math_Vector toler(1,2), infb(1, 2), supb(1, 2);
-  FinvP.GetTolerance(toler, tolesp);
+  FinvP.GetTolerance(toler, tolpoint3d);
   FinvP.GetBounds(infb, supb);
   Solinv(1) = param;
   Solinv(2) = sol(2);
@@ -1214,7 +1214,7 @@ Standard_Boolean BRepBlend_RstRstLineBuilder::Recadre1(Blend_CurvPointFuncInv&
   }
   rsnld.Root(Solinv);
   
-  if(FinvP.IsSolution(Solinv, tolesp)){
+  if(FinvP.IsSolution(Solinv, tolpoint3d)){
     gp_Pnt2d p2drst2  = rst2->Value(Solinv(2));
     TopAbs_State situ = domain2->Classify(p2drst2, toler(2), 0);
     if ((situ != TopAbs_IN) && (situ != TopAbs_ON)) {
@@ -1267,7 +1267,7 @@ Standard_Boolean BRepBlend_RstRstLineBuilder::Recadre2(Blend_CurvPointFuncInv&
 
   FinvP.Set(thepoint);
   math_Vector toler(1,2), infb(1, 2), supb(1, 2);
-  FinvP.GetTolerance(toler, tolesp);
+  FinvP.GetTolerance(toler, tolpoint3d);
   FinvP.GetBounds(infb, supb);
   Solinv(1) = param;
   Solinv(2) = sol(1);
@@ -1282,7 +1282,7 @@ Standard_Boolean BRepBlend_RstRstLineBuilder::Recadre2(Blend_CurvPointFuncInv&
   }
   rsnld.Root(Solinv);
   
-  if(FinvP.IsSolution(Solinv, tolesp)){
+  if(FinvP.IsSolution(Solinv, tolpoint3d)){
     gp_Pnt2d p2drst1  = rst1->Value(Solinv(2));
     TopAbs_State situ = domain1->Classify(p2drst1, toler(2), 0);
     if ((situ != TopAbs_IN) && (situ != TopAbs_ON)) {
@@ -1378,7 +1378,7 @@ void BRepBlend_RstRstLineBuilder::MakeExtremity(BRepBlend_Extremity&
   if (OnFirst) {
     Extrem.SetValue(previousP.PointOnC1(),
 		    sol(1),
-		    previousP.Parameter(), tolesp);
+		    previousP.Parameter(), tolpoint3d);
     if (!previousP.IsTangencyPoint()) 
       Extrem.SetTangent(previousP.TangentOnC1());
     Iter = domain1;
@@ -1386,7 +1386,7 @@ void BRepBlend_RstRstLineBuilder::MakeExtremity(BRepBlend_Extremity&
   else {
     Extrem.SetValue(previousP.PointOnC2(),
 		    sol(2),
-		    previousP.Parameter(), tolesp);
+		    previousP.Parameter(), tolpoint3d);
     if (!previousP.IsTangencyPoint()) 
       Extrem.SetTangent(previousP.TangentOnC1());
     Iter = domain2;
@@ -1453,12 +1453,13 @@ Blend_Status BRepBlend_RstRstLineBuilder::CheckDeflectionOnRst1(const Blend_Poin
   Norme = Corde.SquareMagnitude();
   if (!prevpointistangent) prevNorme = prevTg.SquareMagnitude();
 
-  if (Norme <= tolesp * tolesp) {
+  const Standard_Real toler3d = 0.01 * tolpoint3d;
+  if (Norme <= toler3d * toler3d) {
     // it can be necessary to force the same point
     return Blend_SamePoints;
   }
   if(!prevpointistangent){
-    if (prevNorme <= tolesp * tolesp) {
+    if (prevNorme <= toler3d * toler3d) {
       return Blend_SamePoints;
     }
     Cosi = sens * Corde * prevTg;
@@ -1530,12 +1531,13 @@ Blend_Status BRepBlend_RstRstLineBuilder::CheckDeflectionOnRst2(const Blend_Poin
   Norme = Corde.SquareMagnitude();
   if (!prevpointistangent) prevNorme = prevTg.SquareMagnitude();
 
-  if (Norme <= tolesp * tolesp){
+  const Standard_Real toler3d = 0.01 * tolpoint3d;
+  if (Norme <= toler3d * toler3d){
     // it can be necessary to force the same point
     return Blend_SamePoints;
   }
   if (!prevpointistangent) {
-    if (prevNorme <= tolesp * tolesp) {
+    if (prevNorme <= toler3d * toler3d) {
       return Blend_SamePoints;
     }
     Cosi = sens * Corde * prevTg;
@@ -1597,7 +1599,7 @@ Blend_Status BRepBlend_RstRstLineBuilder::TestArret(Blend_RstRstFunction& Func,
   IntSurf_TypeTrans trarst1 = IntSurf_Undecided, trarst2 = IntSurf_Undecided;
   Blend_Point curpoint;
 
-  if (Func.IsSolution(sol, tolesp)) {
+  if (Func.IsSolution(sol, tolpoint3d)) {
     Standard_Boolean curpointistangent = Func.IsTangencyPoint();
     ptrst1   = Func.PointOnRst1();
     ptrst2   = Func.PointOnRst2();
@@ -1644,7 +1646,7 @@ Blend_Status BRepBlend_RstRstLineBuilder::TestArret(Blend_RstRstFunction& Func,
       Standard_Real testra = tg2drst1.Dot(tg2drstref);
       TopAbs_Orientation Or = domain1->Orientation(rst1);
 
-      if (Abs(testra) > tolesp) {
+      if (Abs(testra) > tolpoint3d) {
 	if (testra < 0.) {
           trarst1 = ConvOrToTra(TopAbs::Reverse(Or));
 	}
@@ -1656,7 +1658,7 @@ Blend_Status BRepBlend_RstRstLineBuilder::TestArret(Blend_RstRstFunction& Func,
 	testra = tg2drst2.Dot(tg2drstref);
 
 	Or = domain2->Orientation(rst2);
-	if (Abs(testra) > tolesp) {
+	if (Abs(testra) > tolpoint3d) {
 	  if (testra < 0.) {
 	    trarst2 = ConvOrToTra(TopAbs::Reverse(Or));
 	  }
@@ -1705,7 +1707,7 @@ Standard_Boolean BRepBlend_RstRstLineBuilder::CheckInside(Blend_RstRstFunction&
 {
 //  Standard_Boolean inside = Standard_True;
   math_Vector tolerance(1, 2);
-  Func.GetTolerance(tolerance, tolesp);
+  Func.GetTolerance(tolerance, tolpoint3d);
 
   //face pcurve 1.
   Standard_Real v = sol(1);

src/BRepBlend/BRepBlend_RstRstLineBuilder.hxx

@@ -72,9 +72,9 @@ public:
   
   Standard_EXPORT BRepBlend_RstRstLineBuilder(const Handle(Adaptor3d_Surface)& Surf1, const Handle(Adaptor2d_Curve2d)& Rst1, const Handle(Adaptor3d_TopolTool)& Domain1, const Handle(Adaptor3d_Surface)& Surf2, const Handle(Adaptor2d_Curve2d)& Rst2, const Handle(Adaptor3d_TopolTool)& Domain2);
   
-  Standard_EXPORT void Perform (Blend_RstRstFunction& Func, Blend_SurfCurvFuncInv& Finv1, Blend_CurvPointFuncInv& FinvP1, Blend_SurfCurvFuncInv& Finv2, Blend_CurvPointFuncInv& FinvP2, const Standard_Real Pdep, const Standard_Real Pmax, const Standard_Real MaxStep, const Standard_Real TolGuide, const math_Vector& Soldep, const Standard_Real Tolesp, const Standard_Real Fleche, const Standard_Boolean Appro = Standard_False);
+  Standard_EXPORT void Perform (Blend_RstRstFunction& Func, Blend_SurfCurvFuncInv& Finv1, Blend_CurvPointFuncInv& FinvP1, Blend_SurfCurvFuncInv& Finv2, Blend_CurvPointFuncInv& FinvP2, const Standard_Real Pdep, const Standard_Real Pmax, const Standard_Real MaxStep, const Standard_Real Tol3d, const Standard_Real TolGuide, const math_Vector& Soldep, const Standard_Real Fleche, const Standard_Boolean Appro = Standard_False);
   
-  Standard_EXPORT Standard_Boolean PerformFirstSection (Blend_RstRstFunction& Func, Blend_SurfCurvFuncInv& Finv1, Blend_CurvPointFuncInv& FinvP1, Blend_SurfCurvFuncInv& Finv2, Blend_CurvPointFuncInv& FinvP2, const Standard_Real Pdep, const Standard_Real Pmax, const math_Vector& Soldep, const Standard_Real Tolesp, const Standard_Real TolGuide, const Standard_Boolean RecRst1, const Standard_Boolean RecP1, const Standard_Boolean RecRst2, const Standard_Boolean RecP2, Standard_Real& Psol, math_Vector& ParSol);
+  Standard_EXPORT Standard_Boolean PerformFirstSection (Blend_RstRstFunction& Func, Blend_SurfCurvFuncInv& Finv1, Blend_CurvPointFuncInv& FinvP1, Blend_SurfCurvFuncInv& Finv2, Blend_CurvPointFuncInv& FinvP2, const Standard_Real Pdep, const Standard_Real Pmax, const math_Vector& Soldep, const Standard_Real Tol3d, const Standard_Real TolGuide, const Standard_Boolean RecRst1, const Standard_Boolean RecP1, const Standard_Boolean RecRst2, const Standard_Boolean RecP2, Standard_Real& Psol, math_Vector& ParSol);
   
   Standard_EXPORT Standard_Boolean Complete (Blend_RstRstFunction& Func, Blend_SurfCurvFuncInv& Finv1, Blend_CurvPointFuncInv& FinvP1, Blend_SurfCurvFuncInv& Finv2, Blend_CurvPointFuncInv& FinvP2, const Standard_Real Pmin);
   
@@ -134,7 +134,7 @@ private:
   Handle(Adaptor3d_TopolTool) domain2;
   Handle(Adaptor2d_Curve2d) rst1;
   Handle(Adaptor2d_Curve2d) rst2;
-  Standard_Real tolesp;
+  Standard_Real tolpoint3d;
   Standard_Real tolgui;
   Standard_Real pasmax;
   Standard_Real fleche;

src/BRepBlend/BRepBlend_SurfRstLineBuilder.cxx

@@ -210,7 +210,7 @@ BRepBlend_SurfRstLineBuilder::BRepBlend_SurfRstLineBuilder
  const Handle(Adaptor3d_TopolTool)& Domain2):
  done(Standard_False), sol(1, 3), surf1(Surf1),
  domain1(Domain1), surf2(Surf2), rst(Rst),
- domain2(Domain2), tolesp(0.0), tolgui(0.0),
+ domain2(Domain2), tolpoint3d(0.0), tolpoint2d(0.0), tolgui(0.0),
  pasmax(0.0), fleche(0.0), param(0.0),
  rebrou(Standard_False), iscomplete(Standard_False),
  comptra(Standard_False), sens(0.0),
@@ -230,9 +230,10 @@ void BRepBlend_SurfRstLineBuilder::Perform(Blend_SurfRstFunction&  Func,
 					   const Standard_Real     Pdep,
 					   const Standard_Real     Pmax,
 					   const Standard_Real     MaxStep,
+             const Standard_Real     Tol3d,
+             const Standard_Real     Tol2d,
 					   const Standard_Real     TolGuide,
 					   const math_Vector&      ParDep,
-					   const Standard_Real     Tolesp,
 					   const Standard_Real     Fleche,
 					   const Standard_Boolean  Appro) 
 {
@@ -240,7 +241,8 @@ void BRepBlend_SurfRstLineBuilder::Perform(Blend_SurfRstFunction&  Func,
   iscomplete = Standard_False;
   comptra = Standard_False;
   line = new BRepBlend_Line();
-  tolesp = Abs(Tolesp);
+  tolpoint3d = Tol3d;
+  tolpoint2d = Tol2d;
   tolgui = Abs(TolGuide);
   fleche = Abs(Fleche);
   rebrou = Standard_False;
@@ -262,7 +264,7 @@ void BRepBlend_SurfRstLineBuilder::Perform(Blend_SurfRstFunction&  Func,
     TopAbs_State siturst,situs;
     Standard_Boolean decroch;
     math_Vector tolerance(1,3),infbound(1,3),supbound(1,3);
-    Func.GetTolerance(tolerance,tolesp);
+    Func.GetTolerance(tolerance,tolpoint3d);
     Func.GetBounds(infbound,supbound);
     math_FunctionSetRoot rsnld(Func,tolerance,30);
     
@@ -296,9 +298,9 @@ void BRepBlend_SurfRstLineBuilder::Perform(Blend_SurfRstFunction&  Func,
 //  W = previousP.ParameterOnC();
   
   BRepBlend_Extremity ptf1(previousP.PointOnS(),
-			   U,V,previousP.Parameter(),tolesp);
+			   U,V,previousP.Parameter(),tolpoint3d);
   BRepBlend_Extremity ptf2(previousP.PointOnC(),
-			   U,V,previousP.Parameter(),tolesp);
+			   U,V,previousP.Parameter(),tolpoint3d);
   if (!previousP.IsTangencyPoint()) {
     ptf1.SetTangent(previousP.TangentOnS());
     ptf2.SetTangent(previousP.TangentOnC());
@@ -327,7 +329,8 @@ Standard_Boolean BRepBlend_SurfRstLineBuilder::PerformFirstSection
  const Standard_Real     Pdep,
  const Standard_Real     Pmax,
  const math_Vector&      ParDep,
- const Standard_Real     Tolesp,
+ const Standard_Real     Tol3d,
+ const Standard_Real     Tol2d,
  const Standard_Real     TolGuide,
  const Standard_Boolean  RecRst,
  const Standard_Boolean  RecP,
@@ -339,7 +342,8 @@ Standard_Boolean BRepBlend_SurfRstLineBuilder::PerformFirstSection
   iscomplete = Standard_False;
   comptra = Standard_False;
   line = new BRepBlend_Line();
-  tolesp = Abs(Tolesp);
+  tolpoint3d = Tol3d;
+  tolpoint2d = Tol2d;
   tolgui = Abs(TolGuide);
   rebrou = Standard_False;
   
@@ -362,7 +366,7 @@ Standard_Boolean BRepBlend_SurfRstLineBuilder::PerformFirstSection
   wp = wrst = ws = Pmax;
   param = Pdep;
   Func.Set(param);
-  Func.GetTolerance(tolerance,tolesp);
+  Func.GetTolerance(tolerance,tolpoint3d);
   Func.GetBounds(infbound,supbound);
 
   math_FunctionSetRoot rsnld(Func,tolerance,30);
@@ -536,7 +540,7 @@ void BRepBlend_SurfRstLineBuilder::InternalPerform(Blend_SurfRstFunction&  Func,
 
   //IntSurf_Transition Tline,Tarc;
 
-  Func.GetTolerance(tolerance,tolesp);
+  Func.GetTolerance(tolerance,tolpoint3d);
   Func.GetBounds(infbound,supbound);
 
   math_FunctionSetRoot rsnld(Func,tolerance,30);
@@ -558,14 +562,14 @@ void BRepBlend_SurfRstLineBuilder::InternalPerform(Blend_SurfRstFunction&  Func,
     if (rsnld.IsDone()) {
       rsnld.Root(sol);
       Blend_Point bp1;
-      if(BBPP(param,Func,sol,tolesp,bp1)){
+      if(BBPP(param,Func,sol,tolpoint3d,bp1)){
 	Standard_Real dw = 1.e-10;
 	Func.Set(param+dw);
 	rsnld.Perform(Func,parinit,infbound,supbound);
 	if (rsnld.IsDone()) {
 	  rsnld.Root(sol);
 	  Blend_Point bp2;
-	  if(BBPP(param+dw,Func,sol,tolesp,bp2)){
+	  if(BBPP(param+dw,Func,sol,tolpoint3d,bp2)){
 	    tracederiv(Func,bp1,bp2);
 	  }
 	}
@@ -746,7 +750,7 @@ void BRepBlend_SurfRstLineBuilder::InternalPerform(Blend_SurfRstFunction&  Func,
 	  Arrive = Standard_True;
 	  Exts.SetValue(previousP.PointOnS(),
 			sol(1),sol(2),
-			previousP.Parameter(),tolesp);
+			previousP.Parameter(),tolpoint3d);
 	  MakeExtremity(Extrst,Standard_False,rst,sol(3),IsVtxrst,Vtxrst);
 	  // Indicate end on Bound.
 	}
@@ -765,10 +769,10 @@ void BRepBlend_SurfRstLineBuilder::InternalPerform(Blend_SurfRstFunction&  Func,
 	if (Abs(stepw) < tolgui) {
 	  previousP.ParametersOnS(U,V);
 	  Exts.SetValue(previousP.PointOnS(),U,V,
-			previousP.Parameter(),tolesp);
+			previousP.Parameter(),tolpoint3d);
 	  Extrst.SetValue(previousP.PointOnC(),
 			  previousP.ParameterOnC(),
-			  previousP.Parameter(),tolesp);
+			  previousP.Parameter(),tolpoint3d);
 	  Arrive = Standard_True;
 	  if (line->NbPoints()>=2) {
 	    // Indicate that one stops during the processing
@@ -804,7 +808,7 @@ void BRepBlend_SurfRstLineBuilder::InternalPerform(Blend_SurfRstFunction&  Func,
 	if (param == Bound) {
 	  Arrive = Standard_True;
 	  Exts.SetValue(previousP.PointOnS(),sol(1),sol(2),
-			previousP.Parameter(),tolesp);
+			previousP.Parameter(),tolpoint3d);
 	  MakeExtremity(Extrst,Standard_False,rst,sol(3),IsVtxrst,Vtxrst);
 	  // Indicate end on Bound.
 	}
@@ -850,7 +854,7 @@ void BRepBlend_SurfRstLineBuilder::InternalPerform(Blend_SurfRstFunction&  Func,
 	  line->Prepend(previousP);
 	}
 	Exts.SetValue(previousP.PointOnS(),sol(1),sol(2),
-		      previousP.Parameter(),tolesp);
+		      previousP.Parameter(),tolpoint3d);
 	MakeExtremity(Extrst,Standard_False,rst,sol(3),IsVtxrst,Vtxrst);
 	Arrive = Standard_True;
       }
@@ -883,10 +887,10 @@ void BRepBlend_SurfRstLineBuilder::InternalPerform(Blend_SurfRstFunction&  Func,
 #endif
 	previousP.ParametersOnS(U,V);
 	Exts.SetValue(previousP.PointOnS(),U,V,
-		      previousP.Parameter(),tolesp);
+		      previousP.Parameter(),tolpoint3d);
 	Extrst.SetValue(previousP.PointOnC(),
 			previousP.ParameterOnC(),
-			previousP.Parameter(),tolesp);
+			previousP.Parameter(),tolpoint3d);
 	Arrive = Standard_True;
       }
       break;
@@ -941,7 +945,10 @@ Standard_Boolean BRepBlend_SurfRstLineBuilder::Recadre(Blend_SurfCurvFuncInv&
   FinvC.Set(Arc);
   
   math_Vector toler(1,3),infb(1,3),supb(1,3);
-  FinvC.GetTolerance(toler,tolesp);
+  // use reduced Tol argument value to pass testcase
+  // blend complex A6 with scale factor of model 0.1 (base scale = 1000)
+  // So, here we using 1.0e-5 rather than 1.0e-4 of tolerance of point in 3d
+  FinvC.GetTolerance(toler,0.1 * tolpoint3d);
   FinvC.GetBounds(infb,supb);
   Solinv(1) = param;
   Solinv(2) = sol(3);
@@ -958,7 +965,7 @@ Standard_Boolean BRepBlend_SurfRstLineBuilder::Recadre(Blend_SurfCurvFuncInv&
   else {
       // It is necessary to check the value of the function
     rsnld.Root(Solinv);
-    recadre = FinvC.IsSolution(Solinv,tolesp);
+    recadre = FinvC.IsSolution(Solinv,tolpoint3d);
   }
 
   // In case of fail, it is checked if another arc 
@@ -981,7 +988,7 @@ Standard_Boolean BRepBlend_SurfRstLineBuilder::Recadre(Blend_SurfCurvFuncInv&
     Arc = domain1->Value();
     FinvC.Set(Arc);
   
-    FinvC.GetTolerance(toler,tolesp);
+    FinvC.GetTolerance(toler,tolpoint3d);
     FinvC.GetBounds(infb,supb);
 
     Solinv(3) = pmin;
@@ -997,7 +1004,7 @@ Standard_Boolean BRepBlend_SurfRstLineBuilder::Recadre(Blend_SurfCurvFuncInv&
     else {
       // It is necessary to check the value of the function
       aRsnld.Root(Solinv);
-      recadre = FinvC.IsSolution(Solinv,tolesp);
+      recadre = FinvC.IsSolution(Solinv,tolpoint3d);
     }
   }  
 
@@ -1041,7 +1048,7 @@ Standard_Boolean BRepBlend_SurfRstLineBuilder::Recadre(Blend_SurfRstFunction&
 						       Handle(Adaptor3d_HVertex)& Vtx) 
 {
   math_Vector toler(1,4),infb(1,4),supb(1,4);
-  Finv.GetTolerance(toler,tolesp);
+  Finv.GetTolerance(toler,tolpoint3d);
   Finv.GetBounds(infb,supb);
   Solinv(1) = sol(3);
   Solinv(2) = param;
@@ -1058,9 +1065,9 @@ Standard_Boolean BRepBlend_SurfRstLineBuilder::Recadre(Blend_SurfRstFunction&
   }
   rsnld.Root(Solinv);
   
-  if(Finv.IsSolution(Solinv,tolesp)){
+  if(Finv.IsSolution(Solinv,tolpoint3d)){
     gp_Pnt2d p2d(Solinv(3),Solinv(4));
-    TopAbs_State situ = domain1->Classify(p2d,Min(toler(3),toler(4)),0);
+    TopAbs_State situ = domain1->Classify(p2d,tolpoint2d,0);
     if ((situ != TopAbs_IN) && (situ != TopAbs_ON)) {
       return Standard_False;
     }
@@ -1086,7 +1093,7 @@ Standard_Boolean BRepBlend_SurfRstLineBuilder::Recadre(Blend_SurfRstFunction&
 
     math_Vector infbound(1,3),supbound(1,3);
     math_Vector parinit(1,3),tolerance(1,3);
-    Func.GetTolerance(tolerance,tolesp);
+    Func.GetTolerance(tolerance,tolpoint3d);
     Func.GetBounds(infbound,supbound);
 
     math_FunctionSetRoot rsnld2(Func,tolerance,30);
@@ -1126,7 +1133,7 @@ Standard_Boolean BRepBlend_SurfRstLineBuilder::Recadre(Blend_SurfPointFuncInv&
 
   FinvP.Set(thepoint);
   math_Vector toler(1,3),infb(1,3),supb(1,3);
-  FinvP.GetTolerance(toler,tolesp);
+  FinvP.GetTolerance(toler,tolpoint3d);
   FinvP.GetBounds(infb,supb);
   Solinv(1) = param;
   Solinv(2) = sol(1);
@@ -1142,9 +1149,9 @@ Standard_Boolean BRepBlend_SurfRstLineBuilder::Recadre(Blend_SurfPointFuncInv&
   }
   rsnld.Root(Solinv);
   
-  if(FinvP.IsSolution(Solinv,tolesp)){
+  if(FinvP.IsSolution(Solinv,tolpoint3d)){
     gp_Pnt2d p2d(Solinv(2),Solinv(3));
-    TopAbs_State situ = domain1->Classify(p2d,Min(toler(2),toler(3)),0);
+    TopAbs_State situ = domain1->Classify(p2d,tolpoint2d,0);
     if ((situ != TopAbs_IN) && (situ != TopAbs_ON)) {
       return Standard_False;
     }
@@ -1237,7 +1244,7 @@ void BRepBlend_SurfRstLineBuilder::MakeExtremity(BRepBlend_Extremity&
   if (OnFirst) {
     Extrem.SetValue(previousP.PointOnS(),
 		    sol(1),sol(2),
-		    previousP.Parameter(),tolesp);
+		    previousP.Parameter(),tolpoint3d);
     if (!previousP.IsTangencyPoint()) 
       Extrem.SetTangent(previousP.TangentOnS());
     Iter = domain1;
@@ -1245,7 +1252,7 @@ void BRepBlend_SurfRstLineBuilder::MakeExtremity(BRepBlend_Extremity&
   else {
     Extrem.SetValue(previousP.PointOnC(),
 		    sol(3),
-		    previousP.Parameter(),tolesp);
+		    previousP.Parameter(),tolpoint3d);
     if (!previousP.IsTangencyPoint()) 
       Extrem.SetTangent(previousP.TangentOnC());    
     Iter = domain2;
@@ -1312,12 +1319,13 @@ Blend_Status BRepBlend_SurfRstLineBuilder::CheckDeflectionOnSurf(const Blend_Poi
 //  if(!curpointistangent) curNorme = Tgsurf.SquareMagnitude();
   if(!prevpointistangent) prevNorme = prevTg.SquareMagnitude();
 
-  if (Norme <= tolesp*tolesp){
+  const Standard_Real toler3d = 0.01 * tolpoint3d;
+  if (Norme <= toler3d * toler3d){
     // it can be necessary to force same point
     return Blend_SamePoints;
   }
   if(!prevpointistangent){
-    if(prevNorme <= tolesp*tolesp) {
+    if(prevNorme <= toler3d * toler3d) {
       return Blend_SamePoints;
     }
     Cosi = sens*Corde*prevTg;
@@ -1388,12 +1396,13 @@ Blend_Status BRepBlend_SurfRstLineBuilder::CheckDeflectionOnRst(const Blend_Poin
 //  if(!curpointistangent) curNorme = Tgsurf.SquareMagnitude();
   if(!prevpointistangent) prevNorme = prevTg.SquareMagnitude();
 
-  if (Norme <= tolesp*tolesp){
+  const Standard_Real toler3d = 0.01 * tolpoint3d;
+  if (Norme <= toler3d * toler3d){
     // it can be necessary to force same point
     return Blend_SamePoints;
   }
   if(!prevpointistangent){
-    if(prevNorme <= tolesp*tolesp) {
+    if(prevNorme <= toler3d * toler3d) {
       return Blend_SamePoints;
     }
     Cosi = sens*Corde*prevTg;
@@ -1455,7 +1464,7 @@ Blend_Status BRepBlend_SurfRstLineBuilder::TestArret(Blend_SurfRstFunction& Func
   IntSurf_TypeTrans tras = IntSurf_Undecided, trarst = IntSurf_Undecided;
   Blend_Point curpoint;
 
-  if (Func.IsSolution(sol,tolesp)) {
+  if (Func.IsSolution(sol,tolpoint3d)) {
     Standard_Boolean curpointistangent = Func.IsTangencyPoint();
     pts = Func.PointOnS();
     ptrst = Func.PointOnRst();
@@ -1499,7 +1508,7 @@ Blend_Status BRepBlend_SurfRstLineBuilder::TestArret(Blend_SurfRstFunction& Func
       Func.Decroch(sol,nors,tgsecs);
       nors.Normalize();
       Standard_Real testra = tgsecs.Dot(nors.Crossed(tgs));
-      if (Abs(testra) > tolesp) {
+      if (Abs(testra) > tolpoint3d) {
 	if (testra < 0.) {
 	  tras = IntSurf_In;
 	}
@@ -1558,7 +1567,7 @@ Standard_Boolean BRepBlend_SurfRstLineBuilder::CheckInside(Blend_SurfRstFunction
 							   Standard_Boolean&      Decroch)
 {
   math_Vector tolerance(1,3);
-  Func.GetTolerance(tolerance,tolesp);
+  Func.GetTolerance(tolerance,tolpoint3d);
   //face pcurve.
   Standard_Real w = sol(3);
   if(w < rst->FirstParameter() - tolerance(3)||
@@ -1573,7 +1582,7 @@ Standard_Boolean BRepBlend_SurfRstLineBuilder::CheckInside(Blend_SurfRstFunction
 
   //face surface
   gp_Pnt2d p2d(sol(1),sol(2));
-  SituOnS = domain1->Classify(p2d,Min(tolerance(1),tolerance(2)),0);
+  SituOnS = domain1->Classify(p2d,tolpoint2d,0);
 
   //lost contact
   gp_Vec tgs,nors;

src/BRepBlend/BRepBlend_SurfRstLineBuilder.hxx

@@ -71,9 +71,9 @@ public:
   
   Standard_EXPORT BRepBlend_SurfRstLineBuilder(const Handle(Adaptor3d_Surface)& Surf1, const Handle(Adaptor3d_TopolTool)& Domain1, const Handle(Adaptor3d_Surface)& Surf2, const Handle(Adaptor2d_Curve2d)& Rst, const Handle(Adaptor3d_TopolTool)& Domain2);
   
-  Standard_EXPORT void Perform (Blend_SurfRstFunction& Func, Blend_FuncInv& Finv, Blend_SurfPointFuncInv& FinvP, Blend_SurfCurvFuncInv& FinvC, const Standard_Real Pdep, const Standard_Real Pmax, const Standard_Real MaxStep, const Standard_Real TolGuide, const math_Vector& Soldep, const Standard_Real Tolesp, const Standard_Real Fleche, const Standard_Boolean Appro = Standard_False);
+  Standard_EXPORT void Perform (Blend_SurfRstFunction& Func, Blend_FuncInv& Finv, Blend_SurfPointFuncInv& FinvP, Blend_SurfCurvFuncInv& FinvC, const Standard_Real Pdep, const Standard_Real Pmax, const Standard_Real MaxStep, const Standard_Real Tol3d, const Standard_Real Tol2d, const Standard_Real TolGuide, const math_Vector& Soldep, const Standard_Real Fleche, const Standard_Boolean Appro = Standard_False);
   
-  Standard_EXPORT Standard_Boolean PerformFirstSection (Blend_SurfRstFunction& Func, Blend_FuncInv& Finv, Blend_SurfPointFuncInv& FinvP, Blend_SurfCurvFuncInv& FinvC, const Standard_Real Pdep, const Standard_Real Pmax, const math_Vector& Soldep, const Standard_Real Tolesp, const Standard_Real TolGuide, const Standard_Boolean RecRst, const Standard_Boolean RecP, const Standard_Boolean RecS, Standard_Real& Psol, math_Vector& ParSol);
+  Standard_EXPORT Standard_Boolean PerformFirstSection (Blend_SurfRstFunction& Func, Blend_FuncInv& Finv, Blend_SurfPointFuncInv& FinvP, Blend_SurfCurvFuncInv& FinvC, const Standard_Real Pdep, const Standard_Real Pmax, const math_Vector& Soldep, const Standard_Real Tol3d, const Standard_Real Tol2d, const Standard_Real TolGuide, const Standard_Boolean RecRst, const Standard_Boolean RecP, const Standard_Boolean RecS, Standard_Real& Psol, math_Vector& ParSol);
   
   Standard_EXPORT Standard_Boolean Complete (Blend_SurfRstFunction& Func, Blend_FuncInv& Finv, Blend_SurfPointFuncInv& FinvP, Blend_SurfCurvFuncInv& FinvC, const Standard_Real Pmin);
   
@@ -128,7 +128,8 @@ private:
   Handle(Adaptor3d_Surface) surf2;
   Handle(Adaptor2d_Curve2d) rst;
   Handle(Adaptor3d_TopolTool) domain2;
-  Standard_Real tolesp;
+  Standard_Real tolpoint3d;
+  Standard_Real tolpoint2d;
   Standard_Real tolgui;
   Standard_Real pasmax;
   Standard_Real fleche;

src/BRepBlend/BRepBlend_Walking.hxx

@@ -58,11 +58,11 @@ public:
   //! To define singular points computed before walking.
   Standard_EXPORT void AddSingularPoint (const Blend_Point& P);
   
-  Standard_EXPORT void Perform (Blend_Function& F, Blend_FuncInv& FInv, const Standard_Real Pdep, const Standard_Real Pmax, const Standard_Real MaxStep, const Standard_Real TolGuide, const math_Vector& Soldep, const Standard_Real Tolesp, const Standard_Real Fleche, const Standard_Boolean Appro = Standard_False);
+  Standard_EXPORT void Perform (Blend_Function& F, Blend_FuncInv& FInv, const Standard_Real Pdep, const Standard_Real Pmax, const Standard_Real MaxStep, const Standard_Real Tol3d, const Standard_Real TolGuide, const math_Vector& Soldep, const Standard_Real Fleche, const Standard_Boolean Appro = Standard_False);
   
-  Standard_EXPORT Standard_Boolean PerformFirstSection (Blend_Function& F, const Standard_Real Pdep, math_Vector& ParDep, const Standard_Real Tolesp, const Standard_Real TolGuide, TopAbs_State& Pos1, TopAbs_State& Pos2);
+  Standard_EXPORT Standard_Boolean PerformFirstSection (Blend_Function& F, const Standard_Real Pdep, math_Vector& ParDep, const Standard_Real Tol3d, const Standard_Real TolGuide, TopAbs_State& Pos1, TopAbs_State& Pos2);
   
-  Standard_EXPORT Standard_Boolean PerformFirstSection (Blend_Function& F, Blend_FuncInv& FInv, const Standard_Real Pdep, const Standard_Real Pmax, const math_Vector& ParDep, const Standard_Real Tolesp, const Standard_Real TolGuide, const Standard_Boolean RecOnS1, const Standard_Boolean RecOnS2, Standard_Real& Psol, math_Vector& ParSol);
+  Standard_EXPORT Standard_Boolean PerformFirstSection (Blend_Function& F, Blend_FuncInv& FInv, const Standard_Real Pdep, const Standard_Real Pmax, const math_Vector& ParDep, const Standard_Real Tol3d, const Standard_Real TolGuide, const Standard_Boolean RecOnS1, const Standard_Boolean RecOnS2, Standard_Real& Psol, math_Vector& ParSol);
   
   Standard_EXPORT Standard_Boolean Continu (Blend_Function& F, Blend_FuncInv& FInv, const Standard_Real P);
   
@@ -131,7 +131,7 @@ private:
   Standard_Boolean ToCorrectOnRst1;
   Standard_Boolean ToCorrectOnRst2;
   Standard_Real CorrectedParam;
-  Standard_Real tolesp;
+  Standard_Real tolpoint3d;
   Standard_Real tolgui;
   Standard_Real pasmax;
   Standard_Real fleche;

src/BRepBndLib/BRepBndLib.cxx

@@ -127,6 +127,14 @@ void BRepBndLib::Add(const TopoDS_Shape& S, Bnd_Box& B, Standard_Boolean useTria
   for (ex.Init(S,TopAbs_EDGE,TopAbs_FACE); ex.More(); ex.Next())
   {
     const TopoDS_Edge& E = TopoDS::Edge(ex.Current());
+ 
+    if (!useTriangulation && BRep_Tool::IsGeometric(E))
+    {
+      BC.Initialize(E);
+      BndLib_Add3dCurve::Add(BC, BRep_Tool::Tolerance(E), B);
+      continue;
+    }
+
     Handle(Poly_Polygon3D) P3d = BRep_Tool::Polygon3D(E, l);
     if (!P3d.IsNull() && P3d->NbNodes() > 0)
     {
@@ -143,7 +151,7 @@ void BRepBndLib::Add(const TopoDS_Shape& S, Bnd_Box& B, Standard_Boolean useTria
     else
     {
       BRep_Tool::PolygonOnTriangulation(E, Poly, T, l);
-      if (useTriangulation && !Poly.IsNull() && !T.IsNull() && T->NbNodes() > 0)
+      if (!Poly.IsNull() && !T.IsNull() && T->NbNodes() > 0)
       {
         const TColStd_Array1OfInteger& Indices = Poly->Nodes();
         nbNodes = Indices.Length();

src/BRepExtrema/BRepExtrema_DistanceSS.cxx

@@ -468,7 +468,14 @@ static void PERFORM_C0(const TopoDS_Edge& S1, const TopoDS_Edge& S2,
               if (fabs(Dstmin - sqrt(Ext.SquareDistance(ii))) < Eps)
               {
                 Pt = Ext.Point(ii);
-                if (TRI_SOLUTION(SeqSol2, Pt))
+                // Pt - point on the curve pCurvOther/Eother, but
+                // if iE == 0 -> Eother correspond to edge S2
+                // and to edge S1 in the opposite case.
+                // Therefore we should search Pt through previous solution points on Other curve (edge):
+                // if iE == 0 - on edge S2, namely through SeqSol2,
+                // else       - on edge S1, namely through SeqSol1.
+                const bool triSolutionResult = (iE == 0) ? TRI_SOLUTION(SeqSol2, Pt) : TRI_SOLUTION(SeqSol1, Pt);
+                if (triSolutionResult)
                 {
                   // Check if the parameter does not correspond to a vertex
                   const Standard_Real t = Ext.Parameter(ii);
@@ -869,9 +876,19 @@ void BRepExtrema_DistanceSS::Perform (const TopoDS_Edge& theS1,
 
   if (!seqSol1.IsEmpty() && !seqSol2.IsEmpty())
   {
-    theSeqSolShape1.Append(seqSol1);
-    theSeqSolShape2.Append(seqSol2);
-    myModif = Standard_True;
+    BRepExtrema_SeqOfSolution::iterator anIt1 = seqSol1.begin();
+    BRepExtrema_SeqOfSolution::iterator anIt2 = seqSol2.begin();
+    for (; anIt1 != seqSol1.end() && anIt2 != seqSol2.end(); anIt1++, anIt2++)
+    {
+      gp_Pnt Pt1 = anIt1->Point();
+      gp_Pnt Pt2 = anIt2->Point();
+      if (TRI_SOLUTION(theSeqSolShape1, Pt1) || TRI_SOLUTION(theSeqSolShape2, Pt2))
+      {
+        theSeqSolShape1.Append(*anIt1);
+        theSeqSolShape2.Append(*anIt2);
+        myModif = Standard_True;
+      }
+    }
   }
 }
 

src/BRepFill/BRepFill_AdvancedEvolved.cxx

@@ -44,6 +44,8 @@
 #include <BRepGProp_Face.hxx>
 #include <BRep_TEdge.hxx>
 #include <ShapeUpgrade_UnifySameDomain.hxx>
+#include <Bnd_Box.hxx>
+#include <BRepBndLib.hxx>
 
 #ifdef BRepFill_AdvancedEvolved_DEBUG
 #include <BinTools.hxx>
@@ -524,9 +526,14 @@ void BRepFill_AdvancedEvolved::GetLids()
     return;
   }
 
+  Standard_Real aTol = Max(aFS.Tolerance(), aFS.ToleranceReached());
+  aTol += myFuzzyValue;
+  Bnd_Box aProfBox;
+  BRepBndLib::Add(myProfile, aProfBox);
+  Standard_Real aSqDiag = aProfBox.SquareExtent();
   //Square of the default angular tolerance in
   //BOPAlgo_Tools::EdgesToWires(...) and BOPAlgo_Tools::WiresToFaces(...) methods
-  const Standard_Real aSqAnguarTol = 1.0e-16;
+  const Standard_Real aSqAnguarTol = aTol*aTol / aSqDiag;
   const gp_Dir &aNormal = aSurf->Position().Direction();
 
   // Obtain free-edges from myPipeShell. All edges must be planar
@@ -541,6 +548,7 @@ void BRepFill_AdvancedEvolved::GetLids()
   gp_Pnt aPtmp;
   gp_Vec aTan;
 
+  Standard_Real aDPMax = 0.;
   for (Standard_Integer i = 1; i <= aMapEF.Size(); i++)
   {
     TopTools_ListOfShape& aListF = aMapEF(i);
@@ -564,6 +572,8 @@ void BRepFill_AdvancedEvolved::GetLids()
       continue;
 
     const Standard_Real aDP = aTan.XYZ().Dot(aNormal.XYZ());
+    if (Abs(aDP) > aDPMax)
+      aDPMax = Abs(aDP);
     if (aDP*aDP>aSqModulus*aSqAnguarTol)
     {
       //Only planar edges are considered
@@ -594,8 +604,9 @@ void BRepFill_AdvancedEvolved::GetLids()
   aBB.MakeCompound(aCompW);
   aBB.MakeCompound(aCompF);
   aBB.MakeCompound(myTopBottom);
-  BOPAlgo_Tools::EdgesToWires(aFreeEdges, aCompW, Standard_True);
-  BOPAlgo_Tools::WiresToFaces(aCompW, aCompF);
+  Standard_Real anAngTol = Sqrt(aSqAnguarTol);
+  BOPAlgo_Tools::EdgesToWires(aFreeEdges, aCompW, Standard_True, anAngTol);
+  BOPAlgo_Tools::WiresToFaces(aCompW, aCompF, anAngTol);
 
   {
     // Check orientation

src/BRepFill/BRepFill_CompatibleWires.cxx

@@ -351,6 +351,10 @@ static void TrimEdge (const TopoDS_Edge&              CurrentEdge,
     for (j=1; j<=ndec; j++) {
       // piece of edge  
       m1 = (CutValues.Value(j)-t0)*(last-first)/(t1-t0)+first;
+      if (Abs(m0 - m1) < Precision::Confusion())
+      {
+        return;
+      }
       TopoDS_Edge CutE = BRepLib_MakeEdge(C,V0,Vbid,m0,m1);
       CutE.Orientation(CurrentOrient);
       S.Append(CutE);
@@ -358,6 +362,10 @@ static void TrimEdge (const TopoDS_Edge&              CurrentEdge,
       V0 = TopExp::LastVertex(CutE);
       if (j==ndec) {
 	// last piece
+        if (Abs(m0 - last) < Precision::Confusion())
+        {
+          return;
+        }
 	TopoDS_Edge LastE = BRepLib_MakeEdge(C,V0,Vl,m0,last);
 	LastE.Orientation(CurrentOrient);
 	S.Append(LastE);
@@ -371,6 +379,10 @@ static void TrimEdge (const TopoDS_Edge&              CurrentEdge,
     for (j=ndec; j>=1; j--) {
       // piece of edge  
       m0 = (CutValues.Value(j)-t0)*(last-first)/(t1-t0)+first;
+      if (Abs(m0 - m1) < Precision::Confusion())
+      {
+        return;
+      }
       TopoDS_Edge CutE = BRepLib_MakeEdge(C,Vbid,V1,m0,m1);
       CutE.Orientation(CurrentOrient);
       S.Append(CutE);
@@ -378,6 +390,10 @@ static void TrimEdge (const TopoDS_Edge&              CurrentEdge,
       V1 = TopExp::FirstVertex(CutE);
       if (j==1) {
 	// last piece
+        if (Abs(first - m1) < Precision::Confusion())
+        {
+          return;
+        }
 	TopoDS_Edge LastE = BRepLib_MakeEdge(C,Vf,V1,first,m1);
 	LastE.Orientation(CurrentOrient);
 	S.Append(LastE);
@@ -547,6 +563,10 @@ static Standard_Boolean EdgeIntersectOnWire (const gp_Pnt& P1,
 	  SR.Clear();
 	  SR.Append(param);
 	  TrimEdge(E,SR,first,last,SO,SE);
+          if (SE.IsEmpty())
+          {
+            return Standard_False;
+          }
           theEdgeNewEdges(E) = SE;
 	  TopoDS_Vertex VV1,VV2;
 	  TopExp::Vertices(TopoDS::Edge(SE.Value(1)),VV1,VV2);
@@ -656,7 +676,7 @@ static void BuildConnectedEdges(const TopoDS_Wire& aWire,
 //=======================================================================
 
 BRepFill_CompatibleWires::BRepFill_CompatibleWires() 
-:myIsDone(Standard_False)
+:myStatus(BRepFill_ThruSectionErrorStatus_NotDone)
 {
 }
 
@@ -681,8 +701,8 @@ void BRepFill_CompatibleWires::Init(const TopTools_SequenceOfShape& Sections)
 {
   myInit = Sections;
   myWork = Sections;
-  myPercent = 0.01;
-  myIsDone = Standard_False;
+  myPercent = 0.1;
+  myStatus = BRepFill_ThruSectionErrorStatus_NotDone;
   myMap.Clear();
 
 }
@@ -707,7 +727,7 @@ void BRepFill_CompatibleWires::SetPercent(const Standard_Real Percent)
 
 Standard_Boolean BRepFill_CompatibleWires::IsDone() const 
 {
-  return myIsDone;
+  return myStatus == BRepFill_ThruSectionErrorStatus_Done;
 }
 
 
@@ -766,6 +786,7 @@ Standard_Boolean BRepFill_CompatibleWires::IsDegeneratedLastSection() const
 
 void BRepFill_CompatibleWires::Perform (const Standard_Boolean WithRotation)
 {
+  myStatus = BRepFill_ThruSectionErrorStatus_Done;
   // compute origin and orientation on wires to avoid twisted results
   // and update wires to have same number of edges
 
@@ -838,7 +859,7 @@ void BRepFill_CompatibleWires::Perform (const Standard_Boolean WithRotation)
     allClosed = (allClosed && wClosed);
     allOpen = (allOpen && !wClosed);
   }
-  
+
   if (allClosed) {
     // All sections are closed 
     if (report) {
@@ -849,24 +870,26 @@ void BRepFill_CompatibleWires::Perform (const Standard_Boolean WithRotation)
       // origin
       ComputeOrigin(Standard_False);
     }
-    myIsDone = Standard_True;
   }
   else if (allOpen) {
     // All sections are open
     // origin
     SearchOrigin();
+    if (myStatus != BRepFill_ThruSectionErrorStatus_Done)
+    {
+      return;
+    }
     // same number of elements
     if (report) {
       SameNumberByACR(report);
     }
-    myIsDone = Standard_True;
   }
   else {
     // There are open and closed sections :
     // not processed
-    throw Standard_DomainError("Sections must be all closed or all open");
+    myStatus = BRepFill_ThruSectionErrorStatus_NotSameTopology;
+    return;
   }
-  
 }
 
 
@@ -906,7 +929,10 @@ void BRepFill_CompatibleWires::
     //allClosed = (allClosed && myWork(i).Closed());
   }
   if (!allClosed)
-    throw Standard_NoSuchObject("BRepFill_CompatibleWires::SameNumberByPolarMethod : the wires must be closed");
+  {
+    myStatus = BRepFill_ThruSectionErrorStatus_NotSameTopology;
+    return;
+  }
   
   // sections ponctuelles, sections bouclantes ?
   if (myDegen1) ideb++;
@@ -986,8 +1012,11 @@ void BRepFill_CompatibleWires::
     
     // sequence of vertices of the first wire
     SeqOfVertices(wire1,SeqV);
-    if (SeqV.Length()>NbMaxV) 
-      throw Standard_NoSuchObject("BRepFill::SameNumberByPolarMethod failed");
+    if (SeqV.Length() > NbMaxV)
+    {
+      myStatus = BRepFill_ThruSectionErrorStatus_Failed;
+      return;
+    }
     
     // loop on vertices of wire1
     for (ii=1;ii<=SeqV.Length();ii++) {
@@ -1062,7 +1091,10 @@ void BRepFill_CompatibleWires::
     // sequence of vertices of the first wire
     SeqOfVertices(wire1,SeqV);
     if ( SeqV.Length()>NbMaxV || SeqV.Length()>SizeMap ) 
-      throw Standard_NoSuchObject("BRepFill::SameNumberByPolarMethod failed");
+    {
+      myStatus = BRepFill_ThruSectionErrorStatus_Failed;
+      return;
+    }
     
 
     // next wire 
@@ -1184,14 +1216,17 @@ void BRepFill_CompatibleWires::
 	}
       } //end of for(; itW.More(); itW.Next())
     if (Esol.IsNull())
-      throw Standard_ConstructionError("BRepFill :: profiles are inconsistent");
+    {
+      myStatus = BRepFill_ThruSectionErrorStatus_ProfilesInconsistent;
+      return;
+    }
     MW.Add(Esol);
 
     TopTools_ListOfShape ConnectedEdges;
     BuildConnectedEdges( TopoDS::Wire(myWork(i)), Esol, V2, ConnectedEdges );
 
     TopTools_ListIteratorOfListOfShape itCE(ConnectedEdges);
-    for(; anExp.More(), itCE.More(); anExp.Next(), itCE.Next())
+    for(; anExp.More() && itCE.More(); anExp.Next(), itCE.Next())
       {
 	ECur = anExp.Current();
 	TopExp::Vertices(ECur,VF,VL,Standard_True);
@@ -1264,8 +1299,10 @@ void BRepFill_CompatibleWires::
     if (nbmax<nbEdges) nbmax = nbEdges;
     if (nbmin>nbEdges) nbmin = nbEdges;
   }
-  if (nbmin!=nbmax) {
-    throw Standard_NoSuchObject("BRepFill_CompatibleWires::SameNumberByPolarMethod failed");
+  if (nbmin!=nbmax) 
+  {
+    myStatus = BRepFill_ThruSectionErrorStatus_Failed;
+    return;
   }
 
   //Fill <myMap>
@@ -1487,7 +1524,10 @@ void BRepFill_CompatibleWires::SameNumberByACR(const  Standard_Boolean  report)
     if (nbmin>nbEdges(i)) nbmin = nbEdges(i);
   }
   if (nbmax!=nbmin) 
-    throw Standard_NoSuchObject("BRepFill_CompatibleWires::SameNumberByACR failed");
+  {
+    myStatus = BRepFill_ThruSectionErrorStatus_Failed;
+    return;
+  }
 }
 
 //=======================================================================
@@ -1532,7 +1572,10 @@ void BRepFill_CompatibleWires::ComputeOrigin(const  Standard_Boolean /*polar*/ )
   }
 */
   if (!allClosed) 
-    throw Standard_NoSuchObject("BRepFill_CompatibleWires::ComputeOrigin : the wires must be closed");
+  {
+    myStatus = BRepFill_ThruSectionErrorStatus_NotSameTopology;
+    return;
+  }
 
 /*  
   // Max number of possible cuts
@@ -1869,7 +1912,10 @@ void BRepFill_CompatibleWires::ComputeOrigin(const  Standard_Boolean /*polar*/ )
       gp_Pnt Pmini,P1,P2;
       SeqOfVertices(wire,SeqV);
       if (SeqV.Length()>NbMaxV) 
-	throw Standard_NoSuchObject("BRepFill::ComputeOrigin failed");
+      {
+        myStatus = BRepFill::ThruSectionsError_Failed;
+        return;
+      }
       if (!polar) {
 	// choix du vertex le plus proche comme origine
 	distmini = Precision::Infinite();
@@ -2094,7 +2140,10 @@ void BRepFill_CompatibleWires::SearchOrigin()
     allOpen = (allOpen && !myWork(i).Closed());
   }
   if (!allOpen)
-    throw Standard_NoSuchObject("BRepFill_CompatibleWires::SearchOrigin : the wires must be open");
+  {
+    myStatus = BRepFill_ThruSectionErrorStatus_NotSameTopology;
+    return;
+  }
 
   // init
 

src/BRepFill/BRepFill_CompatibleWires.hxx

@@ -20,6 +20,7 @@
 #include <Standard.hxx>
 #include <Standard_DefineAlloc.hxx>
 
+#include <BRepFill_ThruSectionErrorStatus.hxx>
 #include <TopTools_SequenceOfShape.hxx>
 #include <TopTools_DataMapOfShapeListOfShape.hxx>
 #include <TopTools_ListOfShape.hxx>
@@ -49,6 +50,11 @@ public:
   Standard_EXPORT void Perform (const Standard_Boolean WithRotation = Standard_True);
   
   Standard_EXPORT Standard_Boolean IsDone() const;
+
+  BRepFill_ThruSectionErrorStatus GetStatus() const
+  {
+    return myStatus;
+  }
   
   //! returns the generated sequence.
   Standard_EXPORT const TopTools_SequenceOfShape& Shape() const;
@@ -101,7 +107,7 @@ private:
   Standard_Real myPercent;
   Standard_Boolean myDegen1;
   Standard_Boolean myDegen2;
-  Standard_Boolean myIsDone;
+  BRepFill_ThruSectionErrorStatus myStatus;
   TopTools_DataMapOfShapeListOfShape myMap;
 
 

src/BRepFill/BRepFill_Generator.cxx

@@ -65,6 +65,7 @@ Standard_Integer DetectKPart(const TopoDS_Edge& Edge1,
 			     const TopoDS_Edge& Edge2)
 {
   // initializations
+  // !Note if IType set as -1 it means that occurs error with null 3d curve for the edge
   Standard_Integer IType = 0;
 
   // characteristics of the first edge
@@ -89,7 +90,9 @@ Standard_Integer DetectKPart(const TopoDS_Edge& Edge1,
   else {
     curv1 = BRep_Tool::Curve(Edge1, loc, first1, last1);
     if (curv1.IsNull())
-      throw Standard_NullObject("Null 3D curve in edge");
+    {
+      return -1;
+    }
     curv1 = 
       Handle(Geom_Curve)::DownCast(curv1->Transformed(loc.Transformation()));
     ff = first1;
@@ -156,7 +159,9 @@ Standard_Integer DetectKPart(const TopoDS_Edge& Edge1,
     else {
       curv = BRep_Tool::Curve(Edge2, loc, first2, last2);
       if (curv.IsNull())
-        throw Standard_NullObject("Null 3D curve in edge");
+      {
+        return -1;
+      }
       curv = 
 	Handle(Geom_Curve)::DownCast(curv->Transformed(loc.Transformation()));
       ff = first2;
@@ -312,12 +317,12 @@ Standard_Integer DetectKPart(const TopoDS_Edge& Edge1,
 
 //=======================================================================
 //function : CreateKPart
-//purpose  : 
+//purpose  : Returns true if there is no errors occur
 //=======================================================================
 
-void CreateKPart(const TopoDS_Edge& Edge1,const TopoDS_Edge& Edge2,
-		 const Standard_Integer IType, 
-		 Handle(Geom_Surface)& Surf)
+Standard_Boolean CreateKPart (const TopoDS_Edge& Edge1,const TopoDS_Edge& Edge2,
+                              const Standard_Integer IType, 
+                              Handle(Geom_Surface)& Surf)
 {
   // find the dimension
   TopoDS_Vertex V1, V2;
@@ -326,6 +331,8 @@ void CreateKPart(const TopoDS_Edge& Edge1,const TopoDS_Edge& Edge2,
   Standard_Real a1, b1, aa =0., bb =0.;
   TopoDS_Vertex v1f,v1l,v2f,v2l;
 
+  Standard_Boolean isDone = Standard_True;
+
   // find characteristics of the first edge
   Handle(Geom_Curve) C1;
   Standard_Boolean degen1 = BRep_Tool::Degenerated(Edge1);
@@ -336,7 +343,9 @@ void CreateKPart(const TopoDS_Edge& Edge1,const TopoDS_Edge& Edge2,
   else {
     C1 = BRep_Tool::Curve(Edge1, loc, a1, b1);
     if (C1.IsNull())
-      throw Standard_NullObject("Null 3D curve in edge");
+    {
+      return Standard_False;
+    }
     C1 = Handle(Geom_Curve)::DownCast(C1->Transformed(loc.Transformation()));
     aa = a1;
     bb = b1;
@@ -361,7 +370,9 @@ void CreateKPart(const TopoDS_Edge& Edge1,const TopoDS_Edge& Edge2,
   else {
     C2 = BRep_Tool::Curve(Edge2, loc, a1, b1);
     if (C2.IsNull())
-      throw Standard_NullObject("Null 3D curve in edge");
+    {
+      return Standard_False;
+    }
     C2 = Handle(Geom_Curve)::DownCast(C2->Transformed(loc.Transformation()));
     if (Edge2.Orientation() == TopAbs_REVERSED) {
       C2->Reverse();
@@ -496,6 +507,7 @@ void CreateKPart(const TopoDS_Edge& Edge1,const TopoDS_Edge& Edge2,
     // IType incorrect
   }
   Surf = surface;
+  return isDone;
 }
 
 //=======================================================================
@@ -528,7 +540,8 @@ static TopoDS_Edge CreateNewEdge(const TopoDS_Edge& theEdge, TopTools_DataMapOfS
 //=======================================================================
 
 BRepFill_Generator::BRepFill_Generator(): 
-  myMutableInput (Standard_True)
+  myMutableInput (Standard_True),
+  myStatus (BRepFill_ThruSectionErrorStatus_NotDone)
 {
 }
 
@@ -551,6 +564,8 @@ void BRepFill_Generator::AddWire(const TopoDS_Wire& Wire)
 
 void BRepFill_Generator::Perform()
 {
+  myStatus = BRepFill_ThruSectionErrorStatus_Done;
+
   TopoDS_Shell Shell;
   TopoDS_Face  Face;
   TopoDS_Shape S1, S2;
@@ -679,6 +694,12 @@ void BRepFill_Generator::Perform()
 
       // processing of KPart
       Standard_Integer IType = DetectKPart(Edge1,Edge2);
+      if (IType == -1)
+      {
+        myStatus = BRepFill_ThruSectionErrorStatus_Null3DCurve;
+        return;
+      }
+
       if (IType==0) {
 	// no part cases
 	TopLoc_Location L,L1,L2;
@@ -694,7 +715,10 @@ void BRepFill_Generator::Perform()
 	else {
 	  C1 = BRep_Tool::Curve(Edge1,L1,f1,l1);
           if (C1.IsNull())
-            throw Standard_NullObject("Null 3D curve in edge");
+          {
+            myStatus = BRepFill_ThruSectionErrorStatus_Null3DCurve;
+            return;
+          }
 	}
 	if (degen2) {
 	  Extremities(1) = BRep_Tool::Pnt(V2l);
@@ -704,7 +728,10 @@ void BRepFill_Generator::Perform()
 	else {
 	  C2 = BRep_Tool::Curve(Edge2,L2,f2,l2);
           if (C2.IsNull())
-            throw Standard_NullObject("Null 3D curve in edge");
+          {
+            myStatus = BRepFill_ThruSectionErrorStatus_Null3DCurve;
+            return;
+          }
 	}
 	
 	// compute the location
@@ -746,7 +773,11 @@ void BRepFill_Generator::Perform()
       }
       else {
 	// particular case
-	CreateKPart(Edge1,Edge2,IType,Surf);
+        if (!CreateKPart(Edge1, Edge2, IType, Surf))
+        {
+          myStatus = BRepFill_ThruSectionErrorStatus_Null3DCurve;
+          return;
+        }
 	B.MakeFace(Face,Surf,Precision::Confusion());
       }
       

src/BRepFill/BRepFill_Generator.hxx

@@ -20,6 +20,7 @@
 #include <Standard.hxx>
 #include <Standard_DefineAlloc.hxx>
 
+#include <BRepFill_ThruSectionErrorStatus.hxx>
 #include <TopTools_SequenceOfShape.hxx>
 #include <TopoDS_Shell.hxx>
 #include <TopTools_DataMapOfShapeListOfShape.hxx>
@@ -68,6 +69,12 @@ public:
   //! Returns the current mutable input state
   Standard_EXPORT Standard_Boolean IsMutableInput() const;
 
+  //! Returns status of the operation
+  BRepFill_ThruSectionErrorStatus GetStatus() const
+  {
+    return myStatus;
+  }
+
 protected:
 
 private:
@@ -78,6 +85,7 @@ private:
   TopTools_DataMapOfShapeShape myOldNewShapes;
   BRepTools_ReShape myReshaper;
   Standard_Boolean myMutableInput;
+  BRepFill_ThruSectionErrorStatus myStatus;
 
 };
 

src/BRepFill/BRepFill_ThruSectionErrorStatus.hxx

@@ -0,0 +1,29 @@
+// Copyright (c) 2022 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _BRepFill_ThruSectionErrorStatus_HeaderFile
+#define _BRepFill_ThruSectionErrorStatus_HeaderFile
+
+//! Errors that can occur at thrusection algorithm.
+enum BRepFill_ThruSectionErrorStatus
+{
+  BRepFill_ThruSectionErrorStatus_Done,                     //!< Thrusection algorithm is done
+  BRepFill_ThruSectionErrorStatus_NotDone,                  //!< Thrusection algorithm is not done
+  BRepFill_ThruSectionErrorStatus_NotSameTopology,          //!< All profiles have not same topology (they should be all closed or all opened)
+  BRepFill_ThruSectionErrorStatus_ProfilesInconsistent,     //!< Profiles are inconsistent 
+  BRepFill_ThruSectionErrorStatus_WrongUsage,               //!< Wrong usage of punctual sections
+  BRepFill_ThruSectionErrorStatus_Null3DCurve,              //!< Null 3D curve in edge
+  BRepFill_ThruSectionErrorStatus_Failed                    //!< Thrusection algorithm has failed
+};
+
+#endif // _BRepFill_ThruSectionErrorStatus_HeaderFile

src/BRepFill/FILES

@@ -77,6 +77,7 @@ BRepFill_ShapeLaw.hxx
 BRepFill_ShapeLaw.lxx
 BRepFill_Sweep.cxx
 BRepFill_Sweep.hxx
+BRepFill_ThruSectionErrorStatus.hxx
 BRepFill_TransitionStyle.hxx
 BRepFill_TrimEdgeTool.cxx
 BRepFill_TrimEdgeTool.hxx

src/BRepFilletAPI/BRepFilletAPI_MakeFillet.cxx

@@ -44,13 +44,13 @@ BRepFilletAPI_MakeFillet::BRepFilletAPI_MakeFillet(const TopoDS_Shape& S,
 //=======================================================================
 
 void BRepFilletAPI_MakeFillet::SetParams(const Standard_Real Tang, 
-					 const Standard_Real Tesp, 
-					 const Standard_Real T2d, 
-					 const Standard_Real TApp3d, 
-					 const Standard_Real TolApp2d, 
-					 const Standard_Real Fleche)
+                                         const Standard_Real Tesp, 
+                                         const Standard_Real T2d, 
+                                         const Standard_Real TApp3d,
+                                         const Standard_Real TolApp2d, 
+                                         const Standard_Real Fleche)
 {
-  myBuilder.SetParams(Tang,Tesp, T2d, TApp3d, TolApp2d, Fleche);
+  myBuilder.SetParams(Tang, Tesp, T2d, TApp3d, TolApp2d, Fleche);
 }
 
 //=======================================================================

src/BRepLib/BRepLib.cxx

@@ -961,6 +961,9 @@ static void InternalSameParameter(const TopoDS_Shape& theSh, BRepTools_ReShape&
     TopExp_Explorer ex2;
     for(ex2.Init(curface,TopAbs_EDGE); ex2.More(); ex2.Next()){
       const TopoDS_Edge& E = TopoDS::Edge(ex2.Current());
+      if (BRep_Tool::Degenerated(E))
+        continue;
+
       TopoDS_Shape aNe = theReshaper.Value(E);
       Standard_Real aNewEtol = -1;
       GetEdgeTol(TopoDS::Edge(aNe), curface, aNewEtol);

src/BRepLib/BRepLib_MakeFace.cxx

@@ -256,7 +256,7 @@ BRepLib_MakeFace::BRepLib_MakeFace(const TopoDS_Wire& W,
     myError = BRepLib_NotPlanar;
     return;
   }
- 
+
   // build the face and add the wire
   BRep_Builder B;
   myError = BRepLib_FaceDone;
@@ -264,13 +264,40 @@ BRepLib_MakeFace::BRepLib_MakeFace(const TopoDS_Wire& W,
   Standard_Real tol = Max(1.2*FS.ToleranceReached(), FS.Tolerance());
 
   B.MakeFace(TopoDS::Face(myShape),FS.Surface(),FS.Location(),tol);
-  Add(W);
+
+  TopoDS_Wire aW;
+  if (OnlyPlane)
+  {
+    // get rid of degenerative edges in the input wire
+    BRep_Builder aB;
+    aB.MakeWire (aW);
+
+    TopoDS_Wire aWForw = W;
+    aWForw.Orientation (TopAbs_FORWARD);
+    TopoDS_Iterator anIter (aWForw);
+    for (; anIter.More(); anIter.Next())
+    {
+      const TopoDS_Edge& aE = TopoDS::Edge (anIter.Value());
+
+      if (!BRep_Tool::Degenerated (aE))
+        aB.Add (aW, aE);
+    }
+
+    aW.Orientation (W.Orientation()); // return to original orient
+    aW.Closed (W.Closed());
+  }
+  else
+  {
+    aW = W;
+  }
+
+  Add (aW);
   //
   BRepLib::UpdateTolerances(myShape);
   //
   BRepLib::SameParameter(myShape, tol, Standard_True);
   //
-  if (BRep_Tool::IsClosed(W))
+  if (BRep_Tool::IsClosed(aW))
     CheckInside();
 }
 

src/BRepMesh/BRepMesh_CurveTessellator.cxx

@@ -101,9 +101,21 @@ void BRepMesh_CurveTessellator::init()
   myEdgeSqTol  = BRep_Tool::Tolerance (myEdge);
   myEdgeSqTol *= myEdgeSqTol;
 
-  const Standard_Integer aMinPntNb = Max(myMinPointsNb,
-    (myCurve.GetType() == GeomAbs_Circle) ? 4 : 2); //OCC287
+  Standard_Integer aMinPntThreshold = 2;
+  switch (myCurve.GetType())
+  {
+    case GeomAbs_Circle:
+    case GeomAbs_Ellipse:
+    case GeomAbs_Parabola:
+    case GeomAbs_Hyperbola:
+      aMinPntThreshold = 4;
+      break;
 
+    default:
+      break;
+  }
+
+  const Standard_Integer aMinPntNb = Max (myMinPointsNb, aMinPntThreshold); //OCC287
   myDiscretTool.Initialize (myCurve,
                             myCurve.FirstParameter(), myCurve.LastParameter(),
                             aPreciseAngDef, aPreciseLinDef, aMinPntNb,

src/BRepOffset/BRepOffset_Analyse.cxx

@@ -41,6 +41,7 @@
 #include <TopoDS_Vertex.hxx>
 #include <TopTools_MapOfShape.hxx>
 #include <ChFi3d.hxx>
+#include <LocalAnalysis_SurfaceContinuity.hxx>
 
 static void CorrectOrientationOfTangent(gp_Vec& TangVec,
                                         const TopoDS_Vertex& aVertex,
@@ -50,6 +51,12 @@ static void CorrectOrientationOfTangent(gp_Vec& TangVec,
   if (aVertex.IsSame(Vlast))
     TangVec.Reverse();
 }
+
+static Standard_Boolean CheckMixedContinuity (const TopoDS_Edge&  theEdge,
+                                              const TopoDS_Face&  theFace1,
+                                              const TopoDS_Face&  theFace2,
+                                              const Standard_Real theAngTol);
+
 //=======================================================================
 //function : BRepOffset_Analyse
 //purpose  : 
@@ -105,15 +112,168 @@ static void EdgeAnalyse(const TopoDS_Edge&         E,
   }
   else
   {
-    if (ChFi3d::IsTangentFaces(E, F1, F2)) //weak condition
-      ConnectType = ChFiDS_Tangential;
+    Standard_Boolean isTwoSplines = (aSurfType1 == GeomAbs_BSplineSurface || aSurfType1 == GeomAbs_BezierSurface) &&
+                                    (aSurfType2 == GeomAbs_BSplineSurface || aSurfType2 == GeomAbs_BezierSurface);
+    Standard_Boolean isMixedConcavity = Standard_False;
+    if (isTwoSplines)
+    {
+      Standard_Real anAngTol = 0.1;
+      isMixedConcavity = CheckMixedContinuity(E, F1, F2, anAngTol);
+    }
+
+    if (!isMixedConcavity)
+    {
+      if (ChFi3d::IsTangentFaces(E, F1, F2)) //weak condition
+      {
+        ConnectType = ChFiDS_Tangential;
+      }
+      else
+      {
+        ConnectType = ChFi3d::DefineConnectType(E, F1, F2, SinTol, Standard_False);
+      }
+    }
     else
-      ConnectType = ChFi3d::DefineConnectType(E, F1, F2, SinTol, Standard_False);
+    {
+      ConnectType = ChFiDS_Mixed;
+    }
   }
    
   I.Type(ConnectType);
   LI.Append(I);
 }
+//=======================================================================
+//function : CheckMixedConcavity
+//purpose  : 
+//=======================================================================
+Standard_Boolean CheckMixedContinuity (const TopoDS_Edge&  theEdge,
+                                       const TopoDS_Face&  theFace1,
+                                       const TopoDS_Face&  theFace2,
+                                       const Standard_Real theAngTol)
+{
+  Standard_Boolean aMixedCont = Standard_False;
+  GeomAbs_Shape aCurrOrder = BRep_Tool::Continuity(theEdge, theFace1, theFace2);
+  if (aCurrOrder > GeomAbs_C0)
+  {
+    //Method BRep_Tool::Continuity(...) always returns minimal continuity between faces
+    //so, if aCurrOrder > C0 it means that faces are tangent along whole edge.
+    return aMixedCont;
+  }
+  //But we caqnnot trust result, if it is C0. because this value set by default.
+  Standard_Real TolC0 = Max(0.001, 1.5*BRep_Tool::Tolerance(theEdge));
+
+  Standard_Real aFirst;
+  Standard_Real aLast;
+
+  Handle(Geom2d_Curve) aC2d1, aC2d2;
+
+  if (!theFace1.IsSame(theFace2) &&
+    BRep_Tool::IsClosed(theEdge, theFace1) &&
+    BRep_Tool::IsClosed(theEdge, theFace2))
+  {
+    //Find the edge in the face 1: this edge will have correct orientation
+    TopoDS_Edge anEdgeInFace1;
+    TopoDS_Face aFace1 = theFace1;
+    aFace1.Orientation(TopAbs_FORWARD);
+    TopExp_Explorer anExplo(aFace1, TopAbs_EDGE);
+    for (; anExplo.More(); anExplo.Next())
+    {
+      const TopoDS_Edge& anEdge = TopoDS::Edge(anExplo.Current());
+      if (anEdge.IsSame(theEdge))
+      {
+        anEdgeInFace1 = anEdge;
+        break;
+      }
+    }
+    if (anEdgeInFace1.IsNull())
+    {
+      return aMixedCont;
+    }
+
+    aC2d1 = BRep_Tool::CurveOnSurface(anEdgeInFace1, aFace1, aFirst, aLast);
+    TopoDS_Face aFace2 = theFace2;
+    aFace2.Orientation(TopAbs_FORWARD);
+    anEdgeInFace1.Reverse();
+    aC2d2 = BRep_Tool::CurveOnSurface(anEdgeInFace1, aFace2, aFirst, aLast);
+  }
+  else
+  {
+    // Obtaining of pcurves of edge on two faces.
+    aC2d1 = BRep_Tool::CurveOnSurface(theEdge, theFace1, aFirst, aLast);
+    //For the case of seam edge
+    TopoDS_Edge EE = theEdge;
+    if (theFace1.IsSame(theFace2))
+    {
+      EE.Reverse();
+    }
+    aC2d2 = BRep_Tool::CurveOnSurface(EE, theFace2, aFirst, aLast);
+  }
+
+  if (aC2d1.IsNull() || aC2d2.IsNull())
+  {
+    return aMixedCont;
+  }
+
+  // Obtaining of two surfaces from adjacent faces.
+  Handle(Geom_Surface) aSurf1 = BRep_Tool::Surface(theFace1);
+  Handle(Geom_Surface) aSurf2 = BRep_Tool::Surface(theFace2);
+
+  if (aSurf1.IsNull() || aSurf2.IsNull())
+  {
+    return aMixedCont;
+  }
+
+  Standard_Integer aNbSamples = 23;
+
+  // Computation of the continuity.
+  Standard_Real    aPar;
+  Standard_Real    aDelta = (aLast - aFirst) / (aNbSamples - 1);
+  Standard_Integer i, istart = 1;
+  Standard_Boolean isG1 = Standard_False;
+
+  for (i = 1, aPar = aFirst; i <= aNbSamples; i++, aPar += aDelta) 
+  {
+    if (i == aNbSamples) aPar = aLast;
+
+    LocalAnalysis_SurfaceContinuity aCont(aC2d1, aC2d2, aPar,
+      aSurf1, aSurf2, GeomAbs_G1, 0.001, TolC0, theAngTol, theAngTol, theAngTol);
+    if (aCont.IsDone())
+    {
+      istart = i + 1;
+      isG1 = aCont.IsG1();
+      break;
+    }
+  }
+
+  if (istart > aNbSamples / 2)
+  {
+    return aMixedCont;
+  }
+
+  for (i = istart, aPar = aFirst; i <= aNbSamples; i++, aPar += aDelta) 
+  {
+    if (i == aNbSamples) aPar = aLast;
+
+    LocalAnalysis_SurfaceContinuity aCont(aC2d1, aC2d2, aPar,
+      aSurf1, aSurf2, GeomAbs_G1, 0.001, TolC0, theAngTol, theAngTol, theAngTol);
+    if (!aCont.IsDone())
+    {
+      continue;
+    }
+
+    if (aCont.IsG1() == isG1)
+    {
+      continue;
+    }
+    else
+    {
+       aMixedCont = Standard_True;
+       break;
+    }
+  }
+
+  return aMixedCont;
+
+}
 
 //=======================================================================
 //function : BuildAncestors

src/BRepOffset/BRepOffset_Error.hxx

@@ -29,7 +29,8 @@ enum BRepOffset_Error
   BRepOffset_CannotTrimEdges,        //!< exception while trim edges
   BRepOffset_CannotFuseVertices,     //!< exception while fuse vertices
   BRepOffset_CannotExtentEdge,       //!< exception while extent edges
-  BRepOffset_UserBreak               //!< user break
+  BRepOffset_UserBreak,              //!< user break
+  BRepOffset_MixedConnectivity       //!< Different connectivity of faces along edge: partially C0 and tangent
 };
 
 #endif // _BRepOffset_Error_HeaderFile

src/BRepOffset/BRepOffset_MakeOffset.cxx

@@ -910,6 +910,19 @@ void BRepOffset_MakeOffset::MakeOffsetShape(const Message_ProgressRange& theRang
     myAnalyse.SetFaceOffsetMap (myFaceOffset);
   }
   myAnalyse.Perform(myFaceComp,TolAngle, aPS.Next(aSteps(PIOperation_Analyse)));
+  TopExp_Explorer anEExp(myFaceComp, TopAbs_EDGE);
+  for (; anEExp.More(); anEExp.Next())
+  {
+    const TopoDS_Edge& anE = TopoDS::Edge(anEExp.Current());
+    const BRepOffset_ListOfInterval& aLI = myAnalyse.Type(anE);
+    if (aLI.IsEmpty())
+      continue;
+    if (aLI.Last().Type() == ChFiDS_Mixed)
+    {
+      myError = BRepOffset_MixedConnectivity;
+      return;
+    }
+  }
   if (!aPS.More())
   {
     myError = BRepOffset_UserBreak;
@@ -2960,6 +2973,36 @@ void BRepOffset_MakeOffset::MakeMissingWalls (const Message_ProgressRange& theRa
       TopExp::Vertices(anEdge, V1, V2);
       Standard_Real aF, aL;
       const Handle(Geom_Curve) aC = BRep_Tool::Curve(anEdge, aF, aL);
+      if (V3.IsNull() && V4.IsNull())
+      {
+        // Initially offset edge is created without vertices.
+        // Then edge is trimmed by intersection line between  
+        // two adjacent extended offset faces and get vertices.
+        // When intersection lines are invalid for any reason, 
+        // (one of reson is mixed connectivity of faces)
+        // algoritm of cutting offset edge by intersection line 
+        // can fail and offset edge cannot get vertices.
+        // Follwing workaround is only to avoid exeption if V3 and V4 are Null
+        // Vertex points are invalid.
+        Standard_Real anOEF, anOEL;
+        TopAbs_Orientation anOEOri = OE.Orientation();
+        OE.Orientation(TopAbs_FORWARD);
+        Handle(Geom_Curve) anOEC = BRep_Tool::Curve(OE, anOEF, anOEL);
+        BRep_Builder aBB;
+        gp_Pnt aP1 = anOEC->Value(aF);
+        gp_Pnt aP2 = anOEC->Value(aL);
+        TopoDS_Vertex anOEV1, anOEV2;
+        Standard_Real aTol = Max(BRep_Tool::Tolerance(V1), BRep_Tool::Tolerance(V2));
+        aBB.MakeVertex(anOEV1, aP1, aTol);
+        anOEV1.Orientation(TopAbs_FORWARD);
+        aBB.MakeVertex(anOEV2, aP2, aTol);
+        anOEV2.Orientation(TopAbs_REVERSED);
+        aBB.Add(OE, anOEV1);
+        aBB.Add(OE, anOEV2);
+        aBB.Range(OE, aF, aL);
+        OE.Orientation(anOEOri);
+        TopExp::Vertices(OE, V4, V3);
+      }
       if (!aC.IsNull() &&
          (!aC->IsClosed() && !aC->IsPeriodic()))
       {

src/BRepOffset/BRepOffset_MakeOffset_1.cxx

@@ -5225,7 +5225,6 @@ void BRepOffset_BuildOffsetFaces::FilterInvalidEdges (const BRepOffset_DataMapOf
     const TopTools_ListOfShape* pEOrigins = myOEOrigins.Seek (aE);
     if (!pEOrigins)
     {
-      theMEUseInRebuild.Add (aE);
       continue;
     }
 
@@ -5393,6 +5392,29 @@ void BRepOffset_BuildOffsetFaces::FindFacesToRebuild()
   }
 }
 
+
+namespace
+{
+//=======================================================================
+//function : mapShapes
+//purpose  : Collect theVecShapes into theMap with setted theType
+//=======================================================================
+  template<class Container>
+  static void mapShapes (const Container& theVecShapes, 
+                         const TopAbs_ShapeEnum theType,
+                         TopTools_MapOfShape& theMap)
+  {
+    for (const auto& aShape : theVecShapes)
+    {
+      for (TopExp_Explorer anExp(aShape, theType); anExp.More(); anExp.Next())
+      {
+        theMap.Add(anExp.Current());
+      }
+    }
+  }
+}
+
+
 //=======================================================================
 //function : IntersectFaces
 //purpose  : Intersection of the faces that should be rebuild to resolve all invalidities
@@ -5715,7 +5737,10 @@ void BRepOffset_BuildOffsetFaces::IntersectFaces (TopTools_MapOfShape& theVertsT
       TopoDS_Compound aCBE;
       aBB.MakeCompound (aCBE);
       //
-      TopExp_Explorer aExp (aCBInv, TopAbs_EDGE);
+      // remember inside edges and vertices to further check
+      TopTools_MapOfShape anInsideEdges;
+      TopTools_MapOfShape anInsideVertices;
+      TopExp_Explorer aExp(aCBInv, TopAbs_EDGE);
       for (; aExp.More(); aExp.Next())
       {
         const TopoDS_Shape& aE = aExp.Current();
@@ -5724,6 +5749,15 @@ void BRepOffset_BuildOffsetFaces::IntersectFaces (TopTools_MapOfShape& theVertsT
           if (aMEFence.Add (aE))
           {
             aBB.Add (aCBE, aE);
+            if (!myEdgesToAvoid.Contains(aE) && myInvalidEdges.Contains(aE))
+            {
+              anInsideEdges.Add(aE);
+              TopoDS_Iterator anIt(aE);
+              for (; anIt.More(); anIt.Next())
+              {
+                anInsideVertices.Add(anIt.Value());
+              }
+            }
           }
         }
       }
@@ -5749,10 +5783,6 @@ void BRepOffset_BuildOffsetFaces::IntersectFaces (TopTools_MapOfShape& theVertsT
         TopExp::MapShapes (aCBELoc, TopAbs_EDGE, aME);
         aMECV = aME;
         TopExp::MapShapes (aCBELoc, TopAbs_VERTEX, aME);
-        //
-        // Using the map <aME> find chain of faces to be intersected;
-        //
-        // faces for intersection
         TopTools_IndexedMapOfShape aMFInt;
         // additional faces for intersection
         TopTools_IndexedMapOfShape aMFIntExt;
@@ -5801,6 +5831,14 @@ void BRepOffset_BuildOffsetFaces::IntersectFaces (TopTools_MapOfShape& theVertsT
           if (pMFInter && !pInterFi)
             continue;
 
+          // create map of edges and vertices for aLFImi
+          TopTools_MapOfShape  aMEVIm;
+          mapShapes(*aLFImi, TopAbs_EDGE, aMEVIm);
+          mapShapes(*aLFImi, TopAbs_VERTEX, aMEVIm);
+
+          Standard_Boolean isIContainsE = aMEVIm.HasIntersection(anInsideEdges);
+          Standard_Boolean isIContainsV = aMEVIm.HasIntersection(anInsideVertices);
+
           for (j = i + 1; j <= aNb; ++j)
           {
             const TopoDS_Face& aFj = TopoDS::Face (aMFInt (j));
@@ -5820,6 +5858,28 @@ void BRepOffset_BuildOffsetFaces::IntersectFaces (TopTools_MapOfShape& theVertsT
             if (!aLFEj)
               continue;
 
+            // create map of edges and vertices for aLFImi
+            aMEVIm.Clear();
+            mapShapes(*aLFImj, TopAbs_EDGE, aMEVIm);
+            mapShapes(*aLFImj, TopAbs_VERTEX, aMEVIm);
+            // check images of both faces contain anInsideEdges and anInsideVertices
+            // not process if false and true 
+            Standard_Boolean isJContainsE = aMEVIm.HasIntersection(anInsideEdges);
+            Standard_Boolean isJContainsV = aMEVIm.HasIntersection(anInsideVertices);
+
+            // Check if one face is connected to inside edge then
+            // the other must be also connected
+            if ((isIContainsE && !isJContainsV) ||
+                (isJContainsE && !isIContainsV))
+            {
+              TopTools_ListOfShape aLVC;
+              // it is necessary to process the images if they already have 
+              // common vertices
+              FindCommonParts(*aLFImi, *aLFImj, aLVC, TopAbs_VERTEX);
+
+              if (aLVC.IsEmpty())
+                continue;
+            }
             //
             // if there are some common edges between faces
             // we should use these edges and do not intersect again.

src/BRepOffsetAPI/BRepOffsetAPI_ThruSections.cxx

@@ -262,6 +262,7 @@ BRepOffsetAPI_ThruSections::BRepOffsetAPI_ThruSections(const Standard_Boolean is
   myCritWeights[1] = .2; 
   myCritWeights[2] = .4; 
   myUseSmoothing = Standard_False;
+  myStatus = BRepFill_ThruSectionErrorStatus_NotDone;
 }
 
 
@@ -286,7 +287,7 @@ void BRepOffsetAPI_ThruSections::Init(const Standard_Boolean isSolid, const Stan
   myCritWeights[1] = .2; 
   myCritWeights[2] = .4; 
   myUseSmoothing = Standard_False;
-
+  myStatus = BRepFill_ThruSectionErrorStatus_NotDone;
 }
 
 
@@ -343,6 +344,7 @@ void BRepOffsetAPI_ThruSections::CheckCompatibility(const Standard_Boolean check
 
 void BRepOffsetAPI_ThruSections::Build(const Message_ProgressRange& /*theRange*/)
 {
+  myStatus = BRepFill_ThruSectionErrorStatus_Done;
   myBFGenerator.Nullify();
   //Check set of section for right configuration of punctual sections
   Standard_Integer i;
@@ -356,7 +358,10 @@ void BRepOffsetAPI_ThruSections::Build(const Message_ProgressRange& /*theRange*/
       wdeg = wdeg && (BRep_Tool::Degenerated(anEdge));
     }
     if (wdeg)
-      throw Standard_Failure("Wrong usage of punctual sections");
+    {
+      myStatus = BRepFill_ThruSectionErrorStatus_WrongUsage;
+      return;
+    }
   }
   if (myWires.Length() <= 2)
   {
@@ -371,7 +376,8 @@ void BRepOffsetAPI_ThruSections::Build(const Message_ProgressRange& /*theRange*/
     }
     if (wdeg)
     {
-      throw Standard_Failure("Wrong usage of punctual sections");
+      myStatus = BRepFill_ThruSectionErrorStatus_WrongUsage;
+      return;
     }
   }
 
@@ -447,6 +453,13 @@ void BRepOffsetAPI_ThruSections::Build(const Message_ProgressRange& /*theRange*/
         }
       }
     }
+    else
+    {
+      myStatus = Georges.GetStatus();
+      NotDone();
+      return;
+    }
+
     myWires = WorkingSections;
   } //if (myWCheck)
   else //no check
@@ -498,6 +511,12 @@ void BRepOffsetAPI_ThruSections::Build(const Message_ProgressRange& /*theRange*/
     NotDone();
     return;
   }
+
+  if (myStatus != BRepFill_ThruSectionErrorStatus_Done)
+  {
+    NotDone();
+    return;
+  }
   // Encode the Regularities
   BRepLib::EncodeRegularity(myShape);
 }
@@ -520,6 +539,12 @@ void BRepOffsetAPI_ThruSections::CreateRuled()
     myBFGenerator->AddWire(TopoDS::Wire(myWires(i)));
   }
   myBFGenerator->Perform();
+  BRepFill_ThruSectionErrorStatus aStatus = myBFGenerator->GetStatus();
+  if (aStatus != BRepFill_ThruSectionErrorStatus_Done)
+  {
+    myStatus = aStatus;
+    return;
+  }
   TopoDS_Shell shell = myBFGenerator->Shell();
 
   if (myIsSolid) {
@@ -739,6 +764,7 @@ void BRepOffsetAPI_ThruSections::CreateSmoothed()
   TS = TotalSurf(shapes,nbSects,nbEdges,w1Point,w2Point,vClosed);
 
   if(TS.IsNull()) {
+    myStatus = BRepFill_ThruSectionErrorStatus_Failed;
     return;
   }
 
@@ -934,14 +960,12 @@ void BRepOffsetAPI_ThruSections::CreateSmoothed()
     else {
       myShape = MakeSolid(shell, newW1, newW2, myPres3d, myFirst, myLast);
     }
-
-    Done();
   }
 
   else {
     myShape = shell;
-    Done();
   }
+  Done();
 
   TopTools_DataMapOfShapeReal aVertexToleranceMap;
   TopExp_Explorer aTopExplorer(myShape,TopAbs_EDGE);
@@ -1040,7 +1064,9 @@ static Handle(Geom_BSplineCurve) EdgeToBSpline (const TopoDS_Edge& theEdge)
     Standard_Real aFirst, aLast;
     Handle(Geom_Curve) aCurve = BRep_Tool::Curve (theEdge, aLoc, aFirst, aLast);
     if (aCurve.IsNull())
-      throw Standard_NullObject("Null 3D curve in edge");
+    {
+      return nullptr;
+    }
 
     // convert its part used by edge to bspline; note that if edge curve is bspline,
     // conversion made via trimmed curve is still needed -- it will copy it, segment 
@@ -1132,6 +1158,10 @@ Handle(Geom_BSplineSurface) BRepOffsetAPI_ThruSections::
       // read the first edge to initialise CompBS;
       TopoDS_Edge aPrevEdge = TopoDS::Edge (shapes((j-1)*NbEdges+1));
       Handle(Geom_BSplineCurve) curvBS = EdgeToBSpline (aPrevEdge);
+      if (curvBS.IsNull())
+      {
+        return nullptr;
+      }
 
       // initialization
       GeomConvert_CompCurveToBSplineCurve CompBS(curvBS);
@@ -1145,6 +1175,10 @@ Handle(Geom_BSplineSurface) BRepOffsetAPI_ThruSections::
         aTolV = Max(aTolV, BRep_Tool::Tolerance(vl));
         aTolV = Min(aTolV, 1.e-3);
         curvBS = EdgeToBSpline (aNextEdge);
+        if (curvBS.IsNull())
+        {
+          return nullptr;
+        }
 
         // concatenation
         CompBS.Add(curvBS, aTolV, Standard_True, Standard_False, 1);
@@ -1503,7 +1537,11 @@ void BRepOffsetAPI_ThruSections::CriteriumWeight(Standard_Real& W1, Standard_Rea
 
 void BRepOffsetAPI_ThruSections::SetCriteriumWeight(const Standard_Real W1, const Standard_Real W2, const Standard_Real W3)
 {
-  if (W1 < 0 || W2 < 0 || W3 < 0 ) throw Standard_DomainError();
+  if (W1 < 0 || W2 < 0 || W3 < 0)
+  {
+    myStatus = BRepFill_ThruSectionErrorStatus_Failed;
+    return;
+  }
   myCritWeights[0] = W1;
   myCritWeights[1] = W2;
   myCritWeights[2] = W3;

src/BRepOffsetAPI/BRepOffsetAPI_ThruSections.hxx

@@ -21,6 +21,7 @@
 #include <Standard_DefineAlloc.hxx>
 #include <Standard_Handle.hxx>
 
+#include <BRepFill_ThruSectionErrorStatus.hxx>
 #include <TopTools_SequenceOfShape.hxx>
 #include <TopoDS_Face.hxx>
 #include <TopTools_DataMapOfShapeShape.hxx>
@@ -163,6 +164,11 @@ public:
   //! Returns the current mutable input state
   Standard_EXPORT Standard_Boolean IsMutableInput() const;
   
+  //! Returns the status of thrusection operation
+  BRepFill_ThruSectionErrorStatus GetStatus() const
+  {
+    return myStatus;
+  }
 
 protected:
 
@@ -206,6 +212,7 @@ private:
   Standard_Boolean myUseSmoothing;
   Standard_Boolean myMutableInput;
   NCollection_Handle<BRepFill_Generator> myBFGenerator;
+  BRepFill_ThruSectionErrorStatus myStatus;
 
 };
 

src/BRepTest/BRepTest_CurveCommands.cxx

@@ -281,9 +281,11 @@ static Standard_Integer mkedge(Draw_Interpretor& di, Standard_Integer n, const c
 
   Handle(Geom_Curve)   C   = DrawTrSurf::GetCurve(a[2]);
   Handle(Geom2d_Curve) C2d = DrawTrSurf::GetCurve2d(a[2]);
-  if (C.IsNull() && C2d.IsNull()) {
+  Handle(Poly_Polygon3D) P3d = DrawTrSurf::GetPolygon3D(a[2]);
+
+  if (C.IsNull() && C2d.IsNull() && P3d.IsNull()) {
     //std::cout << a[2] << " is not a curve" << std::endl;
-    di << a[2] << " is not a curve\n";
+    di << a[2] << " is not a curve or polygon 3d\n";
     return 1;
   }
 
@@ -291,7 +293,12 @@ static Standard_Integer mkedge(Draw_Interpretor& di, Standard_Integer n, const c
 
   if (n == 3) {
     if (!C.IsNull())   edge = BRepBuilderAPI_MakeEdge(C);
-    else               edge = BRepBuilderAPI_MakeEdge2d(C2d);
+    else  if (!C2d.IsNull())  edge = BRepBuilderAPI_MakeEdge2d(C2d);
+    else
+    {
+      BRep_Builder aBB;
+      aBB.MakeEdge(edge, P3d);
+    }
   }
   else {
     Handle(Geom_Surface) S;

src/BRepTest/BRepTest_FeatureCommands.cxx

@@ -112,6 +112,7 @@ static Standard_Boolean pidef = Standard_False;
 static Standard_Boolean lfdef = Standard_False;
 static Standard_Boolean rfdef = Standard_False;
 
+static Standard_Real tesp = 1.0e-4;
 static Standard_Real t3d = 1.e-4;
 static Standard_Real t2d = 1.e-5;
 static Standard_Real ta = 1.e-2;
@@ -414,6 +415,11 @@ static void reportOffsetState(Draw_Interpretor& theCommands,
     theCommands << "ERROR. Can not extent edge.";
     break;
   }
+  case  BRepOffset_MixedConnectivity:
+  {
+    theCommands << "ERROR. Mixed connectivity of faces.";
+    break;
+  }
   default:
   {
     theCommands << "ERROR. offsetperform operation not done.";
@@ -973,7 +979,10 @@ Standard_Integer thickshell(Draw_Interpretor& theCommands,
   const BRepOffset_Error aRetCode = B.Error();
   reportOffsetState(theCommands, aRetCode);
 
-  DBRep::Set(a[1], B.Shape());
+  if (!B.Shape().IsNull())
+  {
+    DBRep::Set(a[1], B.Shape());
+  }
   return 0;
 }
 
@@ -1108,7 +1117,10 @@ Standard_Integer offsetshape(Draw_Interpretor& theCommands,
   const BRepOffset_Error aRetCode = B.Error();
   reportOffsetState(theCommands, aRetCode);
 
-  DBRep::Set(a[1], B.Shape());
+  if (!B.Shape().IsNull())
+  {
+    DBRep::Set(a[1], B.Shape());
+  }
 
   return 0;
 }
@@ -2361,7 +2373,7 @@ static Standard_Integer BOSS(Draw_Interpretor& theCommands,
     if (Rakk)
       delete Rakk;
     Rakk = new BRepFilletAPI_MakeFillet(V, FSh);
-    Rakk->SetParams(ta, t3d, t2d, t3d, t2d, fl);
+    Rakk->SetParams(ta, tesp, t2d, t3d, t2d, fl);
     Rakk->SetContinuity(blend_cont, tapp_angle);
     Standard_Real Rad;
     TopoDS_Shape S;

src/BRepTest/BRepTest_FilletCommands.cxx

@@ -47,7 +47,7 @@
 
 #include <stdio.h>
 
-
+static Standard_Real tesp = 1.0e-4;
 static Standard_Real t3d = 1.e-4;
 static Standard_Real t2d = 1.e-5;
 static Standard_Real ta  = 1.e-2;
@@ -152,7 +152,7 @@ static Standard_Integer BLEND(Draw_Interpretor& di, Standard_Integer narg, const
     }
   }
   Rakk = new BRepFilletAPI_MakeFillet(V,FSh);
-  Rakk->SetParams(ta,t3d,t2d,t3d,t2d,fl);
+  Rakk->SetParams(ta, tesp, t2d, t3d, t2d, fl);
   Rakk->SetContinuity(blend_cont, tapp_angle);
   Standard_Real Rad;
   TopoDS_Edge E;
@@ -254,7 +254,7 @@ static Standard_Integer MKEVOL(Draw_Interpretor& di,
   if (narg < 3) return 1;
   TopoDS_Shape V = DBRep::Get(a[2]);
   Rake = new BRepFilletAPI_MakeFillet(V);
-  Rake->SetParams(ta,t3d,t2d,t3d,t2d,fl);
+  Rake->SetParams(ta, tesp, t2d, t3d, t2d, fl);
   Rake->SetContinuity(blend_cont, tapp_angle);
   if (narg == 4) {
     ChFi3d_FilletShape FSh = ChFi3d_Rational;
@@ -410,7 +410,7 @@ Standard_Integer boptopoblend(Draw_Interpretor& di, Standard_Integer narg, const
     const TopoDS_Shape& aSolid = Explo.Current();
 
     BRepFilletAPI_MakeFillet Blender(aSolid);
-    Blender.SetParams(ta,t3d,t2d,t3d,t2d,fl);
+    Blender.SetParams(ta, tesp, t2d, t3d, t2d, fl);
     Blender.SetContinuity( blend_cont, tapp_angle );
 
     TopExp_Explorer expsec( theSection, TopAbs_EDGE );

src/BRepTest/BRepTest_SweepCommands.cxx

@@ -443,7 +443,7 @@ Standard_Integer gener(Draw_Interpretor&, Standard_Integer n, const char** a)
 //purpose  : 
 //=======================================================================
 
-Standard_Integer thrusections(Draw_Interpretor&, Standard_Integer n, const char** a)
+Standard_Integer thrusections(Draw_Interpretor& di, Standard_Integer n, const char** a)
 {
   if (n < 6) return 1;
 
@@ -525,7 +525,30 @@ Standard_Integer thrusections(Draw_Interpretor&, Standard_Integer n, const char*
       BRepTest_Objects::SetHistory(Generator->Wires(), *Generator);
   }
   else {
-    std::cout << "Algorithm is not done" << std::endl;
+    BRepFill_ThruSectionErrorStatus aStatus = Generator->GetStatus();
+    switch (aStatus)
+    {
+    case BRepFill_ThruSectionErrorStatus_NotDone:
+      di << "Algorithm is not done\n";
+      break;
+    case BRepFill_ThruSectionErrorStatus_NotSameTopology:
+      di << "The input profiles should be all closed or all opened\n";
+      break;
+    case BRepFill_ThruSectionErrorStatus_ProfilesInconsistent:
+      di << "Profiles inconsistent\n";
+      break;
+    case BRepFill_ThruSectionErrorStatus_WrongUsage:
+      di << "Wrong usage of punctual sections\n";
+      break;
+    case BRepFill_ThruSectionErrorStatus_Null3DCurve:
+      di << "Some edges have null 3d curve";
+      break;
+    case BRepFill_ThruSectionErrorStatus_Failed:
+      di << "Algorithm has failed\n";
+      break;
+    default:
+      break;
+    }
   }
 
   return 0;

src/Blend/Blend_CSWalking_1.gxx

@@ -28,9 +28,9 @@ void Blend_CSWalking::Perform(Blend_CSFunction& Func,
 			      const Standard_Real Pdep,   
 			      const Standard_Real Pmax,
 			      const Standard_Real MaxStep,
+            const Standard_Real Tol3d,
 			      const Standard_Real TolGuide,
 			      const math_Vector& ParDep,
-			      const Standard_Real Tolesp,
 			      const Standard_Real Fleche,
 			      const Standard_Boolean Appro)
 {
@@ -40,7 +40,7 @@ void Blend_CSWalking::Perform(Blend_CSFunction& Func,
   comptra = Standard_False;
   line = new TheLine ();
   Standard_Integer Nbvar = Func.NbVariables();
-  tolesp = Abs(Tolesp);
+  tolpoint3d = Tol3d;
   tolgui = Abs(TolGuide);
   fleche = Abs(Fleche);
   rebrou = Standard_False;
@@ -68,7 +68,7 @@ void Blend_CSWalking::Perform(Blend_CSFunction& Func,
     TopAbs_State situ;
 //    math_Vector tolerance(1,3),infbound(1,3),supbound(1,3);
     math_Vector tolerance(1,Nbvar),infbound(1,Nbvar),supbound(1,Nbvar);
-    Func.GetTolerance(tolerance,tolesp);
+    Func.GetTolerance(tolerance,tolpoint3d);
     Func.GetBounds(infbound,supbound);
     math_FunctionSetRoot rsnld(Func,tolerance,30);
 
@@ -115,8 +115,8 @@ void Blend_CSWalking::Perform(Blend_CSFunction& Func,
   Standard_Real U,V,W;
   previousP.ParametersOnS(U,V);
   W = previousP.ParameterOnC();
-  TheExtremity P1(previousP.PointOnS(),U,V,previousP.Parameter(),tolesp);
-  TheExtremity P2(previousP.PointOnC(),W,previousP.Parameter(),tolesp);
+  TheExtremity P1(previousP.PointOnS(),U,V,previousP.Parameter(),tolpoint3d);
+  TheExtremity P2(previousP.PointOnC(),W,previousP.Parameter(),tolpoint3d);
   if (sens>0.) {
     line->SetStartPoints(P1,P2);
   }

src/Blend/Blend_CSWalking_2.gxx

@@ -39,7 +39,7 @@ Blend_Status Blend_CSWalking::TestArret(Blend_CSFunction& Function,
   Blend_Status State1,State2;
   IntSurf_TypeTrans tras = IntSurf_Undecided;
 
-  if (Function.IsSolution(Sol,tolesp)) {
+  if (Function.IsSolution(Sol,tolpoint3d)) {
 
     pt1  = Function.PointOnS();
     pt2  = Function.PointOnC();
@@ -176,15 +176,16 @@ Blend_Status Blend_CSWalking::CheckDeflectionOnSurf
 
   prevP = previousP.PointOnS();
   prevTg = previousP.TangentOnS();
-  tolu = TheSurfaceTool::UResolution(surf,tolesp);
-  tolv = TheSurfaceTool::VResolution(surf,tolesp);
+  tolu = TheSurfaceTool::UResolution(surf,tolpoint3d);
+  tolv = TheSurfaceTool::VResolution(surf,tolpoint3d);
 
   gp_Vec Corde(prevP,Psurf);
   Norme = Corde.SquareMagnitude();
   prevNorme = prevTg.SquareMagnitude(); // JAG MODIF 25.04.94
 
 
-  if (Norme <= tolesp*tolesp || prevNorme <= tolesp*tolesp) { // JAG MODIF 25.04.94
+  const Standard_Real toler3d = tolpoint3d;
+  if (Norme <= toler3d * toler3d || prevNorme <= toler3d * toler3d) { // JAG MODIF 25.04.94
     // il faudra peut etre  forcer meme point  JAG MODIF 25.04.94
     return Blend_SamePoints;
   }
@@ -275,19 +276,20 @@ Blend_Status Blend_CSWalking::CheckDeflectionOnCurv
 
   prevP = previousP.PointOnC();
   prevTg = previousP.TangentOnC();
-  tolu = TheCurveTool::Resolution(curv,tolesp);
+  tolu = TheCurveTool::Resolution(curv,tolpoint3d);
 
   gp_Vec Corde(prevP,Pcurv);
   Norme = Corde.SquareMagnitude();
   prevNorme = prevTg.SquareMagnitude(); // JAG MODIF 25.04.94
 
 
+  const Standard_Real toler3d = tolpoint3d;
 // if (Norme <= tolesp*tolesp || prevNorme <= tolesp*tolesp) { // JAG MODIF 25.04.94
-  if (Norme <= tolesp*tolesp) { // le 95.01.10
+  if (Norme <= toler3d * toler3d) { // le 95.01.10
     // il faudra peut etre  forcer meme point  JAG MODIF 25.04.94
     return Blend_SamePoints;
   }
-  else if (prevNorme > tolesp*tolesp) {
+  else if (prevNorme > toler3d * toler3d) {
     Cosi = sens*Corde*prevTg;
     if (Cosi <0.) { // angle 3d>pi/2. --> retour arriere
       return Blend_Backward;
@@ -308,7 +310,7 @@ Blend_Status Blend_CSWalking::CheckDeflectionOnCurv
 
   // Voir s il faut faire le controle sur le signe de prevtg*Tgsurf
 
-  if (Tgcurv.Magnitude() <= tolesp) {
+  if (Tgcurv.Magnitude() <= tolpoint3d) {
     return Blend_SamePoints; // GROS BOBARD EN ATTENDANT
   }
 
@@ -318,7 +320,7 @@ Blend_Status Blend_CSWalking::CheckDeflectionOnCurv
     return Blend_StepTooLarge;
   }
 
-  if (prevNorme > tolesp*tolesp) {
+  if (prevNorme > toler3d * toler3d) {
 
     // Estimation de la fleche courante
 /*    

src/Blend/Blend_CSWalking_3.gxx

@@ -205,7 +205,7 @@ void Blend_CSWalking::MakeExtremity(TheExtremity& Extrem,
 
 //  Extrem.SetValue(previousP.PointOnS(),sol(1),sol(2),tolesp);
   previousP.ParametersOnS(U,V);
-  Extrem.SetValue(previousP.PointOnS(),U,V,previousP.Parameter(),tolesp);
+  Extrem.SetValue(previousP.PointOnS(),U,V,previousP.Parameter(),tolpoint3d);
   Iter = domain;
 
 

src/Blend/Blend_CSWalking_4.gxx

@@ -40,7 +40,7 @@ void Blend_CSWalking::InternalPerform(Blend_CSFunction& Func,
 
   //IntSurf_Transition Tline,Tarc;
 
-  Func.GetTolerance(tolerance,tolesp);
+  Func.GetTolerance(tolerance,tolpoint3d);
   Func.GetBounds(infbound,supbound);
 
   math_FunctionSetRoot rsnld(Func,tolerance,30);
@@ -146,9 +146,9 @@ void Blend_CSWalking::InternalPerform(Blend_CSFunction& Func,
 */
 	  previousP.ParametersOnS(U,V);
 	  Exts.SetValue(previousP.PointOnS(),U,V, 
-			previousP.Parameter(),tolesp);
+			previousP.Parameter(),tolpoint3d);
 	  Extc.SetValue(previousP.PointOnC(),previousP.ParameterOnC(),
-			previousP.Parameter(),tolesp);
+			previousP.Parameter(),tolpoint3d);
 	  // Indiquer que fin sur Bound.
 	}
 	else {
@@ -171,9 +171,9 @@ void Blend_CSWalking::InternalPerform(Blend_CSFunction& Func,
 */
 	  previousP.ParametersOnS(U,V);
 	  Exts.SetValue(previousP.PointOnS(),U,V,
-			previousP.Parameter(),tolesp);
+			previousP.Parameter(),tolpoint3d);
 	  Extc.SetValue(previousP.PointOnC(),previousP.ParameterOnC(),
-			previousP.Parameter(),tolesp);
+			previousP.Parameter(),tolpoint3d);
 	  Arrive = Standard_True;
 	  if (line->NbPoints()>=2) {
 	    // Indiquer qu on s arrete en cours de cheminement
@@ -214,9 +214,9 @@ void Blend_CSWalking::InternalPerform(Blend_CSFunction& Func,
 */
 	  previousP.ParametersOnS(U,V);
 	  Exts.SetValue(previousP.PointOnS(),U,V,
-			previousP.Parameter(),tolesp);
+			previousP.Parameter(),tolpoint3d);
 	  Extc.SetValue(previousP.PointOnC(),previousP.ParameterOnC(),
-			previousP.Parameter(),tolesp);
+			previousP.Parameter(),tolpoint3d);
 	  // Indiquer que fin sur Bound.
 	}
 	else {
@@ -244,7 +244,7 @@ void Blend_CSWalking::InternalPerform(Blend_CSFunction& Func,
 	MakeExtremity(Exts,Index,solrst(1),Isvtx,Vtx);
 //	Extc.SetValue(previousP.PointOnC(),sol(3),tolesp);
 	Extc.SetValue(previousP.PointOnC(),previousP.ParameterOnC(),
-		      previousP.Parameter(),tolesp);
+		      previousP.Parameter(),tolpoint3d);
 	Arrive = Standard_True;
       }
       break;
@@ -259,9 +259,9 @@ void Blend_CSWalking::InternalPerform(Blend_CSFunction& Func,
 */
 	previousP.ParametersOnS(U,V);
 	Exts.SetValue(previousP.PointOnS(),U,V,
-		      previousP.Parameter(),tolesp);
+		      previousP.Parameter(),tolpoint3d);
 	Extc.SetValue(previousP.PointOnC(),previousP.ParameterOnC(),
-		      previousP.Parameter(),tolesp);
+		      previousP.Parameter(),tolpoint3d);
 	Arrive = Standard_True;
       }
       break;

src/Blend/Blend_Walking_1.gxx

@@ -62,9 +62,9 @@ void Blend_Walking::Perform(Blend_Function& Func,
 			    const Standard_Real Pdep,   
 			    const Standard_Real Pmax,
 			    const Standard_Real MaxStep,
+          const Standard_Real Tol3d,
 			    const Standard_Real TolGuide,
 			    const math_Vector& ParDep,
-			    const Standard_Real Tolesp,
 			    const Standard_Real Fleche,
 			    const Standard_Boolean Appro)
 {
@@ -75,7 +75,7 @@ void Blend_Walking::Perform(Blend_Function& Func,
   Standard_Boolean doextremities = 1;
   if(line.IsNull()) line = new TheLine ();
   else {line->Clear();doextremities = 0;}
-  tolesp = Abs(Tolesp);
+  tolpoint3d = Tol3d;
   tolgui = Abs(TolGuide);
   fleche = Abs(Fleche);
   rebrou = Standard_False;
@@ -96,7 +96,7 @@ void Blend_Walking::Perform(Blend_Function& Func,
 
     TopAbs_State situ1,situ2;
     math_Vector tolerance(1,4),infbound(1,4),supbound(1,4);
-    Func.GetTolerance(tolerance,tolesp);
+    Func.GetTolerance(tolerance,tolpoint3d);
     Func.GetBounds(infbound,supbound);
     math_FunctionSetRoot rsnld(Func,tolerance,30);
 
@@ -143,9 +143,9 @@ void Blend_Walking::Perform(Blend_Function& Func,
 
   if(doextremities){
     TheExtremity ptf1 (previousP.PointOnS1(),
-		       sol(1),sol(2),tolesp);
+		       sol(1),sol(2),tolpoint3d);
     TheExtremity ptf2 (previousP.PointOnS2(),
-		       sol(3),sol(4),tolesp);
+		       sol(3),sol(4),tolpoint3d);
     if (!previousP.IsTangencyPoint()) {
       ptf1.SetTangent(previousP.TangentOnS1());
       ptf2.SetTangent(previousP.TangentOnS2());
@@ -168,7 +168,7 @@ void Blend_Walking::Perform(Blend_Function& Func,
 Standard_Boolean Blend_Walking::PerformFirstSection(Blend_Function&     Func,
                                                     const Standard_Real Pdep,
                                                     math_Vector&        ParDep,
-                                                    const Standard_Real Tolesp,
+                                                    const Standard_Real Tol3d,
                                                     const Standard_Real TolGuide,
                                                     TopAbs_State&       Pos1,
                                                     TopAbs_State&       Pos2)
@@ -176,7 +176,7 @@ Standard_Boolean Blend_Walking::PerformFirstSection(Blend_Function&     Func,
   iscomplete = Standard_False;
   comptra = Standard_False;
   line = new TheLine ();
-  tolesp = Abs(Tolesp);
+  tolpoint3d = Tol3d;
   tolgui = Abs(TolGuide);
 
   Pos1 = Pos2 = TopAbs_UNKNOWN;
@@ -185,7 +185,7 @@ Standard_Boolean Blend_Walking::PerformFirstSection(Blend_Function&     Func,
   Func.Set(param);
 
   math_Vector tolerance(1, 4),infbound(1, 4),supbound(1, 4);
-  Func.GetTolerance(tolerance, tolesp);
+  Func.GetTolerance(tolerance, tolpoint3d);
   Func.GetBounds(infbound, supbound);
   math_FunctionSetRoot rsnld(Func, tolerance, 30);
 
@@ -220,7 +220,7 @@ Standard_Boolean Blend_Walking::PerformFirstSection (Blend_Function& Func,
                                                      const Standard_Real Pdep,
                                                      const Standard_Real Pmax,
                                                      const math_Vector& ParDep,
-                                                     const Standard_Real Tolesp,
+                                                     const Standard_Real Tol3d,
                                                      const Standard_Real TolGuide,
                                                      const Standard_Boolean RecOnS1,
                                                      const Standard_Boolean RecOnS2,
@@ -235,7 +235,7 @@ Standard_Boolean Blend_Walking::PerformFirstSection (Blend_Function& Func,
   Standard_Real w1, w2, extrapol;
   Standard_Boolean recad1, recad2;
 
-  tolesp = Abs(Tolesp);
+  tolpoint3d = Tol3d;
   tolgui = Abs(TolGuide);
   if (Pmax - Pdep >= 0.0)
   {
@@ -262,7 +262,7 @@ Standard_Boolean Blend_Walking::PerformFirstSection (Blend_Function& Func,
   Standard_Real CorrectedU = 0., CorrectedV = 0.;
   gp_Pnt CorrectedPnt;
 
-  Func.GetTolerance(tolerance, tolesp);
+  Func.GetTolerance(tolerance, tolpoint3d);
   Func.GetBounds(infbound, supbound);
   math_FunctionSetRoot rsnld(Func, tolerance, 30);
 
@@ -409,9 +409,9 @@ Standard_Boolean Blend_Walking::PerformFirstSection (Blend_Function& Func,
 #endif
       MakeExtremity(Ext1, Standard_True, Index1, solrst1(1), Isvtx1, Vtx1);
       if (ToCorrectOnRst1)
-        Ext2.SetValue(CorrectedPnt, CorrectedU, CorrectedV, tolesp);
+        Ext2.SetValue(CorrectedPnt, CorrectedU, CorrectedV, tolpoint3d);
       else
-        Ext2.SetValue(previousP.PointOnS2(), sol(3), sol(4), tolesp);
+        Ext2.SetValue(previousP.PointOnS2(), sol(3), sol(4), tolpoint3d);
     }
     break;
 
@@ -424,9 +424,9 @@ Standard_Boolean Blend_Walking::PerformFirstSection (Blend_Function& Func,
       }
 #endif
       if (ToCorrectOnRst2)
-        Ext1.SetValue(CorrectedPnt, CorrectedU, CorrectedV, tolesp);
+        Ext1.SetValue(CorrectedPnt, CorrectedU, CorrectedV, tolpoint3d);
       else
-        Ext1.SetValue(previousP.PointOnS1(), sol(1), sol(2), tolesp);
+        Ext1.SetValue(previousP.PointOnS1(), sol(1), sol(2), tolpoint3d);
       MakeExtremity(Ext2, Standard_False, Index2, solrst2(1), Isvtx2, Vtx2);
     }
     break;

src/Blend/Blend_Walking_2.gxx

@@ -41,7 +41,7 @@ Blend_Status Blend_Walking::TestArret(Blend_Function& Function,
   IntSurf_TypeTrans tras1,tras2;
   Blend_Point curpoint;
   Standard_Boolean loctwist1 = Standard_False, loctwist2 = Standard_False;
-  Standard_Real tolsolu = tolesp;
+  Standard_Real tolsolu = tolpoint3d;
 
   if ( !TestSolu) tolsolu *= 1000; //Ca doit toujours etre bon
   if (Function.IsSolution(sol,tolsolu)) {
@@ -211,8 +211,8 @@ Blend_Status Blend_Walking::CheckDeflection
     if(!prevpointistangent){
       prevTg = previousP.TangentOnS1();
     }
-    tolu = TheSurfaceTool::UResolution(surf1,tolesp);
-    tolv = TheSurfaceTool::VResolution(surf1,tolesp);
+    tolu = TheSurfaceTool::UResolution(surf1,tolpoint3d);
+    tolv = TheSurfaceTool::VResolution(surf1,tolpoint3d);
   }
   else {
     Psurf = CurPoint.PointOnS2();
@@ -223,8 +223,8 @@ Blend_Status Blend_Walking::CheckDeflection
     if(!prevpointistangent){
       prevTg = previousP.TangentOnS2();
     }
-    tolu = TheSurfaceTool::UResolution(surf2,tolesp);
-    tolv = TheSurfaceTool::VResolution(surf2,tolesp);
+    tolu = TheSurfaceTool::UResolution(surf2,tolpoint3d);
+    tolv = TheSurfaceTool::VResolution(surf2,tolpoint3d);
   }
 
   gp_Vec Corde(prevP,Psurf);
@@ -233,12 +233,13 @@ Blend_Status Blend_Walking::CheckDeflection
   if(!prevpointistangent) prevNorme = prevTg.SquareMagnitude();
 
 
-  if (Norme <= tolesp*tolesp){
+  const Standard_Real toler3d = 0.01 * tolpoint3d;
+  if (Norme <= toler3d * toler3d){
     // il faudra peut etre  forcer meme point
     return Blend_SamePoints;
   }
   if(!prevpointistangent){
-    if(prevNorme <= tolesp*tolesp) {
+    if(prevNorme <= toler3d * toler3d) {
       return Blend_SamePoints;
     }
     Cosi = sens*Corde*prevTg;

src/Blend/Blend_Walking_3.gxx

@@ -125,7 +125,7 @@ Standard_Boolean Blend_Walking::Recadre(Blend_FuncInv& FuncInv,
   infb(2) -= Extrap;
   supb(2) += Extrap;
   
-  FuncInv.GetTolerance(toler,tolesp/10);//Il vaut mieux garder un peu de marge
+  FuncInv.GetTolerance(toler,0.1 * tolpoint3d);//Il vaut mieux garder un peu de marge
   math_FunctionSetRoot rsnld(FuncInv,toler,35);
   toler *= 10; // Mais on fait les tests correctements
 
@@ -262,7 +262,7 @@ Standard_Boolean Blend_Walking::Recadre(Blend_FuncInv& FuncInv,
       else solrst(1) = pmin;
     }
     // On verifie le jalon
-    jalons_Trouve = (FuncInv.IsSolution(solrst,tolesp));
+    jalons_Trouve = (FuncInv.IsSolution(solrst,tolpoint3d));
   }
 
   if (!jalons_Trouve) {
@@ -276,7 +276,7 @@ Standard_Boolean Blend_Walking::Recadre(Blend_FuncInv& FuncInv,
     }
     else {
       rsnld.Root(solrst);
-      recadre = FuncInv.IsSolution(solrst,tolesp);
+      recadre = FuncInv.IsSolution(solrst,tolpoint3d);
     }
   }
 
@@ -310,7 +310,7 @@ Standard_Boolean Blend_Walking::Recadre(Blend_FuncInv& FuncInv,
     // Le probleme a resoudre
     FuncInv.Set(OnFirst,thecur);
     FuncInv.GetBounds(infb,supb);
-    FuncInv.GetTolerance(toler,tolesp/10);//Il vaut mieux garder un peu de marge
+    FuncInv.GetTolerance(toler,0.1 * tolpoint3d);//Il vaut mieux garder un peu de marge
     math_FunctionSetRoot aRsnld(FuncInv,toler,35);
     toler *= 10; // Mais on fait les tests correctements
     // Resolution...
@@ -324,7 +324,7 @@ Standard_Boolean Blend_Walking::Recadre(Blend_FuncInv& FuncInv,
     }
     else {
       aRsnld.Root(solrst);
-      recadre = FuncInv.IsSolution(solrst,tolesp);
+      recadre = FuncInv.IsSolution(solrst,tolpoint3d);
     }
   }
 
@@ -453,7 +453,7 @@ void Blend_Walking::MakeExtremity(TheExtremity& Extrem,
   if (OnFirst) {
     Extrem.SetValue(previousP.PointOnS1(),
 		    sol(1),sol(2),
-		    previousP.Parameter(), tolesp);
+		    previousP.Parameter(), tolpoint3d);
     if (!previousP.IsTangencyPoint())  
       Extrem.SetTangent(previousP.TangentOnS1());
     Iter = recdomain1;
@@ -461,7 +461,7 @@ void Blend_Walking::MakeExtremity(TheExtremity& Extrem,
   else {
     Extrem.SetValue(previousP.PointOnS2(),
 		    sol(3),sol(4),
-		    previousP.Parameter(), tolesp);
+		    previousP.Parameter(), tolpoint3d);
     if (!previousP.IsTangencyPoint())  
       Extrem.SetTangent(previousP.TangentOnS2());
     Iter = recdomain2;

src/Blend/Blend_Walking_4.gxx

@@ -135,7 +135,7 @@ void Blend_Walking::InternalPerform(Blend_Function& Func,
 
   //IntSurf_Transition Tline,Tarc;
 
-  Func.GetTolerance(tolerance,tolesp);
+  Func.GetTolerance(tolerance,tolpoint3d);
   Func.GetBounds(infbound,supbound);
 
   math_FunctionSetRoot rsnld(Func,tolerance,30);
@@ -173,10 +173,10 @@ void Blend_Walking::InternalPerform(Blend_Function& Func,
       if (Abs(stepw) < tolgui) {
         Ext1.SetValue(previousP.PointOnS1(),
                       sol(1),sol(2),
-                      previousP.Parameter(),tolesp);
+                      previousP.Parameter(),tolpoint3d);
         Ext2.SetValue(previousP.PointOnS2(),
                       sol(3),sol(4),
-                      previousP.Parameter(),tolesp);
+                      previousP.Parameter(),tolpoint3d);
         if (!previousP.IsTangencyPoint()) {
           Ext1.SetTangent(previousP.TangentOnS1());
           Ext2.SetTangent(previousP.TangentOnS2());
@@ -227,7 +227,7 @@ void Blend_Walking::InternalPerform(Blend_Function& Func,
 	if (recad1) {
 	  Standard_Real wtemp;
 	  wtemp  = solrst1(2);
-	  if ((param - wtemp)/sens>= -10*tolesp){
+	  if ((param - wtemp)/sens>= -10*tolgui){
 	    w1 = solrst1(2);
 	    control = Standard_True;
 	  }
@@ -253,7 +253,7 @@ void Blend_Walking::InternalPerform(Blend_Function& Func,
 	if (recad2) {
 	  Standard_Real wtemp;
 	  wtemp = solrst2(2);
-	  if ((param - wtemp)/sens>= -10*tolesp){
+	  if ((param - wtemp)/sens>= -10*tolgui){
 	    w2 = solrst2(2);
 	    control = Standard_True;
 	  }
@@ -505,10 +505,10 @@ void Blend_Walking::InternalPerform(Blend_Function& Func,
 	  Arrive = Standard_True;
 	  Ext1.SetValue(previousP.PointOnS1(),
 			sol(1),sol(2),
-			previousP.Parameter(), tolesp);
+			previousP.Parameter(), tolpoint3d);
 	  Ext2.SetValue(previousP.PointOnS2(),
 			sol(3),sol(4),
-			previousP.Parameter(), tolesp);
+			previousP.Parameter(), tolpoint3d);
 	  if (!previousP.IsTangencyPoint()) {
 	    Ext1.SetTangent(previousP.TangentOnS1());
 	    Ext2.SetTangent(previousP.TangentOnS2());
@@ -533,10 +533,10 @@ void Blend_Walking::InternalPerform(Blend_Function& Func,
 	if (Abs(stepw) < tolgui) {
 	  Ext1.SetValue(previousP.PointOnS1(),
 			sol(1),sol(2),
-			previousP.Parameter(),tolesp);
+			previousP.Parameter(),tolpoint3d);
 	  Ext2.SetValue(previousP.PointOnS2(),
 			sol(3),sol(4),
-			previousP.Parameter(),tolesp);
+			previousP.Parameter(),tolpoint3d);
 	  if (!previousP.IsTangencyPoint()) {
 	    Ext1.SetTangent(previousP.TangentOnS1());
 	    Ext2.SetTangent(previousP.TangentOnS2());
@@ -584,10 +584,10 @@ void Blend_Walking::InternalPerform(Blend_Function& Func,
 	  Arrive = Standard_True;
 	  Ext1.SetValue(previousP.PointOnS1(),
 			sol(1),sol(2),
-			previousP.Parameter(),tolesp);
+			previousP.Parameter(),tolpoint3d);
 	  Ext2.SetValue(previousP.PointOnS2(),
 			sol(3),sol(4), 
-			previousP.Parameter(),tolesp);
+			previousP.Parameter(),tolpoint3d);
 	  if (!previousP.IsTangencyPoint()) {
 	    Ext1.SetTangent(previousP.TangentOnS1());
 	    Ext2.SetTangent(previousP.TangentOnS2());
@@ -627,15 +627,15 @@ void Blend_Walking::InternalPerform(Blend_Function& Func,
 	MakeExtremity(Ext1,Standard_True,Index1,
 		      solrst1(1),Isvtx1,Vtx1);
         // On blinde le cas singulier ou un des recadrage a planter
-        if (previousP.PointOnS1().IsEqual(previousP.PointOnS2(), 2*tolesp)) {
+        if (previousP.PointOnS1().IsEqual(previousP.PointOnS2(), 2.0 * tolpoint3d)) {
 	  Ext2.SetValue(previousP.PointOnS1(),
-			sol(3),sol(4),tolesp);
+			sol(3),sol(4),tolpoint3d);
 	  if (Isvtx1) MakeSingularExtremity(Ext2, Standard_False, Vtx1);
 	}
 	else {
 	  Ext2.SetValue(previousP.PointOnS2(),
 			sol(3),sol(4),
-			previousP.Parameter(),tolesp);
+			previousP.Parameter(),tolpoint3d);
 	}
 	Arrive = Standard_True;
       }
@@ -661,15 +661,15 @@ void Blend_Walking::InternalPerform(Blend_Function& Func,
 #endif
 
         // On blinde le cas singulier ou un des recadrage a plante
-        if (previousP.PointOnS1().IsEqual(previousP.PointOnS2(), 2*tolesp)) {
+        if (previousP.PointOnS1().IsEqual(previousP.PointOnS2(), 2.0 * tolpoint3d)) {
 	  Ext1.SetValue(previousP.PointOnS2(),
-			sol(1),sol(2),tolesp);
+			sol(1),sol(2),tolpoint3d);
 	  if (Isvtx2) MakeSingularExtremity(Ext1, Standard_True, Vtx2);
 	}
 	else {
 	  Ext1.SetValue(previousP.PointOnS1(),
 			sol(1),sol(2),
-			previousP.Parameter(),tolesp);
+			previousP.Parameter(),tolpoint3d);
 	}
 	MakeExtremity(Ext2,Standard_False,Index2,
 		      solrst2(1),Isvtx2,Vtx2);
@@ -698,7 +698,7 @@ void Blend_Walking::InternalPerform(Blend_Function& Func,
 #endif
 
 	if ( (Isvtx1 != Isvtx2) &&
-	    (previousP.PointOnS1().IsEqual(previousP.PointOnS2(), 2*tolesp)) ) {
+	    (previousP.PointOnS1().IsEqual(previousP.PointOnS2(), 2.0 * tolpoint3d)) ) {
 	  // On blinde le cas singulier ou un seul recadrage
 	  // est reconnu comme vertex.
 	  if (Isvtx1) {
@@ -727,10 +727,10 @@ void Blend_Walking::InternalPerform(Blend_Function& Func,
 #endif
 	Ext1.SetValue(previousP.PointOnS1(),
 		      sol(1),sol(2),
-		      previousP.Parameter(),tolesp);
+		      previousP.Parameter(),tolpoint3d);
 	Ext2.SetValue(previousP.PointOnS2(),
 		      sol(3),sol(4),
-		      previousP.Parameter(),tolesp);
+		      previousP.Parameter(),tolpoint3d);
 	if (!previousP.IsTangencyPoint()) {
 	  Ext1.SetTangent(previousP.TangentOnS1());
 	  Ext2.SetTangent(previousP.TangentOnS2());

src/ChFi3d/ChFi3d_Builder.cxx

@@ -198,7 +198,8 @@ void  ChFi3d_Builder::Compute()
   ChFi3d_InitChron(cl_total);
   ChFi3d_InitChron(cl_extent);
 #endif 
-  
+  UpdateTolesp();
+
   if (myListStripe.IsEmpty())
     throw Standard_Failure("There are no suitable edges for chamfer or fillet");
   
@@ -335,7 +336,7 @@ void  ChFi3d_Builder::Compute()
       }
       // 05/02/02 akm ^^^
       Standard_Integer solidindex = st->SolidIndex();
-      ChFi3d_FilDS(solidindex,st,DStr,myRegul,tolesp,tol2d);
+      ChFi3d_FilDS(solidindex,st,DStr,myRegul,tolapp3d,tol2d);
       if (!done) break;
     }
     

src/ChFi3d/ChFi3d_Builder.hxx

@@ -849,6 +849,10 @@ private:
                                    Handle(BRepAdaptor_Surface)& HS1,
                                    Handle(BRepAdaptor_Surface)& HS2) const;
 
+  //! Assign to tolesp parameter minimal value of spine's tolesp if it is less
+  //! than default initial value.
+  Standard_EXPORT void UpdateTolesp();
+
 
   TopoDS_Shape myShape;
   Standard_Real angular;

src/ChFi3d/ChFi3d_Builder_1.cxx

@@ -325,7 +325,7 @@ ChFi3d_Builder::ChFi3d_Builder(const TopoDS_Shape& S,
   myEShMap.Fill(S,TopAbs_EDGE,TopAbs_SHELL);
   myVFMap.Fill(S,TopAbs_VERTEX,TopAbs_FACE);
   myVEMap.Fill(S,TopAbs_VERTEX,TopAbs_EDGE);
-  SetParams(Ta,1.e-4,1.e-5,1.e-4,1.e-5,1.e-3);
+  SetParams(Ta, 1.0e-4, 1.e-5, 1.e-4, 1.e-5, 1.e-3);
   SetContinuity(GeomAbs_C1, Ta);
 }
 
@@ -336,7 +336,7 @@ ChFi3d_Builder::ChFi3d_Builder(const TopoDS_Shape& S,
 
 void ChFi3d_Builder::SetParams(const Standard_Real Tang, 
 			       const Standard_Real Tesp, 
-			       const Standard_Real T2d, 
+             const Standard_Real T2d, 
 			       const Standard_Real TApp3d, 
 			       const Standard_Real TolApp2d, 
 			       const Standard_Real Fleche)
@@ -692,7 +692,6 @@ void ChFi3d_Builder::PerformExtremity (const Handle(ChFiDS_Spine)& Spine)
     else{
       sst = Spine->LastStatus(); 
       iedge = Spine->NbEdges();
-      E[0] = Spine->Edges(iedge);
       V = Spine->LastVertex();
     }
     //Before all it is checked if the tangency is not dead.
@@ -703,6 +702,7 @@ void ChFi3d_Builder::PerformExtremity (const Handle(ChFiDS_Spine)& Spine)
     }
 
     if(sst == ChFiDS_BreakPoint){
+      Standard_Integer aLocNbG1Connections = 0;
       TopTools_ListIteratorOfListOfShape It;//,Jt;
       Standard_Boolean sommetpourri = Standard_False;
       TopTools_IndexedMapOfOrientedShape EdgesOfV;
@@ -720,7 +720,10 @@ void ChFi3d_Builder::PerformExtremity (const Handle(ChFiDS_Spine)& Spine)
         if (!F2.IsNull() && ChFi3d::IsTangentFaces(anEdge, F1, F2, GeomAbs_G2)) //smooth edge
         {
           if (!F1.IsSame(F2))
+          {
             NbG1Connections++;
+            aLocNbG1Connections++;
+          }
           continue;
         }
         
@@ -759,7 +762,7 @@ void ChFi3d_Builder::PerformExtremity (const Handle(ChFiDS_Spine)& Spine)
       if (EdgesOfV.Extent() != 3)
         sommetpourri = Standard_True;
       
-      if(!sommetpourri){
+      if(!sommetpourri && aLocNbG1Connections < 4){
 	sst = ChFi3d_EdgeState(E,myEFMap);
       }
       if(ii==1)Spine->SetFirstStatus(sst);

src/ChFi3d/ChFi3d_Builder_2.cxx

@@ -188,7 +188,7 @@ static Standard_Boolean BonVoisin(const gp_Pnt& Point,
 				  Standard_Real& XDep,
 				  Standard_Real& YDep,
 				  const ChFiDS_Map& EFMap,
-				  const Standard_Real tolesp) 
+				  const Standard_Real tol3d) 
 {
   Standard_Boolean bonvoisin = 1;
   Standard_Real winter, Uf, Ul;
@@ -203,7 +203,7 @@ static Standard_Boolean BonVoisin(const gp_Pnt& Point,
     const TopoDS_Edge& ecur = TopoDS::Edge(Ex.Current());
     if(!ecur.IsSame(cured)){
       hc->Initialize(ecur);
-      Standard_Real tolc = hc->Resolution(tolesp);
+      Standard_Real tolc = hc->Resolution(tol3d);
       if(ChFi3d_InterPlaneEdge(plane,hc,winter,1,tolc)){
 	gp_Pnt np = hc->Value(winter);
 	Standard_Real ndist = np.SquareDistance(papp);
@@ -848,7 +848,7 @@ void ChFi3d_Builder::StartSol(const Handle(ChFiDS_Stripe)&      Stripe,
     const BRepAdaptor_Curve& Ced = Spine->CurrentElementarySpine(iedge);
     gp_Pnt pnt = Ced.Value(woned);
   
-    if (Projection(PExt, pnt, els, w, tolesp) &&
+    if (Projection(PExt, pnt, els, w, tolapp3d) &&
 	PerformFirstSection(Spine,HGuide,Choix,HS1,HS2,
 			    I1,I2,w,SolDep,Pos1,Pos2)) {
       P1.SetCoord(SolDep(1),SolDep(2));
@@ -894,7 +894,7 @@ void ChFi3d_Builder::StartSol(const Handle(ChFiDS_Stripe)&      Stripe,
 //    Extrema_LocateExtPC ext(pnt,els,w,1.e-8);
 //    if(ext.IsDone()){
 //      w = ext.Point().Parameter(); 
-    if (Projection(PExt, pnt, els, w, tolesp)) {
+    if (Projection(PExt, pnt, els, w, tolapp3d)) {
       PerformFirstSection(Spine,HGuide,Choix,HS1,HS2,
 			  I1,I2,w,SolDep,Pos1,Pos2);
       gp_Pnt P;
@@ -909,11 +909,11 @@ void ChFi3d_Builder::StartSol(const Handle(ChFiDS_Stripe)&      Stripe,
 	   NbChangement++) {
 	if(Pos1 != TopAbs_IN){
 	  bonvoisin = BonVoisin(P, HS1, f1, plane, cured, 
-				SolDep(1),SolDep(2), myEFMap, tolesp); 
+				SolDep(1),SolDep(2), myEFMap, tolapp3d);
 	}
 	if(Pos2 != TopAbs_IN && bonvoisin){
 	  bonvoisin = BonVoisin(P, HS2, f2, plane, cured, 
-				SolDep(3),SolDep(4), myEFMap, tolesp);
+				SolDep(3),SolDep(4), myEFMap, tolapp3d);
 	} 
 	if(bonvoisin){
 	  f1 = HS1->Face();
@@ -2712,7 +2712,7 @@ void ChFi3d_Builder::PerformSetOfKGen(Handle(ChFiDS_Stripe)& Stripe,
 	    pcprev1->D1(prevpar1,pdeb1,vdeb1);
 	    pcnext1->D1(nextpar1,pfin1,vfin1);
 	    Bon1 = ChFi3d_mkbound(S1,PC1,-1,pdeb1,vdeb1,1,
-				  pfin1,vfin1,tolesp,2.e-4);
+				  pfin1,vfin1,tolapp3d,2.e-4);
 	  }
 	}
 	else{
@@ -2731,11 +2731,11 @@ void ChFi3d_Builder::PerformSetOfKGen(Handle(ChFiDS_Stripe)& Stripe,
 	  pdeb1 = PC1->Value(pardeb1);
 	  pfin1 = PC1->Value(parfin1);
 	  Bon1 = ChFi3d_mkbound(S1,PC1,-1,pdeb1,Vdeb1,1,
-				pfin1,Vfin1,tolesp,2.e-4);
+				pfin1,Vfin1,tolapp3d,2.e-4);
 	}
       }
       else{
-	Bon1 = ChFi3d_mkbound(S1,PC1,tolesp,2.e-4);
+	Bon1 = ChFi3d_mkbound(S1,PC1,tolapp3d,2.e-4);
       }
       if(tw2){
 	if(!yaprevon2 || !yanexton2){
@@ -2770,7 +2770,7 @@ void ChFi3d_Builder::PerformSetOfKGen(Handle(ChFiDS_Stripe)& Stripe,
 	    pcprev2->D1(prevpar2,pdeb2,vdeb2);
 	    pcnext2->D1(nextpar2,pfin2,vfin2);
 	    Bon2 = ChFi3d_mkbound(S2,PC2,-1,pdeb2,vdeb2,1,
-				  pfin2,vfin2,tolesp,2.e-4);
+				  pfin2,vfin2,tolapp3d,2.e-4);
 	  }
 	}
 	else{
@@ -2789,11 +2789,11 @@ void ChFi3d_Builder::PerformSetOfKGen(Handle(ChFiDS_Stripe)& Stripe,
 	  pdeb2 = PC2->Value(pardeb2);
 	  pfin2 = PC2->Value(parfin2);
 	  Bon2 = ChFi3d_mkbound(S2,PC2,-1,pdeb2,Vdeb2,1,
-				pfin2,Vfin2,tolesp,2.e-4);
+				pfin2,Vfin2,tolapp3d,2.e-4);
 	}
       }
       else{
-	Bon2 = ChFi3d_mkbound(S2,PC2,tolesp,2.e-4);
+	Bon2 = ChFi3d_mkbound(S2,PC2,tolapp3d,2.e-4);
       }
       // The parameters of neighbor traces are updated, so 
       // straight lines uv are pulled.
@@ -2817,8 +2817,8 @@ void ChFi3d_Builder::PerformSetOfKGen(Handle(ChFiDS_Stripe)& Stripe,
       gp_Pnt2d pdebs2 = pcsprev2->Value(prevpar2);
       gp_Pnt2d pfins1 = pcsnext1->Value(nextpar1);
       gp_Pnt2d pfins2 = pcsnext2->Value(nextpar2);
-      Bdeb = ChFi3d_mkbound(sprev,pdebs1,pdebs2,tolesp,2.e-4);
-      Bfin = ChFi3d_mkbound(snext,pfins1,pfins2,tolesp,2.e-4);
+      Bdeb = ChFi3d_mkbound(sprev,pdebs1,pdebs2,tolapp3d,2.e-4);
+      Bfin = ChFi3d_mkbound(snext,pfins1,pfins2,tolapp3d,2.e-4);
 
       GeomFill_ConstrainedFilling fil(11,20);
       if(pointuon1) fil.Init(Bon2,Bfin,Bdeb,1);
@@ -3046,7 +3046,7 @@ void ChFi3d_Builder::PerformSetOfSurf(Handle(ChFiDS_Stripe)& Stripe,
   ChFi3d_InitChron(ch); // init perf for ChFi3d_MakeExtremities
 #endif
   
-  if(!Simul) ChFi3d_MakeExtremities(Stripe,DStr,myEFMap,tolesp,tol2d);
+  if(!Simul) ChFi3d_MakeExtremities(Stripe,DStr,myEFMap,tolapp3d,tol2d);
   
 #ifdef OCCT_DEBUG
   ChFi3d_ResultChron(ch, t_makextremities); // result perf t_makextremities

src/ChFi3d/ChFi3d_Builder_6.cxx

@@ -416,7 +416,7 @@ Standard_Boolean ChFi3d_Builder::CompleteData
  const Standard_Boolean          Gf2)
 {
   TopOpeBRepDS_DataStructure& DStr = myDS->ChangeDS();
-  Data->ChangeSurf(DStr.AddSurface(TopOpeBRepDS_Surface(Surfcoin,tolesp)));
+  Data->ChangeSurf(DStr.AddSurface(TopOpeBRepDS_Surface(Surfcoin,tolapp3d)));
 #ifdef DRAW
   ChFi3d_SettraceDRAWFIL(Standard_True);
   if (ChFi3d_GettraceDRAWFIL()) {
@@ -987,7 +987,7 @@ Standard_Boolean ChFi3d_Builder::ComputeData
   Standard_Real NewFirst = PFirst;
   if(RecP || RecS || RecRst){
     if(!TheWalk.PerformFirstSection(Func,FInv,FInvP,FInvC,PFirst,Target,Soldep,
-				    tolesp,TolGuide,RecRst,RecP,RecS,
+				    tolapp3d,tolapp2d,TolGuide,RecRst,RecP,RecS,
 				    NewFirst,ParSol)){
 #ifdef OCCT_DEBUG
       std::cout<<"ChFi3d_Builder::ComputeData : calculation fail first section"<<std::endl;
@@ -1001,7 +1001,7 @@ Standard_Boolean ChFi3d_Builder::ComputeData
 
   while (again < 2){
     TheWalk.Perform (Func,FInv,FInvP,FInvC,NewFirst,Last,
-		     MS,TolGuide,ParSol,tolesp,Fleche,Appro);
+		     MS,tolapp3d,tolapp2d,TolGuide,ParSol,Fleche,Appro);
 
     if (!TheWalk.IsDone()) {
 #ifdef OCCT_DEBUG
@@ -1119,7 +1119,7 @@ Standard_Boolean ChFi3d_Builder::ComputeData
   Standard_Real NewFirst = PFirst;
   if (RecP1 || RecRst1 || RecP2 || RecRst2) {
     if (!TheWalk.PerformFirstSection(Func, FInv1, FInvP1, FInv2, FInvP2, PFirst, Target, Soldep,
-	  			     tolesp, TolGuide, RecRst1, RecP1, RecRst2, RecP2,
+               tolapp3d, TolGuide, RecRst1, RecP1, RecRst2, RecP2,
 				     NewFirst, ParSol)){
 #ifdef OCCT_DEBUG
       std::cout<<"ChFi3d_Builder::ComputeData : fail calculation first section"<<std::endl;
@@ -1133,7 +1133,7 @@ Standard_Boolean ChFi3d_Builder::ComputeData
 
   while (again < 2){
     TheWalk.Perform (Func, FInv1, FInvP1, FInv2, FInvP2, NewFirst, Last,
-		     MS, TolGuide, ParSol, tolesp, Fleche, Appro);
+		     MS, tolapp3d, TolGuide, ParSol, Fleche, Appro);
 
     if (!TheWalk.IsDone()) {
 #ifdef OCCT_DEBUG
@@ -1249,7 +1249,7 @@ Standard_Boolean ChFi3d_Builder::SimulData
   Standard_Real NewFirst = PFirst;
   if(RecP || RecS || RecRst){
     if(!TheWalk.PerformFirstSection(Func,FInv,FInvP,FInvC,PFirst,Target,Soldep,
-				    tolesp,TolGuide,RecRst,RecP,RecS,
+				    tolapp3d,tolapp2d,TolGuide,RecRst,RecP,RecS,
 				    NewFirst,ParSol)){
 #ifdef OCCT_DEBUG
 
@@ -1264,7 +1264,7 @@ Standard_Boolean ChFi3d_Builder::SimulData
 
   while (again < 2){
     TheWalk.Perform (Func,FInv,FInvP,FInvC,NewFirst,Last,
-		     MS,TolGuide,ParSol,tolesp,Fleche,Appro);
+		     MS,tolapp3d,tolapp2d,TolGuide,ParSol,Fleche,Appro);
     if (!TheWalk.IsDone()) {
 #ifdef OCCT_DEBUG
       std::cout << "Path not done" << std::endl;
@@ -1375,7 +1375,7 @@ Standard_Boolean ChFi3d_Builder::SimulData
   Standard_Real NewFirst = PFirst;
   if (RecP1 || RecRst1 || RecP2 || RecRst2) {
     if(!TheWalk.PerformFirstSection(Func, FInv1, FInvP1, FInv2, FInvP2, PFirst, Target, Soldep,
-	  			    tolesp, TolGuide, RecRst1, RecP1, RecRst2, RecP2,
+              tolapp3d, TolGuide, RecRst1, RecP1, RecRst2, RecP2,
 				    NewFirst,ParSol)){
 #ifdef OCCT_DEBUG
 
@@ -1390,7 +1390,7 @@ Standard_Boolean ChFi3d_Builder::SimulData
 
   while (again < 2){
     TheWalk.Perform (Func, FInv1, FInvP1, FInv2, FInvP2, NewFirst, Last,
-		     MS, TolGuide, ParSol, tolesp, Fleche, Appro);
+		     MS, tolapp3d, TolGuide, ParSol, Fleche, Appro);
     if (!TheWalk.IsDone()) {
 #ifdef OCCT_DEBUG
       std::cout << "Path not created" << std::endl;
@@ -1518,7 +1518,7 @@ Standard_Boolean ChFi3d_Builder::ComputeData
   if(!HS.IsNull()) F2 = HS->Face();
   
   // Path framing variables
-  Standard_Real TolGuide=tolguide, TolEsp = tolesp;
+  Standard_Real TolGuide=tolguide;
   Standard_Integer nbptmin = 4;
 
   BRepBlend_Walking TheWalk(S1,S2,I1,I2,HGuide);
@@ -1559,7 +1559,7 @@ Standard_Boolean ChFi3d_Builder::ComputeData
 	BP.ParametersOnS1(vec(1),vec(2));
 	BP.ParametersOnS2(vec(3),vec(4));
 	Func.Set(param);
-	if (Func.IsSolution(vec, tolesp)) {
+	if (Func.IsSolution(vec, tolapp3d)) {
 	  TheWalk.AddSingularPoint(BP);
 	}
       }
@@ -1574,7 +1574,7 @@ Standard_Boolean ChFi3d_Builder::ComputeData
 	BP.ParametersOnS1(vec(1),vec(2));
 	BP.ParametersOnS2(vec(3),vec(4));
 	Func.Set(param);
-	if (Func.IsSolution(vec, tolesp)) {
+	if (Func.IsSolution(vec, tolapp3d)) {
 	  TheWalk.AddSingularPoint(BP);
 	}
       }
@@ -1587,7 +1587,7 @@ Standard_Boolean ChFi3d_Builder::ComputeData
   Standard_Real NewFirst = PFirst;
   if(RecOnS1 || RecOnS2){
     if(!TheWalk.PerformFirstSection(Func,FInv,PFirst,Target,Soldep,
-				    tolesp,TolGuide,RecOnS1,RecOnS2,
+				    tolapp3d,TolGuide,RecOnS1,RecOnS2,
 				    NewFirst,ParSol)){
 #ifdef OCCT_DEBUG
       std::cout<<"ChFi3d_Builder::ComputeData : calculation fail first section"<<std::endl;
@@ -1617,10 +1617,9 @@ Standard_Boolean ChFi3d_Builder::ComputeData
     if(!again && (MS < 5*TolGuide)) MS = 5*TolGuide;
     else {
       if (5*TolGuide > MS) TolGuide = MS/5;
-      if (5*TolEsp > MS) TolEsp = MS/5;
     }
-    TheWalk.Perform(Func,FInv,NewFirst,Target,MS,TolGuide,
-		    ParSol,TolEsp,Fleche,Appro);
+    TheWalk.Perform(Func,FInv,NewFirst,Target,MS,tolapp3d,TolGuide,
+		    ParSol,Fleche,Appro);
     if (!TheWalk.IsDone()) {
 #ifdef OCCT_DEBUG
       std::cout << "Path is not created" << std::endl;
@@ -1776,7 +1775,7 @@ Standard_Boolean ChFi3d_Builder::ComputeData
     narc2 = Lin->StartPointOnSecond().NbPointOnRst();
     if(narc1 != 0) {
       ChFi3d_FilCommonPoint(Lin->StartPointOnFirst(),Lin->TransitionOnS1(),
-			    Standard_True, Data->ChangeVertexFirstOnS1(),tolesp);
+			    Standard_True, Data->ChangeVertexFirstOnS1(), tolapp3d);
       debarc1 = Standard_True;
       if(!SearchFace(Spine,Data->VertexFirstOnS1(),F1,bif)){
 	//It is checked if there is not an obstacle.
@@ -1794,7 +1793,7 @@ Standard_Boolean ChFi3d_Builder::ComputeData
     }
     if(narc2 != 0){
       ChFi3d_FilCommonPoint(Lin->StartPointOnSecond(),Lin->TransitionOnS2(),
-			    Standard_True, Data->ChangeVertexFirstOnS2(),tolesp);
+			    Standard_True, Data->ChangeVertexFirstOnS2(),tolapp3d);
       debarc2 = Standard_True;
       if(!SearchFace(Spine,Data->VertexFirstOnS2(),F2,bif)){
 	//It is checked if it is not an obstacle.
@@ -1831,7 +1830,7 @@ Standard_Boolean ChFi3d_Builder::ComputeData
 	  backwContinueFailed = Lin->StartPointOnFirst().ParameterOnGuide() > Target;
 	else {
 	  ChFi3d_FilCommonPoint(Lin->StartPointOnFirst(),Lin->TransitionOnS1(),
-				Standard_True, Data->ChangeVertexFirstOnS1(),tolesp);
+				Standard_True, Data->ChangeVertexFirstOnS1(), tolapp3d);
 	  debarc1 = Standard_True;
 	  if(!SearchFace(Spine,Data->VertexFirstOnS1(),F1,bif)){
 	    //It is checked if it is not an obstacle.
@@ -1853,7 +1852,7 @@ Standard_Boolean ChFi3d_Builder::ComputeData
 	  backwContinueFailed = Lin->StartPointOnSecond().ParameterOnGuide() > Target;
 	else {
 	  ChFi3d_FilCommonPoint(Lin->StartPointOnSecond(),Lin->TransitionOnS2(),
-                                Standard_True, Data->ChangeVertexFirstOnS2(),tolesp);
+                                Standard_True, Data->ChangeVertexFirstOnS2(), tolapp3d);
           debarc2 = Standard_True;
           if(!SearchFace(Spine,Data->VertexFirstOnS2(),F2,bif)){
 	    //It is checked if it is not an obstacle.
@@ -1889,7 +1888,7 @@ Standard_Boolean ChFi3d_Builder::ComputeData
     narc2 = Lin->EndPointOnSecond().NbPointOnRst();
     if(narc1 != 0){
       ChFi3d_FilCommonPoint(Lin->EndPointOnFirst(),Lin->TransitionOnS1(),
-			    Standard_False, Data->ChangeVertexLastOnS1(),tolesp);
+			    Standard_False, Data->ChangeVertexLastOnS1(), tolapp3d);
       finarc1 = Standard_True;
       if(!SearchFace(Spine,Data->VertexLastOnS1(),F1,bif)){
              //It is checked if it is not an obstacle.
@@ -1902,7 +1901,7 @@ Standard_Boolean ChFi3d_Builder::ComputeData
     }
     if(narc2 != 0){
       ChFi3d_FilCommonPoint(Lin->EndPointOnSecond(),Lin->TransitionOnS2(),
-			    Standard_False, Data->ChangeVertexLastOnS2(),tolesp);
+			    Standard_False, Data->ChangeVertexLastOnS2(), tolapp3d);
       finarc2 = Standard_True;
       if(!SearchFace(Spine,Data->VertexLastOnS2(),F2,bif)){
 	 //It is checked if it is not an obstacle.
@@ -1934,7 +1933,7 @@ Standard_Boolean ChFi3d_Builder::ComputeData
 	  forwContinueFailed = Lin->EndPointOnFirst().ParameterOnGuide() < Target;
 	else {
 	  ChFi3d_FilCommonPoint(Lin->EndPointOnFirst(),Lin->TransitionOnS1(),
-				Standard_False, Data->ChangeVertexLastOnS1(),tolesp);
+				Standard_False, Data->ChangeVertexLastOnS1(), tolapp3d);
 	  finarc1 = Standard_True;
 	  if(!SearchFace(Spine,Data->VertexLastOnS1(),F1,bif)){
              //It is checked if it is not an obstacle.
@@ -1951,7 +1950,7 @@ Standard_Boolean ChFi3d_Builder::ComputeData
 	  forwContinueFailed = Lin->EndPointOnSecond().ParameterOnGuide() < Target;
 	else {
 	  ChFi3d_FilCommonPoint(Lin->EndPointOnSecond(),Lin->TransitionOnS2(),
-				Standard_False, Data->ChangeVertexLastOnS2(),tolesp);
+				Standard_False, Data->ChangeVertexLastOnS2(), tolapp3d);
 	  finarc2 = Standard_True;
 	  if(!SearchFace(Spine,Data->VertexLastOnS2(),F2,bif)){
 	    //On regarde si ce n'est pas un obstacle.
@@ -2125,7 +2124,7 @@ Standard_Boolean ChFi3d_Builder::SimulData
   TheWalk.Check2d(Standard_False);
   
   Standard_Real MS = MaxStep;
-  Standard_Real TolGuide=tolguide, TolEsp = tolesp;
+  Standard_Real TolGuide=tolguide;
   Standard_Integer Nbpnt = 0;
   Standard_Real SpFirst = HGuide->FirstParameter();
   Standard_Real SpLast =  HGuide->LastParameter();
@@ -2145,7 +2144,7 @@ Standard_Boolean ChFi3d_Builder::SimulData
   Standard_Real NewFirst = PFirst;
   if(RecOnS1 || RecOnS2){
     if(!TheWalk.PerformFirstSection(Func,FInv,PFirst,Target,Soldep,
-				    tolesp,TolGuide,RecOnS1,RecOnS2,
+            tolapp3d,TolGuide,RecOnS1,RecOnS2,
 				    NewFirst,ParSol)){
 #ifdef OCCT_DEBUG
       std::cout<<"ChFi3d_Builder::SimulData : calculation fail first section"<<std::endl;
@@ -2163,11 +2162,10 @@ Standard_Boolean ChFi3d_Builder::SimulData
     if(!again && (MS < 5*TolGuide)) MS = 5*TolGuide;
     else  {
       if (5*TolGuide > MS) TolGuide = MS/5;
-      if (5*TolEsp > MS) TolEsp = MS/5;
     }
       
-    TheWalk.Perform(Func,FInv,NewFirst,Target,MS,TolGuide,
-		    ParSol,TolEsp,Fleche,Appro);
+    TheWalk.Perform(Func,FInv,NewFirst,Target,MS,tolapp3d,TolGuide,
+		    ParSol,Fleche,Appro);
     
     if (!TheWalk.IsDone()) {
 #ifdef OCCT_DEBUG

src/ChFi3d/ChFi3d_Builder_C1.cxx

@@ -725,7 +725,7 @@ void ChFi3d_Builder::PerformOneCorner(const Standard_Integer Index,
     ChFiDS_CommonPoint saveCPopArc = CPopArc;
     c3df = DStr.Curve(FiopArc.LineIndex()).Curve();
 
-    inters = IntersUpdateOnSame (HGs,HBs,c3df,Fop,Fv,Arcprol,Vtx,isfirst,10*tolesp, // in
+    inters = IntersUpdateOnSame (HGs,HBs,c3df,Fop,Fv,Arcprol,Vtx,isfirst,10*tolapp3d, // in
 				 FiopArc,CPopArc,p2dbout,wop);   // out
 
     Handle(BRepAdaptor_Curve2d) pced = new BRepAdaptor_Curve2d();
@@ -763,7 +763,7 @@ void ChFi3d_Builder::PerformOneCorner(const Standard_Integer Index,
 
   TopoDS_Edge edgecouture;
   Standard_Boolean couture,intcouture=Standard_False;
-  Standard_Real tolreached = tolesp;
+  Standard_Real tolreached = tolapp3d;
   Standard_Real  par1 =0.,par2 =0.;
   Standard_Integer indpt = 0,Icurv1 = 0,Icurv2 = 0;
   Handle(Geom_TrimmedCurve) curv1,curv2;
@@ -817,7 +817,7 @@ void ChFi3d_Builder::PerformOneCorner(const Standard_Integer Index,
 
     if (!ChFi3d_ComputeCurves(HGs,HBs,Pardeb,Parfin,Cc,
 			      Ps,
-			      Pc,tolesp,tol2d,tolreached))
+			      Pc,tolapp3d,tol2d,tolreached))
       throw Standard_Failure("OneCorner : echec calcul intersection");
 
     Udeb = Cc->FirstParameter();
@@ -1238,7 +1238,7 @@ void ChFi3d_Builder::PerformOneCorner(const Standard_Integer Index,
     Handle(Geom2d_Curve) zob2dop, zob2dv;
     //Standard_Real tolreached;
     if (!ChFi3d_ComputeCurves(HBop,HBs,Pardeb,Parfin,zob3d,zob2dop,
-			      zob2dv,tolesp,tol2d,tolreached))
+			      zob2dv,tolapp3d,tol2d,tolreached))
       throw Standard_Failure("OneCorner : echec calcul intersection");
 
     Udeb = zob3d->FirstParameter();
@@ -2143,7 +2143,7 @@ void ChFi3d_Builder::PerformIntersectionAtEnd(const Standard_Integer Index)
         const Handle(Geom_Curve)& c3df = DStr.Curve(Fi1.LineIndex()).Curve();
         Standard_Real Ufi= Fi2.Parameter(isfirst);
         ChFiDS_FaceInterference& Fi = Fd->ChangeInterferenceOnS1();
-        if (!IntersUpdateOnSame (HGs,HBs,c3df,F1,Face[0],Edge[0],Vtx,isfirst,10*tolesp, // in
+        if (!IntersUpdateOnSame (HGs,HBs,c3df,F1,Face[0],Edge[0],Vtx,isfirst,10*tolapp3d, // in
 				 Fi,CV1,pfac1,Ufi))   // out
 	  throw Standard_Failure("IntersectionAtEnd: pb intersection Face - Fi");
         Fi1 = Fi;
@@ -2155,14 +2155,14 @@ void ChFi3d_Builder::PerformIntersectionAtEnd(const Standard_Integer Index)
 	  paredge2 = proj.LowerDistanceParameter();
         }
         // update stripe point
-        TopOpeBRepDS_Point tpoint (CV1.Point(),tolesp);
+        TopOpeBRepDS_Point tpoint (CV1.Point(),tolapp3d);
         indpoint1=DStr.AddPoint(tpoint);
         stripe->SetIndexPoint(indpoint1,isfirst,1);
         // reset arc of CV1
         TopoDS_Vertex vert1,vert2;
         TopExp::Vertices(Edge[0],vert1,vert2);
         TopAbs_Orientation arcOri = Vtx.IsSame(vert1) ? TopAbs_FORWARD : TopAbs_REVERSED;
-        CV1.SetArc(tolesp,Edge[0],paredge2,arcOri);
+        CV1.SetArc(tolapp3d,Edge[0],paredge2,arcOri);
       }
       else {
         if (Hc1.IsNull()) {
@@ -2389,7 +2389,7 @@ void ChFi3d_Builder::PerformIntersectionAtEnd(const Standard_Integer Index)
       const Handle(Geom_Curve)& c3df = DStr.Curve(Fi2.LineIndex()).Curve();
       Standard_Real Ufi= Fi1.Parameter(isfirst);
       ChFiDS_FaceInterference& Fi = Fd->ChangeInterferenceOnS2();
-      if (!IntersUpdateOnSame (HGs,HBs,c3df,F2,F,Edge[nb],Vtx,isfirst,10*tolesp, // in
+      if (!IntersUpdateOnSame (HGs,HBs,c3df,F2,F,Edge[nb],Vtx,isfirst,10*tolapp3d, // in
 			       Fi,CV2,pfac2,Ufi))   // out
 	throw Standard_Failure("IntersectionAtEnd: pb intersection Face - Fi");
       Fi2 = Fi;
@@ -2403,14 +2403,14 @@ void ChFi3d_Builder::PerformIntersectionAtEnd(const Standard_Integer Index)
         paredge2 = proj.LowerDistanceParameter();
       }
       // update stripe point
-      TopOpeBRepDS_Point tpoint (CV2.Point(),tolesp);
+      TopOpeBRepDS_Point tpoint (CV2.Point(),tolapp3d);
       indpoint2=DStr.AddPoint(tpoint);
       stripe->SetIndexPoint(indpoint2,isfirst,2);
       // reset arc of CV2
       TopoDS_Vertex vert1,vert2;
       TopExp::Vertices(Edge[nbface],vert1,vert2);
       TopAbs_Orientation arcOri = Vtx.IsSame(vert1) ? TopAbs_FORWARD : TopAbs_REVERSED;
-      CV2.SetArc(tolesp,Edge[nbface],paredge2,arcOri);
+      CV2.SetArc(tolapp3d,Edge[nbface],paredge2,arcOri);
     }
 
 
@@ -2483,7 +2483,7 @@ void ChFi3d_Builder::PerformIntersectionAtEnd(const Standard_Integer Index)
     //////////////////////////////////////////////////////////////////////
 
     if (!ChFi3d_ComputeCurves(HGs,HBs,Pardeb,Parfin,Cc,
-                              Ps,Pc,tolesp,tol2d,tolreached,nbface==1)) {
+                              Ps,Pc,tolapp3d,tol2d,tolreached,nbface==1)) {
       PerformMoreThreeCorner (Index,1);
       return;
     }
@@ -2799,7 +2799,7 @@ void ChFi3d_Builder::PerformIntersectionAtEnd(const Standard_Integer Index)
       Standard_Real aTolreached;
       ChFi3d_ComputePCurv(Cc,UV1,UV2,Ps,
 			  DStr.Surface(SDprev->Surf()).Surface(),
-			  p1,p2,tolesp,aTolreached);
+			  p1,p2,tolapp3d,aTolreached);
       TopOpeBRepDS_Curve& TCurv = DStr.ChangeCurve(indcurve[nb-1]);
       TCurv.Tolerance(Max(TCurv.Tolerance(),aTolreached));
 
@@ -2858,7 +2858,7 @@ void ChFi3d_Builder::PerformIntersectionAtEnd(const Standard_Integer Index)
     //box.Add(aSurf->Value(UV.X(), UV.Y()));
     
     ChFi3d_ComputeArete(CV1,UV1,CV2,UV2,aSurf, // in 
-			C3d,Ps,p1,p2,tolesp,tol2d,aTolreached,0); // out except tolers
+			C3d,Ps,p1,p2,tolapp3d,tol2d,aTolreached,0); // out except tolers
 
     indpoint1 = indpoint2 = midIpoint;
     gp_Pnt point;
@@ -2890,7 +2890,7 @@ void ChFi3d_Builder::PerformIntersectionAtEnd(const Standard_Integer Index)
     UV1.SetCoord(isUShrink ? 1 : 2, prevSDParam);
     UV2.SetCoord(isUShrink ? 1 : 2, prevSDParam);
     
-    ChFi3d_ComputePCurv(C3d,UV1,UV2,Pc,aSurf,p1,p2,tolesp,aTolreached);
+    ChFi3d_ComputePCurv(C3d,UV1,UV2,Pc,aSurf,p1,p2,tolapp3d,aTolreached);
     
     Crv.Tolerance(Max(Crv.Tolerance(),aTolreached));
     Interfc= ChFi3d_FilCurveInDS (Icurv,IsurfPrev,Pc,TopAbs::Reverse(orcourbe));
@@ -3974,7 +3974,7 @@ void ChFi3d_Builder::IntersectMoreCorner(const Standard_Integer Index)
       Handle(Geom2dAdaptor_Curve) pcprol = new Geom2dAdaptor_Curve(gpcprol);
       Standard_Real partemp = BRep_Tool::Parameter(Vtx,Arcprol);
       inters = Update(HBs,pcprol,HGs,FiopArc,CPopArc,p2dbout,
-		      isfirst,partemp,wop,10*tolesp);
+		      isfirst,partemp,wop,10*tolapp3d);
     }
     Handle(BRepAdaptor_Curve2d) pced = new BRepAdaptor_Curve2d();
     pced->Initialize(CPadArc.Arc(),Fv);
@@ -3987,7 +3987,7 @@ void ChFi3d_Builder::IntersectMoreCorner(const Standard_Integer Index)
 
   TopoDS_Edge edgecouture;
   Standard_Boolean couture,intcouture=Standard_False;
-  Standard_Real tolreached = tolesp;
+  Standard_Real tolreached = tolapp3d;
   Standard_Real par1 = 0.,par2 = 0.;
   Standard_Integer indpt =0,Icurv1 =0,Icurv2 =0;
   Handle(Geom_TrimmedCurve) curv1,curv2;
@@ -4039,7 +4039,7 @@ void ChFi3d_Builder::IntersectMoreCorner(const Standard_Integer Index)
 
     if (!ChFi3d_ComputeCurves(HGs,HBs,Pardeb,Parfin,Cc,
 			      Ps,
-			      Pc,tolesp,tol2d,tolreached))
+			      Pc,tolapp3d,tol2d,tolreached))
     throw Standard_Failure("OneCorner : failed calculation intersection");
 
     Udeb = Cc->FirstParameter();
@@ -4311,7 +4311,7 @@ void ChFi3d_Builder::IntersectMoreCorner(const Standard_Integer Index)
     Handle(Geom2d_Curve) zob2dop, zob2dv;
 //    Standard_Real tolreached;
     if (!ChFi3d_ComputeCurves(HBop,HBs,Pardeb,Parfin,zob3d,zob2dop,
-			      zob2dv,tolesp,tol2d,tolreached))
+			      zob2dv,tolapp3d,tol2d,tolreached))
       throw Standard_Failure("OneCorner : echec calcul intersection");
 
     Udeb = zob3d->FirstParameter();

src/ChFi3d/ChFi3d_Builder_C2.cxx

@@ -230,7 +230,7 @@ Standard_Boolean ChFi3d_Builder::PerformTwoCornerbyInter(const Standard_Integer
   }
   gp_Pnt psp1 = Hpivot->Value(parCP1);
   gp_Pnt psp2 = Hpivot->Value(parCP2);
-  Standard_Real sameparam = (psp1.Distance(psp2) < 10 * tolesp);
+  Standard_Real sameparam = (psp1.Distance(psp2) < 10.0 * tolapp3d);
    
   TopoDS_Face FF1 = TopoDS::Face(DStr.Shape(Fd1->Index(IFaArc1)));
   TopoDS_Face FF2 = TopoDS::Face(DStr.Shape(Fd2->Index(IFaArc2)));
@@ -289,10 +289,10 @@ Standard_Boolean ChFi3d_Builder::PerformTwoCornerbyInter(const Standard_Integer
       Reduce(UIntPC1,UIntPC2,HS1,HS2);
     }
     
-    Standard_Real tolreached = tolesp;
+    Standard_Real tolreached = tolapp3d;
     if (IFaCo1 == 1 && 
 	!ChFi3d_ComputeCurves(HS1,HS2,Pardeb,Parfin,Gc,
-			      PGc1,PGc2,tolesp,tol2d,tolreached)) {
+			      PGc1,PGc2,tolapp3d,tol2d,tolreached)) {
 #ifdef OCCT_DEBUG
       std::cout<<"failed to calculate bevel error interSS"<<std::endl;
 #endif
@@ -301,7 +301,7 @@ Standard_Boolean ChFi3d_Builder::PerformTwoCornerbyInter(const Standard_Integer
     }
     else if (IFaCo1 == 2 && 
 	     !ChFi3d_ComputeCurves(HS1,HS2,Parfin,Pardeb,Gc,
-				   PGc1,PGc2,tolesp,tol2d,tolreached)) {
+				   PGc1,PGc2,tolapp3d,tol2d,tolreached)) {
 #ifdef OCCT_DEBUG
       std::cout<<"failed to calculate bevel error interSS"<<std::endl;
 #endif
@@ -451,7 +451,7 @@ Standard_Boolean ChFi3d_Builder::PerformTwoCornerbyInter(const Standard_Integer
     
     Standard_Real tolreached;
     if (!ChFi3d_ComputeCurves(SmaHS,BigHS,Pardeb,Parfin,Gc,
-			      PGc1,PGc2,tolesp,tol2d,tolreached)) {
+			      PGc1,PGc2,tolapp3d,tol2d,tolreached)) {
 #ifdef OCCT_DEBUG
       std::cout<<"failed to calculate bevel failed interSS"<<std::endl;
 #endif
@@ -573,7 +573,7 @@ Standard_Boolean ChFi3d_Builder::PerformTwoCornerbyInter(const Standard_Integer
     ChFi3d_BoundFac (*HF, uu1, uu2, vv1, vv2, Standard_True);
 
     if (!ChFi3d_ComputeCurves(HF,BigHS,Pardeb,Parfin,Gc,
-			      PGc1,PGc2,tolesp,tol2d,tolreached)) {
+			      PGc1,PGc2,tolapp3d,tol2d,tolreached)) {
 #ifdef OCCT_DEBUG
       std::cout<<"fail calculation bevel fail interSS"<<std::endl;
 #endif
@@ -638,7 +638,26 @@ Standard_Boolean ChFi3d_Builder::PerformTwoCornerbyInter(const Standard_Integer
 }
 
 
-
+//=======================================================================
+//function : UpdateTolesp
+//purpose  : Update tolesp field to fit it to range of parameter of spine curve
+//=======================================================================
+
+void ChFi3d_Builder::UpdateTolesp()
+{
+  ChFiDS_ListIteratorOfListOfStripe itel;
+  // tolesp = Precision::Infinite();
+  for (itel.Initialize(myListStripe); itel.More(); itel.Next())
+  {
+    Handle(ChFiDS_Stripe)& curStripe = itel.Value();
+    Handle(ChFiDS_Spine)& Spine = curStripe->ChangeSpine();
+    const Standard_Real current_stripe_tolesp = Spine->GetTolesp();
+    if (tolesp > current_stripe_tolesp)
+    {
+      tolesp = current_stripe_tolesp;
+    }
+  }
+}
 
 
 

src/ChFi3d/ChFi3d_Builder_CnCrn.cxx

@@ -2053,7 +2053,7 @@ void  ChFi3d_Builder::PerformMoreThreeCorner(const Standard_Integer Jndex,
   // Using constraint order > 0 very often causes  unpredicable undulations of solution
   Standard_Integer degree = 3, nbcurvpnt = 10, nbiter = 1;
   Standard_Integer constr = 1; //G1
-  GeomPlate_BuildPlateSurface PSurf(degree, nbcurvpnt, nbiter, tol2d, tolesp, angular);
+  GeomPlate_BuildPlateSurface PSurf(degree, nbcurvpnt, nbiter, tol2d, tolapp3d, angular);
 // calculation of curves on surface for each stripe 
   for (ic=0;ic<nedge;ic++) {
     gp_Pnt2d p2d1, p2d2;
@@ -2081,7 +2081,7 @@ void  ChFi3d_Builder::PerformMoreThreeCorner(const Standard_Integer Jndex,
       //Order.SetValue(ic,1);
       Order.SetValue(ic, constr);
       Handle(GeomPlate_CurveConstraint) Cont =
-	new GeomPlate_CurveConstraint(HCons,Order.Value(ic), nbcurvpnt,tolesp,angular,0.1);
+	new GeomPlate_CurveConstraint(HCons,Order.Value(ic),nbcurvpnt,tolapp3d,angular,0.1);
       PSurf.Add(Cont);
       
       // calculate indexes of points and of the curve for the DS         
@@ -2378,7 +2378,7 @@ void  ChFi3d_Builder::PerformMoreThreeCorner(const Standard_Integer Jndex,
          if (isG1.Value(ic)) 
            Order.SetValue(n3d,1);
          Handle(GeomPlate_CurveConstraint) Cont =
-           new GeomPlate_CurveConstraint(HCons,Order.Value(n3d),10,tolesp,angular,0.1);
+           new GeomPlate_CurveConstraint(HCons,Order.Value(n3d),10,tolapp3d,angular,0.1);
          PSurf.Add(Cont);
 
          //calculation of curve 3d if it is not a projection 
@@ -2502,7 +2502,7 @@ void  ChFi3d_Builder::PerformMoreThreeCorner(const Standard_Integer Jndex,
 	  Handle(Adaptor3d_CurveOnSurface) HCons =new Adaptor3d_CurveOnSurface(CurvOnS);
 	  Order.SetValue(n3d,1);
 	  Handle(GeomPlate_CurveConstraint) Cont =
-	    new GeomPlate_CurveConstraint(HCons,Order.Value(n3d),10,tolesp,angular,0.1);
+	    new GeomPlate_CurveConstraint(HCons,Order.Value(n3d),10,tolapp3d,angular,0.1);
 	  PSurf.Add(Cont);
 	  TopOpeBRepDS_Curve tcurv3d( cproj,error);
 	  indcurve3d.SetValue(n3d, DStr.AddCurve(tcurv3d));
@@ -2615,7 +2615,7 @@ void  ChFi3d_Builder::PerformMoreThreeCorner(const Standard_Integer Jndex,
 	Handle(Adaptor3d_CurveOnSurface) HCons =new Adaptor3d_CurveOnSurface(CurvOnS);
 	Order.SetValue(n3d,0);
 	Handle(GeomPlate_CurveConstraint) Cont =
-	  new GeomPlate_CurveConstraint(HCons,Order.Value(n3d),10,tolesp,angular,0.1);
+	  new GeomPlate_CurveConstraint(HCons,Order.Value(n3d),10,tolapp3d,angular,0.1);
 	PSurf.Add(Cont);
 	TopOpeBRepDS_Curve tcurv3d( ctrim,1.e-4);
 	indcurve3d.SetValue(n3d, DStr.AddCurve(tcurv3d));

src/ChFi3d/ChFi3d_Builder_SpKP.cxx

@@ -654,7 +654,7 @@ Standard_Boolean ChFi3d_Builder::SplitKPart
   
   // Cutting of tangency lines (hatching).
   Geom2dHatch_Intersector Inter(pitol,pitol);
-  Geom2dHatch_Hatcher H1(Inter,tol2d,tolesp), H2(Inter,tol2d,tolesp);
+  Geom2dHatch_Hatcher H1(Inter,tol2d,tolapp3d), H2(Inter,tol2d,tolapp3d);
   Standard_Integer ie;
   Handle(Geom2d_Curve) C1 = Data->InterferenceOnS1().PCurveOnFace(); 
   Geom2dAdaptor_Curve  ll1;

src/ChFi3d/ChFi3d_ChBuilder.cxx

@@ -822,13 +822,13 @@ ChFi3d_ChBuilder::SimulSurf(Handle(ChFiDS_SurfData)&            Data,
     Data->SetSimul(sec);
     Data->Set2dPoints(pf1,pl1,pf2,pl2);
     ChFi3d_FilCommonPoint(lin->StartPointOnFirst(),lin->TransitionOnS1(),
-			  Standard_True, Data->ChangeVertexFirstOnS1(),tolesp);
+			  Standard_True, Data->ChangeVertexFirstOnS1(),tolapp3d);
     ChFi3d_FilCommonPoint(lin->EndPointOnFirst(),lin->TransitionOnS1(),
-			  Standard_False,Data->ChangeVertexLastOnS1(),tolesp);
+			  Standard_False,Data->ChangeVertexLastOnS1(),tolapp3d);
     ChFi3d_FilCommonPoint(lin->StartPointOnSecond(),lin->TransitionOnS2(),
-			  Standard_True, Data->ChangeVertexFirstOnS2(),tolesp);
+			  Standard_True, Data->ChangeVertexFirstOnS2(),tolapp3d);
     ChFi3d_FilCommonPoint(lin->EndPointOnSecond(),lin->TransitionOnS2(),
-			  Standard_False, Data->ChangeVertexLastOnS2(),tolesp);
+			  Standard_False, Data->ChangeVertexLastOnS2(),tolapp3d);
     
     Standard_Boolean reverse = (!Forward || Inside);
     if(intf && reverse){
@@ -932,13 +932,13 @@ ChFi3d_ChBuilder::SimulSurf(Handle(ChFiDS_SurfData)&            Data,
     Data->SetSimul(sec);
     Data->Set2dPoints(pf1,pl1,pf2,pl2);
     ChFi3d_FilCommonPoint(lin->StartPointOnFirst(),lin->TransitionOnS1(),
-			Standard_True, Data->ChangeVertexFirstOnS1(),tolesp);
+			Standard_True, Data->ChangeVertexFirstOnS1(),tolapp3d);
     ChFi3d_FilCommonPoint(lin->EndPointOnFirst(),lin->TransitionOnS1(),
-			  Standard_False,Data->ChangeVertexLastOnS1(),tolesp);
+			  Standard_False,Data->ChangeVertexLastOnS1(),tolapp3d);
     ChFi3d_FilCommonPoint(lin->StartPointOnSecond(),lin->TransitionOnS2(),
-			  Standard_True, Data->ChangeVertexFirstOnS2(),tolesp);
+			  Standard_True, Data->ChangeVertexFirstOnS2(),tolapp3d);
     ChFi3d_FilCommonPoint(lin->EndPointOnSecond(),lin->TransitionOnS2(),
-			  Standard_False, Data->ChangeVertexLastOnS2(),tolesp);
+			  Standard_False, Data->ChangeVertexLastOnS2(),tolapp3d);
     
     Standard_Boolean reverse = (!Forward || Inside);
     if(intf && reverse){
@@ -1017,13 +1017,13 @@ ChFi3d_ChBuilder::SimulSurf(Handle(ChFiDS_SurfData)&            Data,
     Data->SetSimul(sec);
     Data->Set2dPoints(pf1,pl1,pf2,pl2);
     ChFi3d_FilCommonPoint(lin->StartPointOnFirst(),lin->TransitionOnS1(),
-                          Standard_True, Data->ChangeVertexFirstOnS1(),tolesp);
+                          Standard_True, Data->ChangeVertexFirstOnS1(),tolapp3d);
     ChFi3d_FilCommonPoint(lin->EndPointOnFirst(),lin->TransitionOnS1(),
-                          Standard_False,Data->ChangeVertexLastOnS1(),tolesp);
+                          Standard_False,Data->ChangeVertexLastOnS1(),tolapp3d);
     ChFi3d_FilCommonPoint(lin->StartPointOnSecond(),lin->TransitionOnS2(),
-                          Standard_True, Data->ChangeVertexFirstOnS2(),tolesp);
+                          Standard_True, Data->ChangeVertexFirstOnS2(),tolapp3d);
     ChFi3d_FilCommonPoint(lin->EndPointOnSecond(),lin->TransitionOnS2(),
-                          Standard_False, Data->ChangeVertexLastOnS2(),tolesp);
+                          Standard_False, Data->ChangeVertexLastOnS2(),tolapp3d);
     
     Standard_Boolean reverse = (!Forward || Inside);
     if(intf && reverse){
@@ -1175,7 +1175,7 @@ Standard_Boolean ChFi3d_ChBuilder::PerformFirstSection
   if (chsp.IsNull()) 
     throw Standard_ConstructionError("PerformSurf : this is not the spine of a chamfer");
 
-  Standard_Real TolGuide = HGuide->Resolution(tolesp) ;
+  Standard_Real TolGuide = HGuide->Resolution(tolapp3d);
 
 
   if (chsp->IsChamfer() == ChFiDS_Sym) {
@@ -1244,7 +1244,7 @@ Standard_Boolean ChFi3d_ChBuilder::PerformFirstSection
     }
     
     return TheWalk.PerformFirstSection(*pFunc,Par,SolDep,
-				       tolesp,TolGuide,Pos1,Pos2);
+				       tolapp3d,TolGuide,Pos1,Pos2);
   }
   else if (chsp->IsChamfer() == ChFiDS_TwoDist)  {
     Standard_Real dis1, dis2;
@@ -1347,7 +1347,7 @@ Standard_Boolean ChFi3d_ChBuilder::PerformFirstSection
     }
     
     return TheWalk.PerformFirstSection(*pFunc,Par,SolDep,
-				       tolesp,TolGuide,Pos1,Pos2);
+				       tolapp3d,TolGuide,Pos1,Pos2);
   }
   else { //distance and angle
     Standard_Real dis1, angle;
@@ -1415,7 +1415,7 @@ Standard_Boolean ChFi3d_ChBuilder::PerformFirstSection
     }
     
     return TheWalk.PerformFirstSection(Func,Par,SolDep,
-                                       tolesp,TolGuide,Pos1,Pos2);
+                                       tolapp3d,TolGuide,Pos1,Pos2);
   } //distance and angle
 }
 

src/ChFi3d/ChFi3d_ChBuilder_C3.cxx

@@ -478,7 +478,7 @@ void ChFi3d_ChBuilder::PerformThreeCorner(const Standard_Integer Jndex)
     if (!ComputeIntersection(DStr,fdpiv,coin,
 			     p3d[fin],p2d[fin],p3d[deb],p2d[deb],
 			     gcpiv,pivpc1,pivpc2,deru,derv,ptbid,
-			     tolesp,tol2d,tolrcoinpiv))
+			     tolapp3d,tol2d,tolrcoinpiv))
       throw StdFail_NotDone("echec calcul intersection coin-pivot");
     gp_Vec norpiv = deru.Crossed(derv);
     
@@ -495,7 +495,7 @@ void ChFi3d_ChBuilder::PerformThreeCorner(const Standard_Integer Jndex)
     if (!ComputeIntersection(DStr,fddeb,coin,
 			     p3d[pivot],p2d1,p3d[fin],p2d2,
 			     gcdeb,debpc1,debpc2,deru,derv,ptbid,
-			     tolesp,tol2d,tolrcoindeb))
+			     tolapp3d,tol2d,tolrcoindeb))
       throw StdFail_NotDone("echec calcul intersection coin-deb");
     Icf = DStr.AddCurve(TopOpeBRepDS_Curve(gcdeb,tolrcoindeb));    
 
@@ -514,7 +514,7 @@ void ChFi3d_ChBuilder::PerformThreeCorner(const Standard_Integer Jndex)
     if (!ComputeIntersection(DStr,fdfin,coin,
 			     p3dface,p2d1,p3d[deb],p2d2,
 			     gcfin,finpc1,finpc2,deru,derv,ptbid,
-			     tolesp,tol2d,tolrcoinfin)) 
+			     tolapp3d,tol2d,tolrcoinfin)) 
       throw StdFail_NotDone("echec calcul intersection coin-face");
     Icl = DStr.AddCurve(TopOpeBRepDS_Curve(gcfin,tolrcoinfin));  
     
@@ -543,8 +543,8 @@ void ChFi3d_ChBuilder::PerformThreeCorner(const Standard_Integer Jndex)
 	  gaf->Initialize(face[pivot]);
 	  
 	  Standard_Real tolr;
-	  ChFi3d_ProjectPCurv(gac,gaf,facepc1,tolesp,tolr);
-	  ChFi3d_ProjectPCurv(gac,gas,facepc2,tolesp,tolr);
+	  ChFi3d_ProjectPCurv(gac,gaf,facepc1,tolapp3d,tolr);
+	  ChFi3d_ProjectPCurv(gac,gas,facepc2,tolapp3d,tolr);
 	}
       }
     }
@@ -616,18 +616,18 @@ void ChFi3d_ChBuilder::PerformThreeCorner(const Standard_Integer Jndex)
       // les bords de coin sont des lignes courbes qui suivent les 
       // tangentes donnees
       Bfac = ChFi3d_mkbound(Fac,PCurveOnFace,sens[deb],p2d[pivot],Tgpiv,
-			    sens[fin],p2d[3],Tg3,tolesp,2.e-4);
+			    sens[fin],p2d[3],Tg3,tolapp3d,2.e-4);
       Bpiv = ChFi3d_mkbound(Surf,PCurveOnPiv,sens[deb],p2d[fin],vpfin,
-			    sens[fin],p2d[deb],vpdeb,tolesp,2.e-4);
+			    sens[fin],p2d[deb],vpdeb,tolapp3d,2.e-4);
     }
     else {
       // les bords de coin sont des segments
       //      Bfac = ChFi3d_mkbound(Fac,PCurveOnFace,p2d[pivot],
       //			    p2d[3],tolesp,2.e-4);
       Bfac = ChFi3d_mkbound(Fac,PCurveOnFace,p2d[pivot],
-			    p2d[3],tolesp,2.e-4);
+			    p2d[3],tolapp3d,2.e-4);
       Bpiv = ChFi3d_mkbound(Surf,PCurveOnPiv,p2d[fin],
-			    p2d[deb],tolesp,2.e-4);
+			    p2d[deb],tolapp3d,2.e-4);
     }
     
     gp_Pnt2d pdeb1 = fddeb->Interference(jf[deb][pivot]).PCurveOnSurf()->Value(p[deb][pivot]);
@@ -637,15 +637,15 @@ void ChFi3d_ChBuilder::PerformThreeCorner(const Standard_Integer Jndex)
     
     if (issmooth) {
       // il faut homogeneiser, mettre les bords "BoundWithSurf"
-      Bdeb = ChFi3d_mkbound(DStr.Surface(fddeb->Surf()).Surface(),pdeb1,pdeb2,tolesp,2.e-4);
-      Bfin = ChFi3d_mkbound(DStr.Surface(fdfin->Surf()).Surface(),pfin1,pfin2,tolesp,2.e-4);
+      Bdeb = ChFi3d_mkbound(DStr.Surface(fddeb->Surf()).Surface(),pdeb1,pdeb2,tolapp3d,2.e-4);
+      Bfin = ChFi3d_mkbound(DStr.Surface(fdfin->Surf()).Surface(),pfin1,pfin2,tolapp3d,2.e-4);
     }
     else {
       // ou les 4 bords de type "FreeBoundary"
       Bdeb = ChFi3d_mkbound(DStr.Surface(fddeb->Surf()).Surface(),pdeb1,pdeb2,
-			    tolesp,2.e-4,Standard_True);
+			    tolapp3d,2.e-4,Standard_True);
       Bfin = ChFi3d_mkbound(DStr.Surface(fdfin->Surf()).Surface(),pfin1,pfin2,
-			    tolesp,2.e-4,Standard_True);
+			    tolapp3d,2.e-4,Standard_True);
     }
     GeomFill_ConstrainedFilling fil(8,20);
     fil.Init(Bpiv,Bfin,Bfac,Bdeb);
@@ -704,7 +704,7 @@ void ChFi3d_ChBuilder::PerformThreeCorner(const Standard_Integer Jndex)
       ChFi3d_ComputeArete(Pf1,pp1,Pf2,pp2,
 			  DStr.Surface(coin->Surf()).Surface(),C3d,
 			  corner->ChangeFirstPCurve(),P1deb,P2deb,
-			  tolesp,tol2d,tolreached,0);
+        tolapp3d,tol2d,tolreached,0);
       TopOpeBRepDS_Curve Tcurv(C3d,tolreached);
       Icf = DStr.AddCurve(Tcurv);
     }
@@ -733,7 +733,7 @@ void ChFi3d_ChBuilder::PerformThreeCorner(const Standard_Integer Jndex)
       ChFi3d_ComputeArete(Pl1,pp1,Pl2,pp2,
 			  DStr.Surface(coin->Surf()).Surface(),C3d,
 			  corner->ChangeLastPCurve(),P1fin,P2fin,
-			  tolesp,tol2d,tolreached,0);
+        tolapp3d,tol2d,tolreached,0);
       TopOpeBRepDS_Curve Tcurv(C3d,tolreached);
       Icl = DStr.AddCurve(Tcurv);
     }

src/ChFi3d/ChFi3d_FilBuilder.cxx

@@ -689,13 +689,13 @@ ChFi3d_FilBuilder::SimulSurf(Handle(ChFiDS_SurfData)&            Data,
   Data->SetSimul(sec);
   Data->Set2dPoints(pf1,pl1,pf2,pl2);
   ChFi3d_FilCommonPoint(lin->StartPointOnFirst(),lin->TransitionOnS1(),
-			Standard_True, Data->ChangeVertexFirstOnS1(),tolesp);
+			Standard_True, Data->ChangeVertexFirstOnS1(),tolapp3d);
   ChFi3d_FilCommonPoint(lin->EndPointOnFirst(),lin->TransitionOnS1(),
-			Standard_False,Data->ChangeVertexLastOnS1(),tolesp);
+			Standard_False,Data->ChangeVertexLastOnS1(),tolapp3d);
   ChFi3d_FilCommonPoint(lin->StartPointOnSecond(),lin->TransitionOnS2(),
-			Standard_True, Data->ChangeVertexFirstOnS2(),tolesp);
+			Standard_True, Data->ChangeVertexFirstOnS2(),tolapp3d);
   ChFi3d_FilCommonPoint(lin->EndPointOnSecond(),lin->TransitionOnS2(),
-			Standard_False, Data->ChangeVertexLastOnS2(),tolesp);
+			Standard_False, Data->ChangeVertexLastOnS2(),tolapp3d);
   Standard_Boolean reverse = (!Forward || Inside);
   if(intf && reverse){
     Standard_Boolean ok = Standard_False;
@@ -857,13 +857,13 @@ void  ChFi3d_FilBuilder::SimulSurf(Handle(ChFiDS_SurfData)&            Data,
 //  gp_Pnt2d pbid;
   Data->Set2dPoints(ppcf,ppcl,pf,pl);
   ChFi3d_FilCommonPoint(lin->StartPointOnFirst(),lin->TransitionOnS1(),
-			Standard_True, Data->ChangeVertexFirstOnS2(),tolesp);
+			Standard_True, Data->ChangeVertexFirstOnS2(),tolapp3d);
   ChFi3d_FilCommonPoint(lin->EndPointOnFirst(),lin->TransitionOnS1(),
-			Standard_False,Data->ChangeVertexLastOnS2(),tolesp);
+			Standard_False,Data->ChangeVertexLastOnS2(),tolapp3d);
   ChFi3d_FilCommonPoint(lin->StartPointOnSecond(),lin->TransitionOnS2(),
-			Standard_True, Data->ChangeVertexFirstOnS1(),tolesp);
+			Standard_True, Data->ChangeVertexFirstOnS1(),tolapp3d);
   ChFi3d_FilCommonPoint(lin->EndPointOnSecond(),lin->TransitionOnS2(),
-			Standard_False, Data->ChangeVertexLastOnS1(),tolesp);
+			Standard_False, Data->ChangeVertexLastOnS1(),tolapp3d);
 }
 
 //=======================================================================
@@ -989,13 +989,13 @@ void  ChFi3d_FilBuilder::SimulSurf(Handle(ChFiDS_SurfData)&            Data,
   //gp_Pnt2d pbid;
   Data->Set2dPoints(pf,pl,ppcf,ppcl);
   ChFi3d_FilCommonPoint(lin->StartPointOnFirst(),lin->TransitionOnS1(),
-			Standard_True, Data->ChangeVertexFirstOnS1(),tolesp);
+			Standard_True, Data->ChangeVertexFirstOnS1(),tolapp3d);
   ChFi3d_FilCommonPoint(lin->EndPointOnFirst(),lin->TransitionOnS1(),
-			Standard_False,Data->ChangeVertexLastOnS1(),tolesp);
+			Standard_False,Data->ChangeVertexLastOnS1(),tolapp3d);
   ChFi3d_FilCommonPoint(lin->StartPointOnSecond(),lin->TransitionOnS2(),
-			Standard_True, Data->ChangeVertexFirstOnS2(),tolesp);
+			Standard_True, Data->ChangeVertexFirstOnS2(),tolapp3d);
   ChFi3d_FilCommonPoint(lin->EndPointOnSecond(),lin->TransitionOnS2(),
-			Standard_False, Data->ChangeVertexLastOnS2(),tolesp);
+			Standard_False, Data->ChangeVertexLastOnS2(),tolapp3d);
 }
 
 
@@ -1153,13 +1153,13 @@ void  ChFi3d_FilBuilder::SimulSurf(Handle(ChFiDS_SurfData)&            Data,
 //  Data->Set2dPoints(pf,pl,pbid,pbid);
 
   ChFi3d_FilCommonPoint(lin->StartPointOnFirst(),lin->TransitionOnS1(),
-			Standard_True, Data->ChangeVertexFirstOnS1(),tolesp);
+			Standard_True, Data->ChangeVertexFirstOnS1(),tolapp3d);
   ChFi3d_FilCommonPoint(lin->EndPointOnFirst(),lin->TransitionOnS1(),
-			Standard_False,Data->ChangeVertexLastOnS1(),tolesp);
+			Standard_False,Data->ChangeVertexLastOnS1(),tolapp3d);
   ChFi3d_FilCommonPoint(lin->StartPointOnSecond(),lin->TransitionOnS2(),
-			Standard_True, Data->ChangeVertexFirstOnS2(),tolesp);
+			Standard_True, Data->ChangeVertexFirstOnS2(),tolapp3d);
   ChFi3d_FilCommonPoint(lin->EndPointOnSecond(),lin->TransitionOnS2(),
-			Standard_False, Data->ChangeVertexLastOnS2(),tolesp);
+			Standard_False, Data->ChangeVertexLastOnS2(),tolapp3d);
 }
 
 
@@ -1188,14 +1188,14 @@ Standard_Boolean ChFi3d_FilBuilder::PerformFirstSection
 {
   Handle(ChFiDS_FilSpine) fsp = Handle(ChFiDS_FilSpine)::DownCast(Spine);
   if(fsp.IsNull()) throw Standard_ConstructionError("PerformSurf : this is not the spine of a fillet");
-  Standard_Real TolGuide = HGuide->Resolution(tolesp);
+  Standard_Real TolGuide = HGuide->Resolution(tolapp3d);
   if(fsp->IsConstant()){
     BRepBlend_ConstRad Func(S1,S2,HGuide);
     Func.Set(fsp->Radius(),Choix);
     Func.Set(myShape);
     BRepBlend_Walking TheWalk(S1,S2,I1,I2,HGuide);
     return TheWalk.PerformFirstSection(Func,Par,SolDep,
-				       tolesp,TolGuide,Pos1,Pos2);
+               tolapp3d,TolGuide,Pos1,Pos2);
   }
   else {
     BRepBlend_EvolRad Func(S1,S2,HGuide,fsp->Law(HGuide));
@@ -1203,7 +1203,7 @@ Standard_Boolean ChFi3d_FilBuilder::PerformFirstSection
     Func.Set(myShape);
     BRepBlend_Walking TheWalk(S1,S2,I1,I2,HGuide);
     return TheWalk.PerformFirstSection(Func,Par,SolDep,
-				       tolesp,TolGuide,Pos1,Pos2);
+               tolapp3d,TolGuide,Pos1,Pos2);
   }
 }
 

src/ChFi3d/ChFi3d_FilBuilder_C2.cxx

@@ -321,7 +321,7 @@ void ChFi3d_FilBuilder::PerformTwoCorner(const Standard_Integer Index)
     parCP2 = CP2.ParameterOnArc();
     gp_Pnt tst1 = Hpivot->Value(parCP1);
     gp_Pnt tst2 = Hpivot->Value(parCP2);
-    sameparam = tst1.Distance(tst2) <= tolesp;
+    sameparam = tst1.Distance(tst2) <= tolapp3d;
   }
   Handle(BRepAdaptor_Surface) HFaCo = new BRepAdaptor_Surface();
   Handle(BRepAdaptor_Surface) HFaPiv;
@@ -477,18 +477,18 @@ void ChFi3d_FilBuilder::PerformTwoCorner(const Standard_Integer Index)
 #ifdef OCCT_DEBUG
 	ChFi3d_InitChron(ch ); // init perf filling
 #endif 
-	B1 = ChFi3d_mkbound(surf1,p2df1,p2da1,tolesp,2.e-4);
-	B2 = ChFi3d_mkbound(surf2,p2df2,p2da2,tolesp,2.e-4);
+	B1 = ChFi3d_mkbound(surf1,p2df1,p2da1,tolapp3d,2.e-4);
+	B2 = ChFi3d_mkbound(surf2,p2df2,p2da2,tolapp3d,2.e-4);
 	Handle(Geom2d_Curve) PCurveOnFace;
 	Bfac = ChFi3d_mkbound(HFaCo,PCurveOnFace,Sens1,p2dfac1,v2dfac1,
-			      Sens2,p2dfac2,v2dfac2,tolesp,2.e-4);
+			      Sens2,p2dfac2,v2dfac2,tolapp3d,2.e-4);
 	GeomFill_ConstrainedFilling fil(8,20);
 	if(sameparam) {
 	  fil.Init(Bfac,B2,B1,1);
 	}
 	else {
 	  Handle(Adaptor3d_Curve) HPivTrim = Hpivot->Trim(Min(parCP1,parCP2),Max(parCP1,parCP2),tolesp);
-	  Bpiv = new GeomFill_SimpleBound(HPivTrim,tolesp,2.e-4);
+	  Bpiv = new GeomFill_SimpleBound(HPivTrim,tolapp3d,2.e-4);
 	  fil.Init(Bfac,B2,Bpiv,B1,1);
 	  BRepAdaptor_Curve2d pcpivot;
 	  gp_Vec dArc,dcf;
@@ -597,14 +597,14 @@ void ChFi3d_FilBuilder::PerformTwoCorner(const Standard_Integer Index)
 	ChFi3d_ComputeArete(Pf1,pp1,Pf2,pp2,
 			    DStr.Surface(coin->Surf()).Surface(),C3d,
 			    corner->ChangeFirstPCurve(),P1deb,P2deb,
-			    tolesp,tol2d,tolreached,0);
+			    tolapp3d,tol2d,tolreached,0);
 	Standard_Real par1 = sd1->Interference(IFaArc1).Parameter(isfirst1);
 	pp1 = sd1->Interference(IFaCo1).PCurveOnSurf()->Value(par1);
 	pp2 = sd1->Interference(IFaArc1).PCurveOnSurf()->Value(par1);
 	Standard_Real tolr1;
 	ChFi3d_ComputePCurv(C3d,pp1,pp2,st1->ChangePCurve(isfirst1),
 			    DStr.Surface(sd1->Surf()).Surface(),
-			    P1deb,P2deb,tolesp,tolr1);
+			    P1deb,P2deb,tolapp3d,tolr1);
 	tolreached = Max(tolreached,tolr1);
 	TopOpeBRepDS_Curve Tcurv1(C3d,tolreached);
 	Icf = DStr.AddCurve(Tcurv1);
@@ -624,14 +624,14 @@ void ChFi3d_FilBuilder::PerformTwoCorner(const Standard_Integer Index)
 	ChFi3d_ComputeArete(Pl1,pp1,Pl2,pp2,
 			    DStr.Surface(coin->Surf()).Surface(),C3d,
 			    corner->ChangeLastPCurve(),P1fin,P2fin,
-			    tolesp,tol2d,tolreached,0);
+			    tolapp3d,tol2d,tolreached,0);
 	Standard_Real par2 = sd2->Interference(IFaArc2).Parameter(isfirst2);
 	pp1 = sd2->Interference(IFaCo2).PCurveOnSurf()->Value(par2);
 	pp2 = sd2->Interference(IFaArc2).PCurveOnSurf()->Value(par2);
 	Standard_Real tolr2;
 	ChFi3d_ComputePCurv(C3d,pp1,pp2,st2->ChangePCurve(isfirst2),
 			    DStr.Surface(sd2->Surf()).Surface(),
-			    P1deb,P2deb,tolesp,tolr2);
+			    P1deb,P2deb,tolapp3d,tolr2);
 	tolreached = Max(tolreached,tolr2);
 	TopOpeBRepDS_Curve Tcurv2(C3d,tolreached);
 	Icl = DStr.AddCurve(Tcurv2);
@@ -732,7 +732,7 @@ void ChFi3d_FilBuilder::PerformTwoCorner(const Standard_Integer Index)
       Handle(Geom_Surface) surfsam = DStr.Surface(sdsam->Surf()).Surface();
       Handle(GeomAdaptor_Surface) Hsurfsam = new GeomAdaptor_Surface(surfsam);
       Handle(Geom2d_Curve) pcsurfsam;
-      Bsam = ChFi3d_mkbound(Hsurfsam,pcsurfsam,ppopsam,ppcosam,tolesp,2.e-4);
+      Bsam = ChFi3d_mkbound(Hsurfsam,pcsurfsam,ppopsam,ppcosam,tolapp3d,2.e-4);
       Standard_Real upcopdif = sddif->Interference(ifaopdif).Parameter(isfirstdif);
       gp_Pnt2d ppopdif = 
 	sddif->Interference(ifaopdif).PCurveOnSurf()->Value(upcopdif);
@@ -741,7 +741,7 @@ void ChFi3d_FilBuilder::PerformTwoCorner(const Standard_Integer Index)
       Handle(Geom_Surface) surfdif = DStr.Surface(sddif->Surf()).Surface();
       Handle(GeomAdaptor_Surface) Hsurfdif = new GeomAdaptor_Surface(surfdif);
       Handle(Geom2d_Curve) pcsurfdif;
-      Bdif = ChFi3d_mkbound(Hsurfdif,pcsurfdif,ppcodif,ppopdif,tolesp,2.e-4);
+      Bdif = ChFi3d_mkbound(Hsurfdif,pcsurfdif,ppcodif,ppopdif,tolapp3d,2.e-4);
       gp_Pnt2d ppfacsam,ppfacdif;
       gp_Pnt PPfacsam,PPfacdif;
       gp_Vec VVfacsam,VVfacdif;
@@ -773,7 +773,7 @@ void ChFi3d_FilBuilder::PerformTwoCorner(const Standard_Integer Index)
       Handle(Geom2d_Curve) pcFopsam = ChFi3d_BuildPCurve(HBRFopsam,
 							 ppfacsam,VVfacsam,
 							 ppfacdif,VVfacdif,1);
-      Bfac = ChFi3d_mkbound(HBRFopsam,pcFopsam,tolesp,2.e-4);
+      Bfac = ChFi3d_mkbound(HBRFopsam,pcFopsam,tolapp3d,2.e-4);
       GeomFill_ConstrainedFilling fil(8,20);
       fil.Init(Bsam,Bdif,Bfac,1);
 #if 0
@@ -827,10 +827,10 @@ void ChFi3d_FilBuilder::PerformTwoCorner(const Standard_Integer Index)
       ChFi3d_ComputeArete(Pf1,pp1,Pf2,pp2,
 			  DStr.Surface(coin->Surf()).Surface(),C3d,
 			  corner->ChangeFirstPCurve(),P1deb,P2deb,
-			  tolesp,tol2d,tolreached,0);
+			  tolapp3d,tol2d,tolreached,0);
       Standard_Real tolr1;
       Handle(GeomAdaptor_Curve) HC3d = new GeomAdaptor_Curve(C3d);
-      ChFi3d_SameParameter(HC3d,pcFopsam,HBRFopsam,tolesp,tolr1);
+      ChFi3d_SameParameter(HC3d,pcFopsam,HBRFopsam,tolapp3d,tolr1);
       tolreached = Max(tolreached,tolr1);
       TopOpeBRepDS_Curve Tcurv1(C3d,tolreached);
       Icf = DStr.AddCurve(Tcurv1);
@@ -858,10 +858,10 @@ void ChFi3d_FilBuilder::PerformTwoCorner(const Standard_Integer Index)
       ChFi3d_ComputeArete(Pl1,pp1,Pl2,pp2,
 			  DStr.Surface(coin->Surf()).Surface(),C3d,
 			  corner->ChangeLastPCurve(),P1fin,P2fin,
-			  tolesp,tol2d,tolreached,0);
+        tolapp3d,tol2d,tolreached,0);
       Standard_Real tolr2;
       HC3d->Load(C3d);
-      ChFi3d_SameParameter(HC3d,pcsurfdif,Hsurfdif,tolesp,tolr2);
+      ChFi3d_SameParameter(HC3d,pcsurfdif,Hsurfdif,tolapp3d,tolr2);
       tolreached = Max(tolreached,tolr2);
       TopOpeBRepDS_Curve Tcurv2(C3d,tolreached);
       Icl = DStr.AddCurve(Tcurv2);

src/ChFi3d/ChFi3d_FilBuilder_C3.cxx

@@ -307,7 +307,7 @@ void ChFi3d_FilBuilder::PerformThreeCorner(const Standard_Integer Jndex)
 	pivot = ii; deb = jj; fin = kk;
       }
     }
-    if(!c1toric)c1spheric=(Abs(qr[0]-qr[1])<tolesp && Abs(qr[0]-qr[2])<tolesp);
+    if(!c1toric)c1spheric=(Abs(qr[0]-qr[1])<tolapp3d && Abs(qr[0]-qr[2])<tolapp3d);
   }
   
   //  Previously to avoid loops the points were always located 
@@ -543,14 +543,14 @@ void ChFi3d_FilBuilder::PerformThreeCorner(const Standard_Integer Jndex)
       Handle(BRepBlend_Line) lin;
       Standard_Real ffi = WFirst, lla = WLast + pasmax;
       
-      if (Abs(Rdeb-Rfin)<=tolesp){
+      if (Abs(Rdeb-Rfin)<=tolapp3d){
 	
 	BRepBlend_ConstRad func(Fac,Surf,cornerspine);
 	BRepBlend_ConstRadInv finv(Fac,Surf,cornerspine);
 	func.Set(Rdeb,choix);
 	func.Set(myShape);
 	finv.Set(Rdeb,choix);
-	Standard_Real TolGuide = cornerspine->Resolution(tolesp); 
+	Standard_Real TolGuide = cornerspine->Resolution(tolapp3d);
 	
 	Standard_Integer intf = 3, intl = 3;
 	done = ComputeData(coin,cornerspine,NullSpine,lin,Fac,IFac,Surf,ISurf,
@@ -573,7 +573,7 @@ void ChFi3d_FilBuilder::PerformThreeCorner(const Standard_Integer Jndex)
 	func.Set(choix);
 	func.Set(myShape);
 	finv.Set(choix);
-	Standard_Real TolGuide = cornerspine->Resolution(tolesp);
+	Standard_Real TolGuide = cornerspine->Resolution(tolapp3d);
 	Standard_Integer intf = 3, intl = 3;
 	done = ComputeData(coin,cornerspine,NullSpine,lin,Fac,IFac,Surf,ISurf,
 			   func,finv,ffi,pasmax,locfleche,TolGuide,ffi,lla,
@@ -607,7 +607,7 @@ void ChFi3d_FilBuilder::PerformThreeCorner(const Standard_Integer Jndex)
       Handle(Geom2d_Curve) PCurveOnFace;
       if(!c1pointu) 
 	Bfac = ChFi3d_mkbound(Fac,PCurveOnFace,sens[deb],pfac1,vfac1,
-			      sens[fin],pfac2,vfac2,tolesp,2.e-4);
+			      sens[fin],pfac2,vfac2,tolapp3d,2.e-4);
       Standard_Integer kkk;
       gp_Pnt ppbid;
       gp_Vec vp1,vp2;
@@ -620,7 +620,7 @@ void ChFi3d_FilBuilder::PerformThreeCorner(const Standard_Integer Jndex)
       Handle(Geom2d_Curve) PCurveOnPiv;
 //      Bpiv = ChFi3d_mkbound(Surf,PCurveOnPiv,sens[deb],psurf1,vp1,
 //			    sens[fin],psurf2,vp2,tolesp,2.e-4);
-      Bpiv = ChFi3d_mkbound(Surf,PCurveOnPiv,psurf1,psurf2,tolesp,2.e-4,0);
+      Bpiv = ChFi3d_mkbound(Surf,PCurveOnPiv,psurf1,psurf2,tolapp3d,2.e-4,0);
       Standard_Real pardeb2 = p[deb][pivot];
       Standard_Real parfin2 = p[fin][pivot];
       if(c1pointu){
@@ -642,8 +642,8 @@ void ChFi3d_FilBuilder::PerformThreeCorner(const Standard_Integer Jndex)
 	DStr.Surface(CD[fin]->SetOfSurfData()->
 		     Value(i[fin][pivot])->Surf()).Surface();
       
-      Bdeb = ChFi3d_mkbound(sdeb,pdeb1,pdeb2,tolesp,2.e-4);
-      Bfin = ChFi3d_mkbound(sfin,pfin1,pfin2,tolesp,2.e-4);
+      Bdeb = ChFi3d_mkbound(sdeb,pdeb1,pdeb2,tolapp3d,2.e-4);
+      Bfin = ChFi3d_mkbound(sfin,pfin1,pfin2,tolapp3d,2.e-4);
       
       GeomFill_ConstrainedFilling fil(11,20);
       if(c1pointu) fil.Init(Bpiv,Bfin,Bdeb,1);
@@ -712,7 +712,7 @@ void ChFi3d_FilBuilder::PerformThreeCorner(const Standard_Integer Jndex)
     ChFi3d_ComputeArete(Pf1,pp1,Pf2,pp2,
 			DStr.Surface(coin->Surf()).Surface(),C3d,
 			corner->ChangeFirstPCurve(),P1deb,P2deb,
-			tolesp,tol2d,tolreached,0);
+			tolapp3d,tol2d,tolreached,0);
     TopOpeBRepDS_Curve Tcurv1(C3d,tolreached);
     Icf = DStr.AddCurve(Tcurv1);
     regdeb.SetCurve(Icf);
@@ -732,7 +732,7 @@ void ChFi3d_FilBuilder::PerformThreeCorner(const Standard_Integer Jndex)
     ChFi3d_ComputeArete(Pl1,pp1,Pl2,pp2,
 			DStr.Surface(coin->Surf()).Surface(),C3d,
 			corner->ChangeLastPCurve(),P1fin,P2fin,
-			tolesp,tol2d,tolreached,0);
+			tolapp3d,tol2d,tolreached,0);
     TopOpeBRepDS_Curve Tcurv2(C3d,tolreached);
     Icl = DStr.AddCurve(Tcurv2);
     regfin.SetCurve(Icl);
@@ -770,7 +770,7 @@ void ChFi3d_FilBuilder::PerformThreeCorner(const Standard_Integer Jndex)
     Standard_Real tolrdeb;
     ChFi3d_ComputePCurv(crefdeb,pp1,pp2,CD[deb]->ChangePCurve(isfirst),
 			DStr.Surface(fddeb->Surf()).Surface(),
-			P1deb,P2deb,tolesp,tolrdeb,rev);
+			P1deb,P2deb,tolapp3d,tolrdeb,rev);
     tcdeb.Tolerance(Max(tolrdeb,tcdeb.Tolerance()));
     if(rev) ChFi3d_EnlargeBox(DStr,CD[deb],fddeb,*pbf2,*pbf1,isfirst);
     else ChFi3d_EnlargeBox(DStr,CD[deb],fddeb,*pbf1,*pbf2,isfirst);
@@ -800,7 +800,7 @@ void ChFi3d_FilBuilder::PerformThreeCorner(const Standard_Integer Jndex)
     Standard_Real tolrfin;
     ChFi3d_ComputePCurv(creffin,pp1,pp2,CD[fin]->ChangePCurve(isfirst),
 			DStr.Surface(fdfin->Surf()).Surface(),
-			P1fin,P2fin,tolesp,tolrfin,rev);
+			P1fin,P2fin,tolapp3d,tolrfin,rev);
     tcfin.Tolerance(Max(tolrfin,tcfin.Tolerance()));
     if(rev) ChFi3d_EnlargeBox(DStr,CD[fin],fdfin,*pbl2,*pbl1,isfirst);
     else ChFi3d_EnlargeBox(DStr,CD[fin],fdfin,*pbl1,*pbl2,isfirst);
@@ -823,7 +823,7 @@ void ChFi3d_FilBuilder::PerformThreeCorner(const Standard_Integer Jndex)
     Standard_Real tolr;
     ChFi3d_SameParameter(Ccoinpiv,C2dOnPiv,Spiv,
 			 fi.FirstParameter(),fi.LastParameter(),
-			 tolesp,tolr);
+			 tolapp3d,tolr);
     TCcoinpiv.Tolerance(Max(TCcoinpiv.Tolerance(),tolr));
     CD[pivot]->ChangePCurve(isfirst) = C2dOnPiv;
     CD[pivot]->SetIndexPoint(If2,isfirst,isurf1);

src/ChFiDS/ChFiDS_Spine.cxx

@@ -558,6 +558,17 @@ void  ChFiDS_Spine::Load()
   }
   indexofcurve =1;
   myCurve.Initialize(TopoDS::Edge(spine.Value(1)));
+
+  // Here, we should update tolesp according to curve parameter range
+  // if tolesp candidate less than default initial value.
+  const Standard_Real umin = FirstParameter();
+  const Standard_Real umax = LastParameter();
+
+  Standard_Real new_tolesp = 5.0e-5 * (umax - umin);
+  if (tolesp > new_tolesp)
+  {
+    tolesp = new_tolesp;
+  }
 }
 
 

src/ChFiDS/ChFiDS_Spine.hxx

@@ -244,6 +244,9 @@ public:
   //! Return the mode of chamfers used
   Standard_EXPORT ChFiDS_ChamfMode Mode() const;
 
+  //! Return tolesp parameter
+  Standard_EXPORT Standard_Real GetTolesp() const;
+
 
 
   DEFINE_STANDARD_RTTIEXT(ChFiDS_Spine,Standard_Transient)

src/ChFiDS/ChFiDS_Spine.lxx

@@ -214,3 +214,12 @@ inline ChFiDS_ChamfMode  ChFiDS_Spine::Mode() const
 
   return myMode;
 }
+
+//=======================================================================
+//function : GetTolesp
+//purpose  : 
+//=======================================================================
+inline Standard_Real ChFiDS_Spine::GetTolesp() const
+{
+  return tolesp;
+}

src/ChFiDS/ChFiDS_TypeOfConcavity.hxx

@@ -24,7 +24,8 @@ ChFiDS_Concave,
 ChFiDS_Convex,
 ChFiDS_Tangential,
 ChFiDS_FreeBound,
-ChFiDS_Other
+ChFiDS_Other,
+ChFiDS_Mixed
 };
 
 #endif // _ChFiDS_TypeOfConcavity_HeaderFile

src/DE/DE_ConfigurationNode.cxx

@@ -88,8 +88,11 @@ bool DE_ConfigurationNode::Save(const TCollection_AsciiString& theResourcePath)
 // function : UpdateLoad
 // purpose  :
 //=======================================================================
-bool DE_ConfigurationNode::UpdateLoad()
+bool DE_ConfigurationNode::UpdateLoad(const Standard_Boolean theToImport,
+                                      const Standard_Boolean theToKeep)
 {
+  (void)theToImport;
+  (void)theToKeep;
   return true;
 }
 

src/DE/DE_ConfigurationNode.hxx

@@ -85,9 +85,12 @@ public:
   //! @return new object with the same field values
   Standard_EXPORT virtual Handle(DE_ConfigurationNode) Copy() const = 0;
 
-  //! Update loading status. Checking for the license.
+  //! Update loading status. Checking for the ability to read and write.
+  //! @param[in] theToImport flag to updates for import. Standard_True-import, Standard_False-export
+  //! @param[in] theToKeep flag to save update result
   //! @return Standard_True, if node can be used
-  Standard_EXPORT virtual bool UpdateLoad();
+  Standard_EXPORT virtual bool UpdateLoad(const Standard_Boolean theToImport,
+                                          const Standard_Boolean theToKeep);
 
 public:
 

src/DE/DE_Wrapper.cxx

@@ -34,6 +34,9 @@ namespace
     static const TCollection_AsciiString aScope ("global");
     return aScope;
   }
+
+  //! Global configuration of current DE Session
+  static Handle(DE_Wrapper) THE_GLOBAL_CONFIGURATION;
 }
 
 //=======================================================================
@@ -41,6 +44,7 @@ namespace
 // purpose  :
 //=======================================================================
 DE_Wrapper::DE_Wrapper()
+  :myKeepUpdates(Standard_False)
 {}
 
 //=======================================================================
@@ -64,6 +68,7 @@ DE_Wrapper::DE_Wrapper(const Handle(DE_Wrapper)& theWrapper)
       Bind(aVendorIter.Value());
     }
   }
+  theWrapper->myKeepUpdates = myKeepUpdates;
 }
 
 //=======================================================================
@@ -72,8 +77,23 @@ DE_Wrapper::DE_Wrapper(const Handle(DE_Wrapper)& theWrapper)
 //=======================================================================
 Handle(DE_Wrapper) DE_Wrapper::GlobalWrapper()
 {
-  static const Handle(DE_Wrapper)& aConfiguration = new DE_Wrapper();
-  return aConfiguration;
+  if (THE_GLOBAL_CONFIGURATION.IsNull())
+  {
+    THE_GLOBAL_CONFIGURATION = new DE_Wrapper();
+  }
+  return THE_GLOBAL_CONFIGURATION;
+}
+
+//=======================================================================
+// function : SetGlobalWrapper
+// purpose  :
+//=======================================================================
+void DE_Wrapper::SetGlobalWrapper(const Handle(DE_Wrapper)& theWrapper)
+{
+  if (!theWrapper.IsNull())
+  {
+    THE_GLOBAL_CONFIGURATION = theWrapper;
+  }
 }
 
 //=======================================================================
@@ -81,7 +101,7 @@ Handle(DE_Wrapper) DE_Wrapper::GlobalWrapper()
 // purpose  :
 //=======================================================================
 Standard_Boolean DE_Wrapper::Read(const TCollection_AsciiString& thePath,
-                                  Handle(TDocStd_Document)& theDocument,
+                                  const Handle(TDocStd_Document)& theDocument,
                                   Handle(XSControl_WorkSession)& theWS,
                                   const Message_ProgressRange& theProgress)
 {
@@ -94,7 +114,7 @@ Standard_Boolean DE_Wrapper::Read(const TCollection_AsciiString& thePath,
     return Read(thePath, theDocument, theProgress);
   }
   Handle(DE_Provider) aProvider;
-  if (!findProvider(thePath, Standard_True, aProvider))
+  if (!FindProvider(thePath, Standard_True, aProvider))
   {
     return Standard_False;
   }
@@ -119,7 +139,7 @@ Standard_Boolean DE_Wrapper::Write(const TCollection_AsciiString& thePath,
     return Write(thePath, theDocument, theProgress);
   }
   Handle(DE_Provider) aProvider;
-  if (!findProvider(thePath, Standard_False, aProvider))
+  if (!FindProvider(thePath, Standard_False, aProvider))
   {
     return Standard_False;
   }
@@ -131,7 +151,7 @@ Standard_Boolean DE_Wrapper::Write(const TCollection_AsciiString& thePath,
 // purpose  :
 //=======================================================================
 Standard_Boolean DE_Wrapper::Read(const TCollection_AsciiString& thePath,
-                                  Handle(TDocStd_Document)& theDocument,
+                                  const Handle(TDocStd_Document)& theDocument,
                                   const Message_ProgressRange& theProgress)
 {
   if (theDocument.IsNull())
@@ -139,7 +159,7 @@ Standard_Boolean DE_Wrapper::Read(const TCollection_AsciiString& thePath,
     return Standard_False;
   }
   Handle(DE_Provider) aProvider;
-  if (!findProvider(thePath, Standard_True, aProvider))
+  if (!FindProvider(thePath, Standard_True, aProvider))
   {
     return Standard_False;
   }
@@ -159,7 +179,7 @@ Standard_Boolean DE_Wrapper::Write(const TCollection_AsciiString& thePath,
     return Standard_False;
   }
   Handle(DE_Provider) aProvider;
-  if (!findProvider(thePath, Standard_False, aProvider))
+  if (!FindProvider(thePath, Standard_False, aProvider))
   {
     return Standard_False;
   }
@@ -180,7 +200,7 @@ Standard_Boolean DE_Wrapper::Read(const TCollection_AsciiString& thePath,
     return Read(thePath, theShape, theProgress);
   }
   Handle(DE_Provider) aProvider;
-  if (!findProvider(thePath, Standard_True, aProvider))
+  if (!FindProvider(thePath, Standard_True, aProvider))
   {
     return Standard_False;
   }
@@ -201,7 +221,7 @@ Standard_Boolean DE_Wrapper::Write(const TCollection_AsciiString& thePath,
     return Write(thePath, theShape, theProgress);
   }
   Handle(DE_Provider) aProvider;
-  if (!findProvider(thePath, Standard_False, aProvider))
+  if (!FindProvider(thePath, Standard_False, aProvider))
   {
     return Standard_False;
   }
@@ -218,7 +238,7 @@ Standard_Boolean DE_Wrapper::Read(const TCollection_AsciiString& thePath,
 {
 
   Handle(DE_Provider) aProvider;
-  if (!findProvider(thePath, Standard_True, aProvider))
+  if (!FindProvider(thePath, Standard_True, aProvider))
   {
     return Standard_False;
   }
@@ -234,7 +254,7 @@ Standard_Boolean DE_Wrapper::Write(const TCollection_AsciiString& thePath,
                                    const Message_ProgressRange& theProgress)
 {
   Handle(DE_Provider) aProvider;
-  if (!findProvider(thePath, Standard_False, aProvider))
+  if (!FindProvider(thePath, Standard_False, aProvider))
   {
     return Standard_False;
   }
@@ -427,7 +447,6 @@ void DE_Wrapper::ChangePriority(const TCollection_AsciiString& theFormat,
     if (aVendorMap.FindFromKey(aVendorName, aNode))
     {
       aNode->SetEnabled(Standard_True);
-      aNode->UpdateLoad();
       aNewVendorMap.Add(aVendorName, aNode);
     }
   }
@@ -482,10 +501,10 @@ Handle(DE_Wrapper) DE_Wrapper::Copy() const
 }
 
 //=======================================================================
-// function : findProvider
+// function : FindProvider
 // purpose  :
 //=======================================================================
-Standard_Boolean DE_Wrapper::findProvider(const TCollection_AsciiString& thePath,
+Standard_Boolean DE_Wrapper::FindProvider(const TCollection_AsciiString& thePath,
                                           const Standard_Boolean theToImport,
                                           Handle(DE_Provider)& theProvider) const
 {
@@ -514,7 +533,8 @@ Standard_Boolean DE_Wrapper::findProvider(const TCollection_AsciiString& thePath
           ((theToImport && aNode->IsImportSupported()) ||
           (!theToImport && aNode->IsExportSupported())) &&
           (aNode->CheckExtension(anExtr) ||
-          (theToImport && aNode->CheckContent(aBuffer))))
+          (theToImport && aNode->CheckContent(aBuffer))) &&
+          aNode->UpdateLoad(theToImport, myKeepUpdates))
       {
         theProvider = aNode->BuildProvider();
         aNode->GlobalParameters = GlobalParameters;
@@ -526,6 +546,28 @@ Standard_Boolean DE_Wrapper::findProvider(const TCollection_AsciiString& thePath
   return Standard_False;
 }
 
+//=======================================================================
+// function : UpdateLoad
+// purpose  :
+//=======================================================================
+Standard_EXPORT void DE_Wrapper::UpdateLoad(const Standard_Boolean theToForceUpdate) const
+{
+  for (DE_ConfigurationFormatMap::Iterator aFormatIter(myConfiguration);
+       aFormatIter.More(); aFormatIter.Next())
+  {
+    for (DE_ConfigurationVendorMap::Iterator aVendorIter(aFormatIter.Value());
+         aVendorIter.More(); aVendorIter.Next())
+    {
+      const Handle(DE_ConfigurationNode)& aNode = aVendorIter.Value();
+      aNode->UpdateLoad(Standard_True, Standard_True);
+      aNode->UpdateLoad(Standard_False, Standard_True);
+      if (!theToForceUpdate)
+        continue;
+      aNode->SetEnabled(aNode->IsExportSupported() || aNode->IsImportSupported());
+    }
+  }
+}
+
 //=======================================================================
 // function : sort
 // purpose  :

src/DE/DE_Wrapper.hxx

@@ -61,10 +61,15 @@ public:
   //! @param[in] theWrapper object to copy
   Standard_EXPORT DE_Wrapper(const Handle(DE_Wrapper)& theWrapper);
 
-  //! Gets global configuration singleton
+  //! Gets global configuration singleton.
+  //! If wrapper is not set, create it by default as base class object.
   //! @return point to global configuration
   Standard_EXPORT static Handle(DE_Wrapper) GlobalWrapper();
 
+  //! Sets global configuration singleton
+  //! @param[in] theWrapper object to set as global configuration
+  Standard_EXPORT static void SetGlobalWrapper(const Handle(DE_Wrapper)& theWrapper);
+
 public:
 
   //! Reads a CAD file, according internal configuration
@@ -74,7 +79,7 @@ public:
   //! @param theProgress[in] progress indicator
   //! @return true if Read operation has ended correctly
   Standard_EXPORT Standard_Boolean Read(const TCollection_AsciiString& thePath,
-                                        Handle(TDocStd_Document)& theDocument,
+                                        const Handle(TDocStd_Document)& theDocument,
                                         Handle(XSControl_WorkSession)& theWS,
                                         const Message_ProgressRange& theProgress = Message_ProgressRange());
 
@@ -95,7 +100,7 @@ public:
   //! @param theProgress[in] progress indicator
   //! @return true if Read operation has ended correctly
   Standard_EXPORT Standard_Boolean Read(const TCollection_AsciiString& thePath,
-                                        Handle(TDocStd_Document)& theDocument,
+                                        const Handle(TDocStd_Document)& theDocument,
                                         const Message_ProgressRange& theProgress = Message_ProgressRange());
 
   //! Writes a CAD file, according internal configuration
@@ -211,13 +216,33 @@ public:
   Standard_EXPORT void ChangePriority(const TColStd_ListOfAsciiString& theVendorPriority,
                                       const Standard_Boolean theToDisable = Standard_False);
 
+  //! Find available provider from the configuration.
+  //! If there are several providers, choose the one with the highest priority.
+  //! @param[in] thePath path to the CAD file
+  //! @param[in] theToImport flag to finds for import. Standard_True-import, Standard_False-export
+  //! @param[out] theProvider created new provider
+  //! @return Standard_True if provider found and created
+  Standard_EXPORT virtual Standard_Boolean FindProvider(const TCollection_AsciiString& thePath,
+                                                        const Standard_Boolean theToImport,
+                                                        Handle(DE_Provider)& theProvider) const;
+
+  //! Updates all registered nodes, all changes will be saved in nodes
+  //! @param[in] theToForceUpdate flag that turns on/of nodes, according to updated ability to import/export
+  Standard_EXPORT void UpdateLoad(const Standard_Boolean theToForceUpdate = Standard_False) const;
+
+  //! Gets flag that keeps changes on configuration nodes which are being updated, false by default
+  Standard_Boolean KeepUpdates() const { return myKeepUpdates; }
+
+  //! Sets flag that keeps changes on configuration nodes which are being updated, false by default
+  void SetKeepUpdates(const Standard_Boolean theToKeepUpdates) { myKeepUpdates = theToKeepUpdates; }
+
   //! Gets format map, contains vendor map with nodes
   //! @return internal map of formats
   Standard_EXPORT const DE_ConfigurationFormatMap& Nodes() const;
 
   //! Copies values of all fields
   //! @return new object with the same field values
-  Standard_EXPORT Handle(DE_Wrapper) Copy() const;
+  Standard_EXPORT virtual Handle(DE_Wrapper) Copy() const;
 
 protected:
 
@@ -227,22 +252,13 @@ protected:
   //! @param[in] theResource resource to get priority
   void sort(const Handle(DE_ConfigurationContext)& theResource);
 
-  //! Find available provider from the configuration.
-  //! If there are several providers, choose the one with the highest priority.
-  //! @param[in] thePath path to the CAD file
-  //! @param[in] theToImport flag to finds for import. Standard_True-import, Standard_False-export
-  //! @param[out] theProvider created new provider
-  //! @return Standard_True if provider found and created
-  Standard_Boolean findProvider(const TCollection_AsciiString& thePath,
-                                const Standard_Boolean theToImport,
-                                Handle(DE_Provider)& theProvider) const;
-
 public:
 
   DE_ConfigurationNode::DE_SectionGlobal GlobalParameters; //!< Internal parameters for the all translators
 
 private:
 
+  Standard_Boolean myKeepUpdates; //!< Flag that keeps changes on configuration nodes which are being updated
   DE_ConfigurationFormatMap myConfiguration; //!< Internal map of formats
 };
 

src/DEBRepCascade/DEBRepCascade_ConfigurationNode.cxx

@@ -34,9 +34,7 @@ namespace
 //=======================================================================
 DEBRepCascade_ConfigurationNode::DEBRepCascade_ConfigurationNode() :
   DE_ConfigurationNode()
-{
-  UpdateLoad();
-}
+{}
 
 //=======================================================================
 // function : DEBRepCascade_ConfigurationNode
@@ -46,7 +44,6 @@ DEBRepCascade_ConfigurationNode::DEBRepCascade_ConfigurationNode(const Handle(DE
   :DE_ConfigurationNode(theNode)
 {
   InternalParameters = theNode->InternalParameters;
-  UpdateLoad();
 }
 
 //=======================================================================

src/DEXCAFCascade/DEXCAFCascade_ConfigurationNode.cxx

@@ -34,9 +34,7 @@ namespace
 //=======================================================================
 DEXCAFCascade_ConfigurationNode::DEXCAFCascade_ConfigurationNode() :
   DE_ConfigurationNode()
-{
-  UpdateLoad();
-}
+{}
 
 //=======================================================================
 // function : DEXCAFCascade_ConfigurationNode
@@ -46,7 +44,6 @@ DEXCAFCascade_ConfigurationNode::DEXCAFCascade_ConfigurationNode(const Handle(DE
   :DE_ConfigurationNode(theNode)
 {
   InternalParameters = theNode->InternalParameters;
-  UpdateLoad();
 }
 
 //=======================================================================

src/Draft/Draft_FaceInfo.cxx

@@ -37,7 +37,9 @@ Draft_FaceInfo::Draft_FaceInfo (const Handle(Geom_Surface)& S,\
 				const Standard_Boolean HasNewGeometry):
        myNewGeom(HasNewGeometry)
 {
-  myGeom = S;
+  Handle(Geom_RectangularTrimmedSurface) T = Handle(Geom_RectangularTrimmedSurface)::DownCast(S);
+  if (!T.IsNull()) myGeom = T->BasisSurface();
+  else             myGeom = S;
 }
 
 

src/Draft/Draft_Modification_1.cxx

@@ -481,7 +481,7 @@ Standard_Boolean Draft_Modification::Propagate ()
           Handle(Geom_Surface)::DownCast(S->Transformed(L.Transformation()));
 
         const Handle(Standard_Type)& typs = S->DynamicType();
-        if (/*typs == STANDARD_TYPE(Geom_CylindricalSurface) ||*/
+        if (typs == STANDARD_TYPE(Geom_CylindricalSurface) ||
             typs == STANDARD_TYPE(Geom_ConicalSurface)) {
           Standard_Real umin,umax,vmin,vmax;
           BRepTools::UVBounds(F,umin,umax,vmin,vmax);
@@ -1062,11 +1062,7 @@ void Draft_Modification::Perform ()
               //Find the first curve to glue
               TColGeom_SequenceOfCurve Candidates;
               if (S1->DynamicType() == STANDARD_TYPE(Geom_CylindricalSurface) ||
-                  S1->DynamicType() == STANDARD_TYPE(Geom_ConicalSurface) ||
-                  S1->DynamicType() == STANDARD_TYPE(Geom_RectangularTrimmedSurface) &&
-                  Handle(Geom_RectangularTrimmedSurface)::DownCast(S1)->BasisSurface()->DynamicType() == STANDARD_TYPE(Geom_CylindricalSurface) ||
-                  S1->DynamicType() == STANDARD_TYPE(Geom_RectangularTrimmedSurface) &&
-                  Handle(Geom_RectangularTrimmedSurface)::DownCast(S1)->BasisSurface()->DynamicType() == STANDARD_TYPE(Geom_ConicalSurface))
+                  S1->DynamicType() == STANDARD_TYPE(Geom_ConicalSurface)) 
               {
                 for (i = 1; i <= i2s.NbLines(); i++)
                 {

src/ExpToCasExe/EXTERNLIB

@@ -1,2 +1,3 @@
 TKernel
 TKExpress
+CSF_wsock32

src/FilletSurf/FilletSurf_InternalBuilder.cxx

@@ -345,19 +345,19 @@ Standard_Boolean
   if(!done) return Standard_False;
   if(lin->StartPointOnFirst().NbPointOnRst() !=0){
     ChFi3d_FilCommonPoint(lin->StartPointOnFirst(),lin->TransitionOnS1(),
-			  Standard_True, Data->ChangeVertexFirstOnS1(), tolesp);
+			  Standard_True, Data->ChangeVertexFirstOnS1(), tolapp3d);
   }
   if(lin->EndPointOnFirst().NbPointOnRst() !=0){
     ChFi3d_FilCommonPoint(lin->EndPointOnFirst(),lin->TransitionOnS1(),
-			  Standard_False,Data->ChangeVertexLastOnS1(), tolesp);
+			  Standard_False,Data->ChangeVertexLastOnS1(), tolapp3d);
   }
   if(lin->StartPointOnSecond().NbPointOnRst() !=0){
     ChFi3d_FilCommonPoint(lin->StartPointOnSecond(),lin->TransitionOnS2(),
-			  Standard_True, Data->ChangeVertexFirstOnS2(), tolesp);
+			  Standard_True, Data->ChangeVertexFirstOnS2(), tolapp3d);
   }
   if(lin->EndPointOnSecond().NbPointOnRst() !=0){
     ChFi3d_FilCommonPoint(lin->EndPointOnSecond(),lin->TransitionOnS2(),
-			  Standard_False, Data->ChangeVertexLastOnS2(), tolesp);
+			  Standard_False, Data->ChangeVertexLastOnS2(), tolapp3d);
   }
   done = CompleteData(Data,Func,lin,S1,S2,Or,0,0,0,0);
   if(!done)  throw Standard_Failure("PerformSurf : Failed approximation!");
@@ -554,7 +554,7 @@ Standard_Real FilletSurf_InternalBuilder::FirstParameter() const
   Standard_Integer ind = 1;
   if(sp->IsPeriodic()) ind = sp->Index(p);
   Standard_Real ep;
-  if(ComputeEdgeParameter(sp,ind,p,ep,tolesp)) return ep;
+  if(ComputeEdgeParameter(sp,ind,p,ep,tolapp3d)) return ep;
   return 0.0;
 }
 //=======================================================================
@@ -570,7 +570,7 @@ Standard_Real FilletSurf_InternalBuilder::LastParameter() const
   Standard_Integer ind = sp->NbEdges();
   if(sp->IsPeriodic()) ind = sp->Index(p);
   Standard_Real ep;
-  if(ComputeEdgeParameter(sp,ind,p,ep,tolesp)) return ep;
+  if(ComputeEdgeParameter(sp,ind,p,ep,tolapp3d)) return ep;
   return 0.0;
 }
 

src/GeomConvert/GeomConvert_CurveToAnaCurve.cxx

@@ -429,6 +429,8 @@ static Standard_Boolean ConicDefinition
     term2 = -gdet/(cprim*pdet);
       
     if (IsEllip) {
+      if (term1 <= eps || term2 <= eps)
+        return Standard_False;
       Xax = cost;
       Yax = sint;
       Rmin = sqrt ( term1);
@@ -439,12 +441,16 @@ static Standard_Boolean ConicDefinition
       }
     }
     else if (term1 <= eps){
+      if (-term1 <= eps || term2 <= eps)
+        return Standard_False;
       Xax  = -sint;
       Yax  =  cost;
       Rmin = sqrt (-term1);
       Rmax = sqrt (term2);
     } 
     else {
+      if (term1 <= eps || -term2 <= eps)
+        return Standard_False;
       Xax  =  cost;
       Yax  =  sint;
       Rmin = sqrt (-term2);

src/GeomInt/GeomInt_IntSS.hxx

@@ -93,6 +93,15 @@ public:
   //! converts RLine to Geom(2d)_Curve.
   Standard_EXPORT static void TreatRLine (const Handle(IntPatch_RLine)& theRL, const Handle(GeomAdaptor_Surface)& theHS1, const Handle(GeomAdaptor_Surface)& theHS2, Handle(Geom_Curve)& theC3d, Handle(Geom2d_Curve)& theC2d1, Handle(Geom2d_Curve)& theC2d2, Standard_Real& theTolReached);
   
+  //! creates 2D-curve on given surface from given 3D-curve
+  Standard_EXPORT static void BuildPCurves (const Standard_Real theFirst, const Standard_Real theLast,
+                                            const Standard_Real theUmin, const Standard_Real theUmax,
+                                            const Standard_Real theVmin, const Standard_Real theVmax,
+                                            Standard_Real& theTol,
+                                            const Handle(Geom_Surface)& theSurface,
+                                            const Handle(Geom_Curve)& theCurve,
+                                            Handle(Geom2d_Curve)& theCurve2d);
+
   //! creates 2D-curve on given surface from given 3D-curve
   Standard_EXPORT static void BuildPCurves (const Standard_Real f, const Standard_Real l, Standard_Real& Tol, const Handle(Geom_Surface)& S, const Handle(Geom_Curve)& C, Handle(Geom2d_Curve)& C2d);
   

src/GeomInt/GeomInt_IntSS_1.cxx

@@ -1074,94 +1074,92 @@ void GeomInt_IntSS::TreatRLine(const Handle(IntPatch_RLine)& theRL,
 //function : BuildPCurves
 //purpose  : 
 //=======================================================================
-void GeomInt_IntSS::BuildPCurves (Standard_Real f,
-                                  Standard_Real l,
-                                  Standard_Real& Tol,
-                                  const Handle (Geom_Surface)& S,
-                                  const Handle (Geom_Curve)&   C,
-                                  Handle (Geom2d_Curve)& C2d)
+void GeomInt_IntSS::BuildPCurves (const Standard_Real theFirst, const Standard_Real theLast,
+                                  const Standard_Real theUmin, const Standard_Real theUmax,
+                                  const Standard_Real theVmin, const Standard_Real theVmax,
+                                  Standard_Real& theTol,
+                                  const Handle(Geom_Surface)& theSurface,
+                                  const Handle(Geom_Curve)& theCurve,
+                                  Handle(Geom2d_Curve)& theCurve2d)
 {
-  if (!C2d.IsNull()) {
+  if (!theCurve2d.IsNull() || theSurface.IsNull()) {
     return;
   }
   //
-  Standard_Real umin,umax,vmin,vmax;
-  // 
-  S->Bounds(umin, umax, vmin, vmax);
   // in class ProjLib_Function the range of parameters is shrank by 1.e-09
-  if((l - f) > 2.e-09) {
-    C2d = GeomProjLib::Curve2d(C,f,l,S,umin,umax,vmin,vmax,Tol);
-    if (C2d.IsNull()) {
+  if ((theLast - theFirst) > 2.e-09) {
+    theCurve2d = GeomProjLib::Curve2d(theCurve, theFirst, theLast, theSurface, theUmin, theUmax, theVmin, theVmax, theTol);
+    if (theCurve2d.IsNull()) {
       // proj. a circle that goes through the pole on a sphere to the sphere     
-      Tol += Precision::Confusion();
-      C2d = GeomProjLib::Curve2d(C,f,l,S,Tol);
+      theTol += Precision::Confusion();
+      theCurve2d = GeomProjLib::Curve2d(theCurve, theFirst, theLast, theSurface, theTol);
     }
-    const Handle(Standard_Type)& aType = C2d->DynamicType();
-    if ( aType == STANDARD_TYPE(Geom2d_BSplineCurve)) 
-    { 
+    const Handle(Standard_Type)& aType = theCurve2d->DynamicType();
+    if (aType == STANDARD_TYPE(Geom2d_BSplineCurve))
+    {
       //Check first, last knots to avoid problems with trimming
       //First, last knots can differ from f, l because of numerical error 
       //of projection and approximation
       //The same checking as in Geom2d_TrimmedCurve
-      if((C2d->FirstParameter() - f > Precision::PConfusion()) ||
-        (l - C2d->LastParameter() > Precision::PConfusion()))   
+      if ((theCurve2d->FirstParameter() - theFirst > Precision::PConfusion()) ||
+        (theLast - theCurve2d->LastParameter() > Precision::PConfusion()))
       {
-        Handle(Geom2d_BSplineCurve) aBspl = Handle(Geom2d_BSplineCurve)::DownCast(C2d);
+        Handle(Geom2d_BSplineCurve) aBspl = Handle(Geom2d_BSplineCurve)::DownCast(theCurve2d);
         TColStd_Array1OfReal aKnots(1, aBspl->NbKnots());
         aBspl->Knots(aKnots);
-        BSplCLib::Reparametrize(f, l, aKnots);
+        BSplCLib::Reparametrize(theFirst, theLast, aKnots);
         aBspl->SetKnots(aKnots);
       }
     }
   }
   else {
-    if((l - f) > Epsilon(Abs(f)))
+    if ((theLast - theFirst) > Epsilon(Abs(theFirst)))
     {
       //The domain of C2d is [Epsilon(Abs(f)), 2.e-09]
       //On this small range C2d can be considered as segment 
       //of line.
 
-      Standard_Real aU=0., aV=0.;
+      Standard_Real aU = 0., aV = 0.;
       GeomAdaptor_Surface anAS;
-      anAS.Load(S);
+      anAS.Load(theSurface);
       Extrema_ExtPS anExtr;
-      const gp_Pnt aP3d1 = C->Value(f);
-      const gp_Pnt aP3d2 = C->Value(l);
+      const gp_Pnt aP3d1 = theCurve->Value(theFirst);
+      const gp_Pnt aP3d2 = theCurve->Value(theLast);
 
       anExtr.SetAlgo(Extrema_ExtAlgo_Grad);
-      anExtr.Initialize(anAS, umin, umax, vmin, vmax,
-                                Precision::Confusion(), Precision::Confusion());
+      anExtr.Initialize(anAS, theUmin, theUmax, theVmin, theVmax,
+        Precision::Confusion(), Precision::Confusion());
       anExtr.Perform(aP3d1);
 
-      if(ParametersOfNearestPointOnSurface(anExtr, aU, aV))
+      if (ParametersOfNearestPointOnSurface(anExtr, aU, aV))
       {
         const gp_Pnt2d aP2d1(aU, aV);
 
         anExtr.Perform(aP3d2);
 
-        if(ParametersOfNearestPointOnSurface(anExtr, aU, aV))
+        if (ParametersOfNearestPointOnSurface(anExtr, aU, aV))
         {
           const gp_Pnt2d aP2d2(aU, aV);
 
-          if(aP2d1.Distance(aP2d2) > gp::Resolution())
+          if (aP2d1.Distance(aP2d2) > gp::Resolution())
           {
-            TColgp_Array1OfPnt2d poles(1,2);
-            TColStd_Array1OfReal knots(1,2);
-            TColStd_Array1OfInteger mults(1,2);
+            TColgp_Array1OfPnt2d poles(1, 2);
+            TColStd_Array1OfReal knots(1, 2);
+            TColStd_Array1OfInteger mults(1, 2);
             poles(1) = aP2d1;
             poles(2) = aP2d2;
-            knots(1) = f;
-            knots(2) = l;
+            knots(1) = theFirst;
+            knots(2) = theLast;
             mults(1) = mults(2) = 2;
 
-            C2d = new Geom2d_BSplineCurve(poles,knots,mults,1);
+            theCurve2d = new Geom2d_BSplineCurve(poles, knots, mults, 1);
 
             //Check same parameter in middle point .begin
-            const gp_Pnt PMid(C->Value(0.5*(f+l)));
+            const gp_Pnt PMid(theCurve->Value(0.5*(theFirst + theLast)));
             const gp_Pnt2d pmidcurve2d(0.5*(aP2d1.XY() + aP2d2.XY()));
             const gp_Pnt aPC(anAS.Value(pmidcurve2d.X(), pmidcurve2d.Y()));
             const Standard_Real aDist = PMid.Distance(aPC);
-            Tol = Max(aDist, Tol);
+            theTol = Max(aDist, theTol);
             //Check same parameter in middle point .end
           }
         }
@@ -1169,27 +1167,51 @@ void GeomInt_IntSS::BuildPCurves (Standard_Real f,
     }
   }
   //
-  if (S->IsUPeriodic() && !C2d.IsNull()) {
+  if (theSurface->IsUPeriodic() && !theCurve2d.IsNull()) {
     // Recadre dans le domaine UV de la face
     Standard_Real aTm, U0, aEps, period, du, U0x;
     Standard_Boolean bAdjust;
     //
     aEps = Precision::PConfusion();
-    period = S->UPeriod();
+    period = theSurface->UPeriod();
     //
-    aTm = .5*(f + l);
-    gp_Pnt2d pm = C2d->Value(aTm);
+    aTm = .5 * (theFirst + theLast);
+    gp_Pnt2d pm = theCurve2d->Value(aTm);
     U0 = pm.X();
     //
-    bAdjust = 
-      GeomInt::AdjustPeriodic(U0, umin, umax, period, U0x, du, aEps);
+    bAdjust =
+      GeomInt::AdjustPeriodic(U0, theUmin, theUmax, period, U0x, du, aEps);
     if (bAdjust) {
       gp_Vec2d T1(du, 0.);
-      C2d->Translate(T1);
+      theCurve2d->Translate(T1);
     }
   }
 }
 
+
+
+//=======================================================================
+//function : BuildPCurves
+//purpose  : 
+//=======================================================================
+void GeomInt_IntSS::BuildPCurves (const Standard_Real f,
+                                  const Standard_Real l,
+                                  Standard_Real& Tol,
+                                  const Handle (Geom_Surface)& S,
+                                  const Handle (Geom_Curve)&   C,
+                                  Handle (Geom2d_Curve)& C2d)
+{
+  if (!C2d.IsNull() || S.IsNull()) {
+    return;
+  }
+  //
+  Standard_Real umin,umax,vmin,vmax;
+  // 
+  S->Bounds(umin, umax, vmin, vmax);
+  
+  BuildPCurves(f, l, umin, umax, vmin, vmax, Tol, S, C, C2d);
+}
+
 //=======================================================================
 //function : TrimILineOnSurfBoundaries
 //purpose  : This function finds intersection points of given curves with

src/IGESCAFControl/IGESCAFControl_ConfigurationNode.cxx

@@ -34,9 +34,7 @@ namespace
 //=======================================================================
 IGESCAFControl_ConfigurationNode::IGESCAFControl_ConfigurationNode() :
   DE_ConfigurationNode()
-{
-  UpdateLoad();
-}
+{}
 
 //=======================================================================
 // function : IGESCAFControl_ConfigurationNode
@@ -46,7 +44,6 @@ IGESCAFControl_ConfigurationNode::IGESCAFControl_ConfigurationNode(const Handle(
   :DE_ConfigurationNode(theNode)
 {
   InternalParameters = theNode->InternalParameters;
-  UpdateLoad();
 }
 
 //=======================================================================

src/IntAna/IntAna_QuadQuadGeo.cxx

@@ -50,11 +50,21 @@
 #include <Standard_DomainError.hxx>
 #include <Standard_OutOfRange.hxx>
 #include <StdFail_NotDone.hxx>
+#include <gce_MakePln.hxx>
+#include <ProjLib.hxx>
+#include <IntAna2d_AnaIntersection.hxx>
+#include <IntAna2d_IntPoint.hxx>
+
+#ifdef DEBUGLINES
+#include <Geom2d_Line.hxx>
+#endif
 
 static
   gp_Ax2 DirToAx2(const gp_Pnt& P,const gp_Dir& D);
 static
   void RefineDir(gp_Dir& aDir);
+static
+  Standard_Real EstimDist(const gp_Cone& theCon1, const gp_Cone& theCon2);
 
 //=======================================================================
 //class :  AxeOperator
@@ -249,6 +259,72 @@ gp_Ax2 DirToAx2(const gp_Pnt& P,const gp_Dir& D)
     return(gp_Ax2(P,D,gp_Dir(gp_Vec(-y,x,0.0))));
   }
 }
+
+//=======================================================================
+//function : EstimDist
+//purpose  : returns a minimal distance from apex to any solution
+//=======================================================================
+Standard_Real EstimDist(const gp_Cone& theCon1, const gp_Cone& theCon2)
+{
+  //It is supposed that axes of cones are coplanar and 
+  //distance between them > Precision::Confusion()
+  gp_Pnt aPA1 = theCon1.Apex(), aPA2 = theCon2.Apex();
+
+  gp_Pnt aP3 = aPA1.Translated(theCon1.Position().Direction());
+
+  gce_MakePln aMkPln(aPA1, aPA2, aP3);
+  if(!aMkPln.IsDone())
+    return Precision::Infinite();
+
+  const gp_Pln& aPln = aMkPln.Value();
+
+  gp_Lin anAx1(aPA1, theCon1.Position().Direction());
+  gp_Lin2d anAx12d = ProjLib::Project(aPln, anAx1);
+  gp_Lin2d Lines1[2];
+  Standard_Real anAng1 = theCon1.SemiAngle();
+  Lines1[0] = anAx12d.Rotated(anAx12d.Location(), anAng1);
+  Lines1[1] = anAx12d.Rotated(anAx12d.Location(), -anAng1);
+  //
+  gp_Lin anAx2(aPA2, theCon2.Position().Direction());
+  gp_Lin2d anAx22d = ProjLib::Project(aPln, anAx2);
+  gp_Lin2d Lines2[2];
+  Standard_Real anAng2 = theCon2.SemiAngle();
+  Lines2[0] = anAx22d.Rotated(anAx22d.Location(), anAng2);
+  Lines2[1] = anAx22d.Rotated(anAx22d.Location(), -anAng2);
+
+#ifdef DEBUGLINES
+  Handle(Geom2d_Line) L10 = new Geom2d_Line(Lines1[0]);
+  Handle(Geom2d_Line) L11 = new Geom2d_Line(Lines1[1]);
+  Handle(Geom2d_Line) L20 = new Geom2d_Line(Lines2[0]);
+  Handle(Geom2d_Line) L21 = new Geom2d_Line(Lines2[1]);
+#endif
+
+  Standard_Real aMinDist[2] = { Precision::Infinite(), Precision::Infinite() };
+  Standard_Integer i, j, k;
+  IntAna2d_AnaIntersection anInter;
+  for (i = 0; i < 2; ++i)
+  {
+    for (j = 0; j < 2; ++j)
+    {
+      anInter.Perform(Lines1[i], Lines2[j]);
+      if (anInter.IsDone())
+      {
+        Standard_Integer aNbPoints = anInter.NbPoints();
+        for (k = 1; k <= aNbPoints; ++k)
+        {
+          const IntAna2d_IntPoint& anIntP = anInter.Point(k);
+          Standard_Real aPar1 = Abs(anIntP.ParamOnFirst());
+          aMinDist[0] = Min(aPar1, aMinDist[0]);
+          Standard_Real aPar2 = Abs(anIntP.ParamOnSecond());
+          aMinDist[1] = Min(aPar2, aMinDist[1]);
+        }
+      }
+    }
+  }
+
+  Standard_Real aDist = Max(aMinDist[0], aMinDist[1]);
+  return aDist;
+}
 //=======================================================================
 //function : IntAna_QuadQuadGeo
 //purpose  : Empty constructor
@@ -1356,30 +1432,49 @@ IntAna_QuadQuadGeo::IntAna_QuadQuadGeo(const gp_Cylinder& Cyl,
 //=======================================================================
   void IntAna_QuadQuadGeo::Perform(const gp_Cone& Con1,
                                    const gp_Cone& Con2,
-                                   const Standard_Real Tol) 
+                                   const Standard_Real Tol)
 {
-  done=Standard_True;
+  done = Standard_True;
   //
   Standard_Real tg1, tg2, aDA1A2, aTol2;
   gp_Pnt aPApex1, aPApex2;
 
   Standard_Real TOL_APEX_CONF = 1.e-10;
-  
-  //
-  tg1=Tan(Con1.SemiAngle());
-  tg2=Tan(Con2.SemiAngle());
 
-  if((tg1 * tg2) < 0.) {
+  //
+  tg1 = Tan(Con1.SemiAngle());
+  tg2 = Tan(Con2.SemiAngle());
+
+  if ((tg1 * tg2) < 0.) {
     tg2 = -tg2;
   }
   //
-  aTol2=Tol*Tol;
-  aPApex1=Con1.Apex();
-  aPApex2=Con2.Apex();
-  aDA1A2=aPApex1.SquareDistance(aPApex2);
+  aTol2 = Tol*Tol;
+  aPApex1 = Con1.Apex();
+  aPApex2 = Con2.Apex();
+  aDA1A2 = aPApex1.SquareDistance(aPApex2);
   //
-  AxeOperator A1A2(Con1.Axis(),Con2.Axis());
+  AxeOperator A1A2(Con1.Axis(), Con2.Axis());
   //
+  Standard_Real aTolAng = myEPSILON_ANGLE_CONE;
+  if ((Abs(tg1 - tg2) < Tol) && (A1A2.Parallel()))
+  {
+    Standard_Real DistA1A2 = A1A2.Distance();
+    if (DistA1A2 > 100. * Tol)
+    {
+      Standard_Real aMinSolDist = EstimDist(Con1, Con2);
+      if (aMinSolDist < Epsilon(1.))
+      {
+        aTolAng = Tol;
+      }
+      else
+      {
+        aTolAng = Max(myEPSILON_ANGLE_CONE, Tol / aMinSolDist);
+        aTolAng = Min(aTolAng, Tol);
+      }
+    }
+  }
+
   // 1
   if(A1A2.Same()) {
     //-- two circles 
@@ -1427,8 +1522,8 @@ IntAna_QuadQuadGeo::IntAna_QuadQuadGeo(const gp_Cylinder& Cyl,
     }
   } //-- fin A1A2.Same
   // 2
-  else if((Abs(tg1-tg2)<myEPSILON_ANGLE_CONE) && (A1A2.Parallel())) {
-    //-- voir AnVer12mai98
+  else if((Abs(tg1-tg2) < aTolAng ) && (A1A2.Parallel())) {
+
     Standard_Real DistA1A2=A1A2.Distance();
     gp_Dir DA1=Con1.Position().Direction();
     gp_Vec O1O2(Con1.Apex(),Con2.Apex());

src/IntTools/IntTools_FaceFace.cxx

@@ -990,15 +990,19 @@ void IntTools_FaceFace::MakeCurve(const Standard_Integer Index,
         if (typl == IntPatch_Circle || typl == IntPatch_Ellipse) {//// 
           if(myApprox1) { 
             Handle (Geom2d_Curve) C2d;
-            GeomInt_IntSS::BuildPCurves(fprm, lprm, Tolpc, 
-                        myHS1->Surface(), newc, C2d);
+            GeomInt_IntSS::BuildPCurves(fprm, lprm,
+                                        myHS1->FirstUParameter(), myHS1->LastUParameter(),
+                                        myHS1->FirstVParameter(), myHS1->LastVParameter(),
+                                        Tolpc, myHS1->Surface(), newc, C2d);
             aCurve.SetFirstCurve2d(C2d);
           }
 
           if(myApprox2) { 
             Handle (Geom2d_Curve) C2d;
-            GeomInt_IntSS::BuildPCurves(fprm,lprm,Tolpc,
-                    myHS2->Surface(),newc,C2d);
+            GeomInt_IntSS::BuildPCurves(fprm, lprm,
+                                        myHS2->FirstUParameter(), myHS2->LastUParameter(),
+                                        myHS2->FirstVParameter(), myHS2->LastVParameter(),
+                                        Tolpc, myHS2->Surface(), newc, C2d);
             aCurve.SetSecondCurve2d(C2d);
           }
         }
@@ -1059,15 +1063,19 @@ void IntTools_FaceFace::MakeCurve(const Standard_Integer Index,
               
               if(myApprox1) { 
                 Handle (Geom2d_Curve) C2d;
-                GeomInt_IntSS::BuildPCurves(fprm, lprm, Tolpc, 
-                        myHS1->Surface(), newc, C2d);
+                GeomInt_IntSS::BuildPCurves(fprm, lprm,
+                                            myHS1->FirstUParameter(), myHS1->LastUParameter(),
+                                            myHS1->FirstVParameter(), myHS1->LastVParameter(),
+                                            Tolpc, myHS1->Surface(), newc, C2d);
                 aCurve.SetFirstCurve2d(C2d);
               }
 
               if(myApprox2) { 
                 Handle (Geom2d_Curve) C2d;
-                GeomInt_IntSS::BuildPCurves(fprm, lprm, Tolpc,
-                        myHS2->Surface(), newc, C2d);
+                GeomInt_IntSS::BuildPCurves(fprm, lprm,
+                                            myHS2->FirstUParameter(), myHS2->LastUParameter(),
+                                            myHS2->FirstVParameter(), myHS2->LastVParameter(),
+                                            Tolpc, myHS2->Surface(), newc, C2d);
                 aCurve.SetSecondCurve2d(C2d);
               }
             }//  end of if (typl == IntPatch_Circle || typl == IntPatch_Ellipse)

src/QABugs/QABugs_11.cxx

@@ -1864,6 +1864,7 @@ static Standard_Integer OCC1487 (Draw_Interpretor& di, Standard_Integer argc, co
 //=======================================================================
 TopoDS_Shape OCC1077_boolbl(BRepAlgoAPI_BooleanOperation& aBoolenaOperation,const Standard_Real aRadius)
 {
+  Standard_Real tesp = 1.e-4;
   Standard_Real t3d = 1.e-4;
   Standard_Real t2d = 1.e-5;
   Standard_Real ta  = 1.e-2;
@@ -1885,7 +1886,7 @@ TopoDS_Shape OCC1077_boolbl(BRepAlgoAPI_BooleanOperation& aBoolenaOperation,cons
       const TopoDS_Shape& cutsol = ex.Current();
 
       BRepFilletAPI_MakeFillet fill(cutsol);
-      fill.SetParams(ta, t3d, t2d, t3d, t2d, fl);
+      fill.SetParams(ta, tesp, t2d, t3d, t2d, fl);
       fill.SetContinuity(blend_cont, tapp_angle);
       its = aBoolenaOperation.SectionEdges();
       while (its.More())

src/QABugs/QABugs_17.cxx

@@ -577,6 +577,7 @@ static Standard_Integer OCC570 (Draw_Interpretor& di, Standard_Integer argc,cons
 
 #include <Law_Interpol.hxx>
 
+static Standard_Real tesp = 1.e-4;
 static Standard_Real t3d = 1.e-4;
 static Standard_Real t2d = 1.e-5;
 static Standard_Real ta  = 1.e-2;
@@ -606,7 +607,7 @@ static Standard_Integer MKEVOL(Draw_Interpretor& di,
   if (narg < 3) return 1;
   TopoDS_Shape V = DBRep::Get(a[2]);
   Rake = new BRepFilletAPI_MakeFillet(V);
-  Rake->SetParams(ta,t3d,t2d,t3d,t2d,fl);
+  Rake->SetParams(ta, tesp, t2d, t3d, t2d, fl);
   Rake->SetContinuity(blend_cont, tapp_angle);
   if (narg == 4) {
     ChFi3d_FilletShape FSh = ChFi3d_Rational;

src/RWGltf/RWGltf_ConfigurationNode.cxx

@@ -33,9 +33,7 @@ namespace
 //=======================================================================
 RWGltf_ConfigurationNode::RWGltf_ConfigurationNode() :
   DE_ConfigurationNode()
-{
-  UpdateLoad();
-}
+{}
 
 //=======================================================================
 // function : RWGltf_ConfigurationNode
@@ -45,7 +43,6 @@ RWGltf_ConfigurationNode::RWGltf_ConfigurationNode(const Handle(RWGltf_Configura
   :DE_ConfigurationNode(theNode)
 {
   InternalParameters = theNode->InternalParameters;
-  UpdateLoad();
 }
 
 //=======================================================================

src/RWObj/RWObj_ConfigurationNode.cxx

@@ -33,9 +33,7 @@ namespace
 //=======================================================================
 RWObj_ConfigurationNode::RWObj_ConfigurationNode() :
   DE_ConfigurationNode()
-{
-  UpdateLoad();
-}
+{}
 
 //=======================================================================
 // function : RWObj_ConfigurationNode
@@ -45,7 +43,6 @@ RWObj_ConfigurationNode::RWObj_ConfigurationNode(const Handle(RWObj_Configuratio
   :DE_ConfigurationNode(theNode)
 {
   InternalParameters = theNode->InternalParameters;
-  UpdateLoad();
 }
 
 //=======================================================================

src/RWPly/RWPly_ConfigurationNode.cxx

@@ -27,9 +27,7 @@ static const TCollection_AsciiString THE_CONFIGURATION_SCOPE = "provider";
 //=======================================================================
 RWPly_ConfigurationNode::RWPly_ConfigurationNode() :
   DE_ConfigurationNode()
-{
-  UpdateLoad();
-}
+{}
 
 //=======================================================================
 // function : RWPly_ConfigurationNode
@@ -39,7 +37,6 @@ RWPly_ConfigurationNode::RWPly_ConfigurationNode(const Handle(RWPly_Configuratio
   :DE_ConfigurationNode(theNode)
 {
   InternalParameters = theNode->InternalParameters;
-  UpdateLoad();
 }
 
 //=======================================================================

src/RWStepBasic/RWStepBasic_RWConversionBasedUnit.cxx

@@ -16,74 +16,73 @@
 #include <RWStepBasic_RWConversionBasedUnit.hxx>
 #include <StepBasic_ConversionBasedUnit.hxx>
 #include <StepBasic_DimensionalExponents.hxx>
-#include <StepBasic_MeasureWithUnit.hxx>
 #include <StepData_StepReaderData.hxx>
 #include <StepData_StepWriter.hxx>
+#include <StepRepr_MeasureWithUnit.hxx>
 
 RWStepBasic_RWConversionBasedUnit::RWStepBasic_RWConversionBasedUnit () {}
 
-void RWStepBasic_RWConversionBasedUnit::ReadStep
-	(const Handle(StepData_StepReaderData)& data,
-	 const Standard_Integer num,
-	 Handle(Interface_Check)& ach,
-	 const Handle(StepBasic_ConversionBasedUnit)& ent) const
+void RWStepBasic_RWConversionBasedUnit::ReadStep(const Handle(StepData_StepReaderData)& data,
+                                                 const Standard_Integer num,
+                                                 Handle(Interface_Check)& ach,
+                                                 const Handle(StepBasic_ConversionBasedUnit)& ent) const
 {
 
 
-	// --- Number of Parameter Control ---
+  // --- Number of Parameter Control ---
 
-	if (!data->CheckNbParams(num,3,ach,"conversion_based_unit")) return;
+  if (!data->CheckNbParams(num,3,ach,"conversion_based_unit")) return;
 
-	// --- inherited field : dimensions ---
+  // --- inherited field : dimensions ---
 
-	Handle(StepBasic_DimensionalExponents) aDimensions;
-	//szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
-	data->ReadEntity(num, 1,"dimensions", ach, STANDARD_TYPE(StepBasic_DimensionalExponents), aDimensions);
+  Handle(StepBasic_DimensionalExponents) aDimensions;
+  //szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
+  data->ReadEntity(num, 1,"dimensions", ach, STANDARD_TYPE(StepBasic_DimensionalExponents), aDimensions);
 
-	// --- own field : name ---
+  // --- own field : name ---
 
-	Handle(TCollection_HAsciiString) aName;
-	//szv#4:S4163:12Mar99 `Standard_Boolean stat2 =` not needed
-	data->ReadString (num,2,"name",ach,aName);
+  Handle(TCollection_HAsciiString) aName;
+  //szv#4:S4163:12Mar99 `Standard_Boolean stat2 =` not needed
+  data->ReadString (num,2,"name",ach,aName);
 
-	// --- own field : conversionFactor ---
+  // --- own field : conversionFactor ---
 
-	Handle(StepBasic_MeasureWithUnit) aConversionFactor;
-	//szv#4:S4163:12Mar99 `Standard_Boolean stat3 =` not needed
-	data->ReadEntity(num, 3,"conversion_factor", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aConversionFactor);
+  //szv#4:S4163:12Mar99 `Standard_Boolean stat3 =` not needed
+  StepRepr_MeasureWithUnit aConversionFactor;
+  data->ReadEntity(num, 3, "conversion_factor", ach, aConversionFactor);
 
-	//--- Initialisation of the read entity ---
+  //--- Initialisation of the read entity ---
 
 
-	ent->Init(aDimensions, aName, aConversionFactor);
+  ent->Init(aDimensions, aName, aConversionFactor);
 }
 
 
 void RWStepBasic_RWConversionBasedUnit::WriteStep
-	(StepData_StepWriter& SW,
-	 const Handle(StepBasic_ConversionBasedUnit)& ent) const
+    (StepData_StepWriter& SW,
+     const Handle(StepBasic_ConversionBasedUnit)& ent) const
 {
 
-	// --- inherited field dimensions ---
+  // --- inherited field dimensions ---
 
-	SW.Send(ent->Dimensions());
+  SW.Send(ent->Dimensions());
 
-	// --- own field : name ---
+  // --- own field : name ---
 
-	SW.Send(ent->Name());
+  SW.Send(ent->Name());
 
-	// --- own field : conversionFactor ---
+  // --- own field : conversionFactor ---
 
-	SW.Send(ent->ConversionFactor());
+  SW.Send(ent->ConversionFactor().Value());
 }
 
 
 void RWStepBasic_RWConversionBasedUnit::Share(const Handle(StepBasic_ConversionBasedUnit)& ent, Interface_EntityIterator& iter) const
 {
 
-	iter.GetOneItem(ent->Dimensions());
+  iter.GetOneItem(ent->Dimensions());
 
 
-	iter.GetOneItem(ent->ConversionFactor());
+  iter.GetOneItem(ent->ConversionFactor().Value());
 }
 

src/RWStepBasic/RWStepBasic_RWConversionBasedUnitAndAreaUnit.cxx

@@ -19,18 +19,18 @@
 #include <RWStepBasic_RWConversionBasedUnitAndAreaUnit.hxx>
 #include <StepBasic_ConversionBasedUnitAndAreaUnit.hxx>
 #include <StepBasic_DimensionalExponents.hxx>
-#include <StepBasic_MeasureWithUnit.hxx>
 #include <StepData_StepReaderData.hxx>
 #include <StepData_StepWriter.hxx>
+#include <StepRepr_MeasureWithUnit.hxx>
 
 RWStepBasic_RWConversionBasedUnitAndAreaUnit::RWStepBasic_RWConversionBasedUnitAndAreaUnit ()
 {
 }
 
 void RWStepBasic_RWConversionBasedUnitAndAreaUnit::ReadStep(const Handle(StepData_StepReaderData)& data,
-							    const Standard_Integer num0,
-							    Handle(Interface_Check)& ach,
-							    const Handle(StepBasic_ConversionBasedUnitAndAreaUnit)& ent) const
+                                                   const Standard_Integer num0,
+                                                   Handle(Interface_Check)& ach,
+                                                   const Handle(StepBasic_ConversionBasedUnitAndAreaUnit)& ent) const
 {
   Standard_Integer num = num0;
   //data->NamedForComplex("AREA_UNIT",num0,num,ach);
@@ -43,15 +43,15 @@ void RWStepBasic_RWConversionBasedUnitAndAreaUnit::ReadStep(const Handle(StepDat
   data->ReadString (num,1,"name",ach,aName);
   
   // --- field : conversionFactor ---
-  Handle(StepBasic_MeasureWithUnit) aConversionFactor;
-  data->ReadEntity(num, 2,"conversion_factor", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aConversionFactor);
+  StepRepr_MeasureWithUnit aConversionFactor;
+  data->ReadEntity(num, 2, "conversion_factor", ach, aConversionFactor);
   num = data->NextForComplex(num);
   
   if (!data->CheckNbParams(num,1,ach,"named_unit")) return;
   Handle(StepBasic_DimensionalExponents) aDimensions;
   data->ReadEntity(num, 1,"dimensions", ach, STANDARD_TYPE(StepBasic_DimensionalExponents), aDimensions);
   
-  ent->Init(aDimensions,aName,aConversionFactor);
+  ent->Init(aDimensions,aName, aConversionFactor);
 }
 
 void RWStepBasic_RWConversionBasedUnitAndAreaUnit::WriteStep(StepData_StepWriter& SW,
@@ -60,7 +60,7 @@ void RWStepBasic_RWConversionBasedUnitAndAreaUnit::WriteStep(StepData_StepWriter
   SW.StartEntity("AREA_UNIT");
   SW.StartEntity("CONVERSION_BASED_UNIT");
   SW.Send(ent->Name());
-  SW.Send(ent->ConversionFactor());
+  SW.Send(ent->ConversionFactor().Value());
   SW.StartEntity("NAMED_UNIT");
   SW.Send(ent->Dimensions());
 }
@@ -69,7 +69,7 @@ void RWStepBasic_RWConversionBasedUnitAndAreaUnit::Share(const Handle(StepBasic_
 							 Interface_EntityIterator& iter) const
 {
   iter.GetOneItem(ent->Dimensions());
-  iter.GetOneItem(ent->ConversionFactor());
+  iter.GetOneItem(ent->ConversionFactor().Value());
 }
 
 

src/RWStepBasic/RWStepBasic_RWConversionBasedUnitAndLengthUnit.cxx

@@ -17,96 +17,96 @@
 #include <StepBasic_ConversionBasedUnitAndLengthUnit.hxx>
 #include <StepBasic_DimensionalExponents.hxx>
 #include <StepBasic_LengthUnit.hxx>
-#include <StepBasic_MeasureWithUnit.hxx>
 #include <StepData_StepReaderData.hxx>
 #include <StepData_StepWriter.hxx>
+#include <StepRepr_MeasureWithUnit.hxx>
 
 RWStepBasic_RWConversionBasedUnitAndLengthUnit::RWStepBasic_RWConversionBasedUnitAndLengthUnit () {}
 
 void RWStepBasic_RWConversionBasedUnitAndLengthUnit::ReadStep
-	(const Handle(StepData_StepReaderData)& data,
-	 const Standard_Integer num0,
-	 Handle(Interface_Check)& ach,
-	 const Handle(StepBasic_ConversionBasedUnitAndLengthUnit)& ent) const
+    (const Handle(StepData_StepReaderData)& data,
+     const Standard_Integer num0,
+     Handle(Interface_Check)& ach,
+     const Handle(StepBasic_ConversionBasedUnitAndLengthUnit)& ent) const
 {
 
-	Standard_Integer num = num0;
+  Standard_Integer num = num0;
 
 
-	// --- Instance of plex component ConversionBasedUnit ---
+  // --- Instance of plex component ConversionBasedUnit ---
 
-	if (!data->CheckNbParams(num,2,ach,"conversion_based_unit")) return;
+  if (!data->CheckNbParams(num,2,ach,"conversion_based_unit")) return;
 
-	// --- field : name ---
+  // --- field : name ---
 
-	Handle(TCollection_HAsciiString) aName;
-	//szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
-	data->ReadString (num,1,"name",ach,aName);
+  Handle(TCollection_HAsciiString) aName;
+  //szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
+  data->ReadString (num,1,"name",ach,aName);
 
-	// --- field : conversionFactor ---
+  // --- field : conversionFactor ---
 
-	Handle(StepBasic_MeasureWithUnit) aConversionFactor;
-	//szv#4:S4163:12Mar99 `Standard_Boolean stat2 =` not needed
-	data->ReadEntity(num, 2,"conversion_factor", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aConversionFactor);
+  //szv#4:S4163:12Mar99 `Standard_Boolean stat2 =` not needed
+  StepRepr_MeasureWithUnit aConversionFactor;
+  data->ReadEntity(num, 2, "conversion_factor", ach, aConversionFactor);
 
-	num = data->NextForComplex(num);
+  num = data->NextForComplex(num);
 
-	// --- Instance of plex component LengthUnit ---
+  // --- Instance of plex component LengthUnit ---
 
-	if (!data->CheckNbParams(num,0,ach,"length_unit")) return;
+  if (!data->CheckNbParams(num,0,ach,"length_unit")) return;
 
-	num = data->NextForComplex(num);
+  num = data->NextForComplex(num);
 
-	// --- Instance of common supertype NamedUnit ---
+  // --- Instance of common supertype NamedUnit ---
 
-	if (!data->CheckNbParams(num,1,ach,"named_unit")) return;
-	// --- field : dimensions ---
+  if (!data->CheckNbParams(num,1,ach,"named_unit")) return;
+  // --- field : dimensions ---
 
 
-	Handle(StepBasic_DimensionalExponents) aDimensions;
-	//szv#4:S4163:12Mar99 `Standard_Boolean stat3 =` not needed
-	data->ReadEntity(num, 1,"dimensions", ach, STANDARD_TYPE(StepBasic_DimensionalExponents), aDimensions);
+  Handle(StepBasic_DimensionalExponents) aDimensions;
+  //szv#4:S4163:12Mar99 `Standard_Boolean stat3 =` not needed
+  data->ReadEntity(num, 1,"dimensions", ach, STANDARD_TYPE(StepBasic_DimensionalExponents), aDimensions);
 
-	//--- Initialisation of the red entity ---
+  //--- Initialisation of the red entity ---
 
-	ent->Init(aDimensions,aName,aConversionFactor);
+  ent->Init(aDimensions,aName,aConversionFactor);
 }
 
 
 void RWStepBasic_RWConversionBasedUnitAndLengthUnit::WriteStep
-	(StepData_StepWriter& SW,
-	 const Handle(StepBasic_ConversionBasedUnitAndLengthUnit)& ent) const
+    (StepData_StepWriter& SW,
+     const Handle(StepBasic_ConversionBasedUnitAndLengthUnit)& ent) const
 {
 
-	// --- Instance of plex component ConversionBasedUnit ---
+  // --- Instance of plex component ConversionBasedUnit ---
 
-	SW.StartEntity("CONVERSION_BASED_UNIT");
-	// --- field : name ---
+  SW.StartEntity("CONVERSION_BASED_UNIT");
+  // --- field : name ---
 
-	SW.Send(ent->Name());
-	// --- field : conversionFactor ---
+  SW.Send(ent->Name());
+  // --- field : conversionFactor ---
 
-	SW.Send(ent->ConversionFactor());
+  SW.Send(ent->ConversionFactor().Value());
 
-	// --- Instance of plex component LengthUnit ---
+  // --- Instance of plex component LengthUnit ---
 
-	SW.StartEntity("LENGTH_UNIT");
+  SW.StartEntity("LENGTH_UNIT");
 
-	// --- Instance of common supertype NamedUnit ---
+  // --- Instance of common supertype NamedUnit ---
 
-	SW.StartEntity("NAMED_UNIT");
-	// --- field : dimensions ---
+  SW.StartEntity("NAMED_UNIT");
+  // --- field : dimensions ---
 
-	SW.Send(ent->Dimensions());
+  SW.Send(ent->Dimensions());
 }
 
 
 void RWStepBasic_RWConversionBasedUnitAndLengthUnit::Share(const Handle(StepBasic_ConversionBasedUnitAndLengthUnit)& ent, Interface_EntityIterator& iter) const
 {
 
-	iter.GetOneItem(ent->Dimensions());
+  iter.GetOneItem(ent->Dimensions());
 
 
-	iter.GetOneItem(ent->ConversionFactor());
+  iter.GetOneItem(ent->ConversionFactor().Value());
 }
 

src/RWStepBasic/RWStepBasic_RWConversionBasedUnitAndMassUnit.cxx

@@ -17,9 +17,9 @@
 #include <StepBasic_ConversionBasedUnitAndMassUnit.hxx>
 #include <StepBasic_DimensionalExponents.hxx>
 #include <StepBasic_MassUnit.hxx>
-#include <StepBasic_MeasureWithUnit.hxx>
 #include <StepData_StepReaderData.hxx>
 #include <StepData_StepWriter.hxx>
+#include <StepRepr_MeasureWithUnit.hxx>
 
 //=======================================================================
 //function : RWStepBasic_RWConversionBasedUnitAndMassUnit
@@ -36,10 +36,10 @@ RWStepBasic_RWConversionBasedUnitAndMassUnit::RWStepBasic_RWConversionBasedUnitA
 //=======================================================================
 
 void RWStepBasic_RWConversionBasedUnitAndMassUnit::ReadStep
-	(const Handle(StepData_StepReaderData)& data,
-	 const Standard_Integer num0,
-	 Handle(Interface_Check)& ach,
-	 const Handle(StepBasic_ConversionBasedUnitAndMassUnit)& ent) const
+    (const Handle(StepData_StepReaderData)& data,
+     const Standard_Integer num0,
+     Handle(Interface_Check)& ach,
+     const Handle(StepBasic_ConversionBasedUnitAndMassUnit)& ent) const
 {
 
   Standard_Integer num = num0;
@@ -51,9 +51,9 @@ void RWStepBasic_RWConversionBasedUnitAndMassUnit::ReadStep
   //szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
   data->ReadString (num,1,"name",ach,aName);
   // --- field : conversionFactor ---
-  Handle(StepBasic_MeasureWithUnit) aConversionFactor;
   //szv#4:S4163:12Mar99 `Standard_Boolean stat2 =` not needed
-  data->ReadEntity(num, 2,"conversion_factor", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aConversionFactor);
+  StepRepr_MeasureWithUnit aConversionFactor;
+  data->ReadEntity(num, 2, "conversion_factor", ach, aConversionFactor);
 
   num = data->NextForComplex(num);
 
@@ -70,7 +70,7 @@ void RWStepBasic_RWConversionBasedUnitAndMassUnit::ReadStep
   data->ReadEntity(num, 1,"dimensions", ach, STANDARD_TYPE(StepBasic_DimensionalExponents), aDimensions);
 
   //--- Initialisation of the red entity ---
-  ent->Init(aDimensions,aName,aConversionFactor);
+  ent->Init(aDimensions,aName, aConversionFactor);
 }
 
 
@@ -88,7 +88,7 @@ void RWStepBasic_RWConversionBasedUnitAndMassUnit::WriteStep
   // --- field : name ---
   SW.Send(ent->Name());
   // --- field : conversionFactor ---
-  SW.Send(ent->ConversionFactor());
+  SW.Send(ent->ConversionFactor().Value());
   // --- Instance of plex component MassUnit ---
   SW.StartEntity("Mass_UNIT");
   // --- Instance of common supertype NamedUnit ---
@@ -108,6 +108,6 @@ void RWStepBasic_RWConversionBasedUnitAndMassUnit::Share
    Interface_EntityIterator& iter) const
 {
   iter.GetOneItem(ent->Dimensions());
-  iter.GetOneItem(ent->ConversionFactor());
+  iter.GetOneItem(ent->ConversionFactor().Value());
 }
 

src/RWStepBasic/RWStepBasic_RWConversionBasedUnitAndPlaneAngleUnit.cxx

@@ -17,79 +17,80 @@
 #include <RWStepBasic_RWConversionBasedUnitAndPlaneAngleUnit.hxx>
 #include <StepBasic_ConversionBasedUnitAndPlaneAngleUnit.hxx>
 #include <StepBasic_DimensionalExponents.hxx>
-#include <StepBasic_MeasureWithUnit.hxx>
 #include <StepBasic_PlaneAngleUnit.hxx>
 #include <StepData_StepReaderData.hxx>
 #include <StepData_StepWriter.hxx>
+#include <StepRepr_MeasureWithUnit.hxx>
 
 RWStepBasic_RWConversionBasedUnitAndPlaneAngleUnit::RWStepBasic_RWConversionBasedUnitAndPlaneAngleUnit () {}
 
 void RWStepBasic_RWConversionBasedUnitAndPlaneAngleUnit::ReadStep
-	(const Handle(StepData_StepReaderData)& data,
-	 const Standard_Integer num0,
-	 Handle(Interface_Check)& ach,
-	 const Handle(StepBasic_ConversionBasedUnitAndPlaneAngleUnit)& ent) const
+   (const Handle(StepData_StepReaderData)& data,
+     const Standard_Integer num0,
+     Handle(Interface_Check)& ach,
+     const Handle(StepBasic_ConversionBasedUnitAndPlaneAngleUnit)& ent) const
 {
         // sln 09.10.2001. BUC61003. Correction of looking for items of complex entity in case of them  do not saticfy to alphabetical order
         // CONVERSION_BASED_UNIT
-	Standard_Integer num = 0;//num0;
-	data->NamedForComplex("CONVERSION_BASED_UNIT", "CNBSUN",num0,num,ach);
-	if (!data->CheckNbParams(num,2,ach,"conversion_based_unit")) return;
-       	Handle(TCollection_HAsciiString) aName;
-	data->ReadString (num,1,"name",ach,aName);
-        Handle(StepBasic_MeasureWithUnit) aConversionFactor;
-	data->ReadEntity(num, 2,"conversion_factor", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aConversionFactor);
-        
-        // NAMED_UNIT
-        //num = 0; //gka TRJ9 c2-id-214.stp
-	data->NamedForComplex("NAMED_UNIT", "NMDUNT",num0,num,ach);
-        if (!data->CheckNbParams(num,1,ach,"named_unit")) return;
-	Handle(StepBasic_DimensionalExponents) aDimensions;
-	data->ReadEntity(num, 1,"dimensions", ach, STANDARD_TYPE(StepBasic_DimensionalExponents), aDimensions);
+  Standard_Integer num = 0;//num0;
+  data->NamedForComplex("CONVERSION_BASED_UNIT", "CNBSUN",num0,num,ach);
+  if (!data->CheckNbParams(num,2,ach,"conversion_based_unit")) return;
+    Handle(TCollection_HAsciiString) aName;
+  data->ReadString (num,1,"name",ach,aName);
 
-        // PLANE_ANGLE_UNIT
-        //num = 0; //gka
-	data->NamedForComplex("PLANE_ANGLE_UNIT", "PLANUN",num0,num,ach);
-        if (!data->CheckNbParams(num,0,ach,"plane_angle_unit")) return;
-        
-	ent->Init(aDimensions,aName,aConversionFactor);
+  StepRepr_MeasureWithUnit aConversionFactor;
+  data->ReadEntity(num, 2, "conversion_factor", ach, aConversionFactor);
+
+  // NAMED_UNIT
+  //num = 0; //gka TRJ9 c2-id-214.stp
+  data->NamedForComplex("NAMED_UNIT", "NMDUNT",num0,num,ach);
+  if (!data->CheckNbParams(num,1,ach,"named_unit")) return;
+  Handle(StepBasic_DimensionalExponents) aDimensions;
+  data->ReadEntity(num, 1,"dimensions", ach, STANDARD_TYPE(StepBasic_DimensionalExponents), aDimensions);
+
+  // PLANE_ANGLE_UNIT
+  //num = 0; //gka
+  data->NamedForComplex("PLANE_ANGLE_UNIT", "PLANUN",num0,num,ach);
+  if (!data->CheckNbParams(num,0,ach,"plane_angle_unit")) return;
+
+  ent->Init(aDimensions,aName,aConversionFactor);
 }
 
 
 void RWStepBasic_RWConversionBasedUnitAndPlaneAngleUnit::WriteStep
-	(StepData_StepWriter& SW,
-	 const Handle(StepBasic_ConversionBasedUnitAndPlaneAngleUnit)& ent) const
+    (StepData_StepWriter& SW,
+     const Handle(StepBasic_ConversionBasedUnitAndPlaneAngleUnit)& ent) const
 {
 
-	// --- Instance of plex component ConversionBasedUnit ---
+  // --- Instance of plex component ConversionBasedUnit ---
 
-	SW.StartEntity("CONVERSION_BASED_UNIT");
-	// --- field : name ---
+  SW.StartEntity("CONVERSION_BASED_UNIT");
+  // --- field : name ---
 
-	SW.Send(ent->Name());
-	// --- field : conversionFactor ---
+  SW.Send(ent->Name());
+  // --- field : conversionFactor ---
 
-	SW.Send(ent->ConversionFactor());
+  SW.Send(ent->ConversionFactor().Value());
 
-	// --- Instance of common supertype NamedUnit ---
+  // --- Instance of common supertype NamedUnit ---
 
-	SW.StartEntity("NAMED_UNIT");
-	// --- field : dimensions ---
+  SW.StartEntity("NAMED_UNIT");
+  // --- field : dimensions ---
 
-	SW.Send(ent->Dimensions());
+  SW.Send(ent->Dimensions());
 
-	// --- Instance of plex component PlaneAngleUnit ---
+  // --- Instance of plex component PlaneAngleUnit ---
 
-	SW.StartEntity("PLANE_ANGLE_UNIT");
+  SW.StartEntity("PLANE_ANGLE_UNIT");
 }
 
 
 void RWStepBasic_RWConversionBasedUnitAndPlaneAngleUnit::Share(const Handle(StepBasic_ConversionBasedUnitAndPlaneAngleUnit)& ent, Interface_EntityIterator& iter) const
 {
 
-	iter.GetOneItem(ent->Dimensions());
+  iter.GetOneItem(ent->Dimensions());
 
 
-	iter.GetOneItem(ent->ConversionFactor());
+  iter.GetOneItem(ent->ConversionFactor().Value());
 }
 

src/RWStepBasic/RWStepBasic_RWConversionBasedUnitAndRatioUnit.cxx

@@ -16,97 +16,97 @@
 #include <RWStepBasic_RWConversionBasedUnitAndRatioUnit.hxx>
 #include <StepBasic_ConversionBasedUnitAndRatioUnit.hxx>
 #include <StepBasic_DimensionalExponents.hxx>
-#include <StepBasic_MeasureWithUnit.hxx>
 #include <StepBasic_RatioUnit.hxx>
 #include <StepData_StepReaderData.hxx>
 #include <StepData_StepWriter.hxx>
+#include <StepRepr_MeasureWithUnit.hxx>
 
 RWStepBasic_RWConversionBasedUnitAndRatioUnit::RWStepBasic_RWConversionBasedUnitAndRatioUnit () {}
 
 void RWStepBasic_RWConversionBasedUnitAndRatioUnit::ReadStep
-	(const Handle(StepData_StepReaderData)& data,
-	 const Standard_Integer num0,
-	 Handle(Interface_Check)& ach,
-	 const Handle(StepBasic_ConversionBasedUnitAndRatioUnit)& ent) const
+    (const Handle(StepData_StepReaderData)& data,
+     const Standard_Integer num0,
+     Handle(Interface_Check)& ach,
+     const Handle(StepBasic_ConversionBasedUnitAndRatioUnit)& ent) const
 {
 
-	Standard_Integer num = num0;
+  Standard_Integer num = num0;
 
 
-	// --- Instance of plex component ConversionBasedUnit ---
+  // --- Instance of plex component ConversionBasedUnit ---
 
-	if (!data->CheckNbParams(num,2,ach,"conversion_based_unit")) return;
+  if (!data->CheckNbParams(num,2,ach,"conversion_based_unit")) return;
 
-	// --- field : name ---
+  // --- field : name ---
 
-	Handle(TCollection_HAsciiString) aName;
-	//szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
-	data->ReadString (num,1,"name",ach,aName);
+  Handle(TCollection_HAsciiString) aName;
+  //szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
+  data->ReadString (num,1,"name",ach,aName);
 
-	// --- field : conversionFactor ---
+  // --- field : conversionFactor ---
 
-	Handle(StepBasic_MeasureWithUnit) aConversionFactor;
-	//szv#4:S4163:12Mar99 `Standard_Boolean stat2 =` not needed
-	data->ReadEntity(num, 2,"conversion_factor", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aConversionFactor);
+  //szv#4:S4163:12Mar99 `Standard_Boolean stat2 =` not needed
+  StepRepr_MeasureWithUnit aConversionFactor;
+  data->ReadEntity(num, 2, "conversion_factor", ach, aConversionFactor);
 
-	num = data->NextForComplex(num);
+  num = data->NextForComplex(num);
 
-	// --- Instance of common supertype NamedUnit ---
+  // --- Instance of common supertype NamedUnit ---
 
-	if (!data->CheckNbParams(num,1,ach,"named_unit")) return;
+  if (!data->CheckNbParams(num,1,ach,"named_unit")) return;
 
-	// --- field : dimensions ---
+  // --- field : dimensions ---
 
-	Handle(StepBasic_DimensionalExponents) aDimensions;
-	//szv#4:S4163:12Mar99 `Standard_Boolean stat3 =` not needed
-	data->ReadEntity(num, 1,"dimensions", ach, STANDARD_TYPE(StepBasic_DimensionalExponents), aDimensions);
+  Handle(StepBasic_DimensionalExponents) aDimensions;
+  //szv#4:S4163:12Mar99 `Standard_Boolean stat3 =` not needed
+  data->ReadEntity(num, 1,"dimensions", ach, STANDARD_TYPE(StepBasic_DimensionalExponents), aDimensions);
 
-	num = data->NextForComplex(num);
+  num = data->NextForComplex(num);
 
-	// --- Instance of plex component RatioUnit ---
+  // --- Instance of plex component RatioUnit ---
 
-	if (!data->CheckNbParams(num,0,ach,"ratio_unit")) return;
+  if (!data->CheckNbParams(num,0,ach,"ratio_unit")) return;
 
-	//--- Initialisation of the red entity ---
+  //--- Initialisation of the red entity ---
 
-	ent->Init(aDimensions,aName,aConversionFactor);
+  ent->Init(aDimensions,aName, aConversionFactor);
 }
 
 
 void RWStepBasic_RWConversionBasedUnitAndRatioUnit::WriteStep
-	(StepData_StepWriter& SW,
-	 const Handle(StepBasic_ConversionBasedUnitAndRatioUnit)& ent) const
+    (StepData_StepWriter& SW,
+     const Handle(StepBasic_ConversionBasedUnitAndRatioUnit)& ent) const
 {
 
-	// --- Instance of plex component ConversionBasedUnit ---
+  // --- Instance of plex component ConversionBasedUnit ---
 
-	SW.StartEntity("CONVERSION_BASED_UNIT");
-	// --- field : name ---
+  SW.StartEntity("CONVERSION_BASED_UNIT");
+  // --- field : name ---
 
-	SW.Send(ent->Name());
-	// --- field : conversionFactor ---
+  SW.Send(ent->Name());
+  // --- field : conversionFactor ---
 
-	SW.Send(ent->ConversionFactor());
+  SW.Send(ent->ConversionFactor().Value());
 
-	// --- Instance of plex component RatioUnit ---
+  // --- Instance of plex component RatioUnit ---
 
-	SW.StartEntity("RATIO_UNIT");
+  SW.StartEntity("RATIO_UNIT");
 
-	// --- Instance of common supertype NamedUnit ---
+  // --- Instance of common supertype NamedUnit ---
 
-	SW.StartEntity("NAMED_UNIT");
-	// --- field : dimensions ---
+  SW.StartEntity("NAMED_UNIT");
+  // --- field : dimensions ---
 
-	SW.Send(ent->Dimensions());
+  SW.Send(ent->Dimensions());
 }
 
 
 void RWStepBasic_RWConversionBasedUnitAndRatioUnit::Share(const Handle(StepBasic_ConversionBasedUnitAndRatioUnit)& ent, Interface_EntityIterator& iter) const
 {
 
-	iter.GetOneItem(ent->Dimensions());
+  iter.GetOneItem(ent->Dimensions());
 
 
-	iter.GetOneItem(ent->ConversionFactor());
+  iter.GetOneItem(ent->ConversionFactor().Value());
 }
 

src/RWStepBasic/RWStepBasic_RWConversionBasedUnitAndSolidAngleUnit.cxx

@@ -16,97 +16,97 @@
 #include <RWStepBasic_RWConversionBasedUnitAndSolidAngleUnit.hxx>
 #include <StepBasic_ConversionBasedUnitAndSolidAngleUnit.hxx>
 #include <StepBasic_DimensionalExponents.hxx>
-#include <StepBasic_MeasureWithUnit.hxx>
 #include <StepBasic_SolidAngleUnit.hxx>
 #include <StepData_StepReaderData.hxx>
 #include <StepData_StepWriter.hxx>
+#include <StepRepr_MeasureWithUnit.hxx>
 
 RWStepBasic_RWConversionBasedUnitAndSolidAngleUnit::RWStepBasic_RWConversionBasedUnitAndSolidAngleUnit () {}
 
 void RWStepBasic_RWConversionBasedUnitAndSolidAngleUnit::ReadStep
-	(const Handle(StepData_StepReaderData)& data,
-	 const Standard_Integer num0,
-	 Handle(Interface_Check)& ach,
-	 const Handle(StepBasic_ConversionBasedUnitAndSolidAngleUnit)& ent) const
+    (const Handle(StepData_StepReaderData)& data,
+     const Standard_Integer num0,
+     Handle(Interface_Check)& ach,
+     const Handle(StepBasic_ConversionBasedUnitAndSolidAngleUnit)& ent) const
 {
 
-	Standard_Integer num = num0;
+  Standard_Integer num = num0;
 
 
-	// --- Instance of plex component ConversionBasedUnit ---
+  // --- Instance of plex component ConversionBasedUnit ---
 
-	if (!data->CheckNbParams(num,2,ach,"conversion_based_unit")) return;
+  if (!data->CheckNbParams(num,2,ach,"conversion_based_unit")) return;
 
-	// --- field : name ---
+  // --- field : name ---
 
-	Handle(TCollection_HAsciiString) aName;
-	//szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
-	data->ReadString (num,1,"name",ach,aName);
+  Handle(TCollection_HAsciiString) aName;
+  //szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
+  data->ReadString (num,1,"name",ach,aName);
 
-	// --- field : conversionFactor ---
+  // --- field : conversionFactor ---
 
-	Handle(StepBasic_MeasureWithUnit) aConversionFactor;
-	//szv#4:S4163:12Mar99 `Standard_Boolean stat2 =` not needed
-	data->ReadEntity(num, 2,"conversion_factor", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aConversionFactor);
+  //szv#4:S4163:12Mar99 `Standard_Boolean stat2 =` not needed
+  StepRepr_MeasureWithUnit aConversionFactor;
+  data->ReadEntity(num, 2, "conversion_factor", ach, aConversionFactor);
 
-	num = data->NextForComplex(num);
+  num = data->NextForComplex(num);
 
-	// --- Instance of common supertype NamedUnit ---
+  // --- Instance of common supertype NamedUnit ---
 
-	if (!data->CheckNbParams(num,1,ach,"named_unit")) return;
-	// --- field : dimensions ---
+  if (!data->CheckNbParams(num,1,ach,"named_unit")) return;
+  // --- field : dimensions ---
 
 
-	Handle(StepBasic_DimensionalExponents) aDimensions;
-	//szv#4:S4163:12Mar99 `Standard_Boolean stat3 =` not needed
-	data->ReadEntity(num, 1,"dimensions", ach, STANDARD_TYPE(StepBasic_DimensionalExponents), aDimensions);
+  Handle(StepBasic_DimensionalExponents) aDimensions;
+  //szv#4:S4163:12Mar99 `Standard_Boolean stat3 =` not needed
+  data->ReadEntity(num, 1,"dimensions", ach, STANDARD_TYPE(StepBasic_DimensionalExponents), aDimensions);
 
-	num = data->NextForComplex(num);
+  num = data->NextForComplex(num);
 
-	// --- Instance of plex component SolidAngleUnit ---
+  // --- Instance of plex component SolidAngleUnit ---
 
-	if (!data->CheckNbParams(num,0,ach,"solid_angle_unit")) return;
+  if (!data->CheckNbParams(num,0,ach,"solid_angle_unit")) return;
 
-	//--- Initialisation of the red entity ---
+  //--- Initialisation of the red entity ---
 
-	ent->Init(aDimensions,aName,aConversionFactor);
+  ent->Init(aDimensions,aName,aConversionFactor);
 }
 
 
 void RWStepBasic_RWConversionBasedUnitAndSolidAngleUnit::WriteStep
-	(StepData_StepWriter& SW,
-	 const Handle(StepBasic_ConversionBasedUnitAndSolidAngleUnit)& ent) const
+    (StepData_StepWriter& SW,
+     const Handle(StepBasic_ConversionBasedUnitAndSolidAngleUnit)& ent) const
 {
 
-	// --- Instance of plex component ConversionBasedUnit ---
+  // --- Instance of plex component ConversionBasedUnit ---
 
-	SW.StartEntity("CONVERSION_BASED_UNIT");
-	// --- field : name ---
+  SW.StartEntity("CONVERSION_BASED_UNIT");
+  // --- field : name ---
 
-	SW.Send(ent->Name());
-	// --- field : conversionFactor ---
+  SW.Send(ent->Name());
+  // --- field : conversionFactor ---
 
-	SW.Send(ent->ConversionFactor());
+  SW.Send(ent->ConversionFactor().Value());
 
-	// --- Instance of common supertype NamedUnit ---
+  // --- Instance of common supertype NamedUnit ---
 
-	SW.StartEntity("NAMED_UNIT");
-	// --- field : dimensions ---
+  SW.StartEntity("NAMED_UNIT");
+  // --- field : dimensions ---
 
-	SW.Send(ent->Dimensions());
+  SW.Send(ent->Dimensions());
 
-	// --- Instance of plex component SolidAngleUnit ---
+  // --- Instance of plex component SolidAngleUnit ---
 
-	SW.StartEntity("SOLID_ANGLE_UNIT");
+  SW.StartEntity("SOLID_ANGLE_UNIT");
 }
 
 
 void RWStepBasic_RWConversionBasedUnitAndSolidAngleUnit::Share(const Handle(StepBasic_ConversionBasedUnitAndSolidAngleUnit)& ent, Interface_EntityIterator& iter) const
 {
 
-	iter.GetOneItem(ent->Dimensions());
+  iter.GetOneItem(ent->Dimensions());
 
 
-	iter.GetOneItem(ent->ConversionFactor());
+  iter.GetOneItem(ent->ConversionFactor().Value());
 }
 

src/RWStepBasic/RWStepBasic_RWConversionBasedUnitAndTimeUnit.cxx

@@ -16,97 +16,96 @@
 #include <RWStepBasic_RWConversionBasedUnitAndTimeUnit.hxx>
 #include <StepBasic_ConversionBasedUnitAndTimeUnit.hxx>
 #include <StepBasic_DimensionalExponents.hxx>
-#include <StepBasic_MeasureWithUnit.hxx>
 #include <StepBasic_TimeUnit.hxx>
 #include <StepData_StepReaderData.hxx>
 #include <StepData_StepWriter.hxx>
+#include <StepRepr_MeasureWithUnit.hxx>
 
 RWStepBasic_RWConversionBasedUnitAndTimeUnit::RWStepBasic_RWConversionBasedUnitAndTimeUnit () {}
 
 void RWStepBasic_RWConversionBasedUnitAndTimeUnit::ReadStep
-	(const Handle(StepData_StepReaderData)& data,
-	 const Standard_Integer num0,
-	 Handle(Interface_Check)& ach,
-	 const Handle(StepBasic_ConversionBasedUnitAndTimeUnit)& ent) const
+     (const Handle(StepData_StepReaderData)& data,
+     const Standard_Integer num0,
+     Handle(Interface_Check)& ach,
+     const Handle(StepBasic_ConversionBasedUnitAndTimeUnit)& ent) const
 {
 
-	Standard_Integer num = num0;
+  Standard_Integer num = num0;
 
 
-	// --- Instance of plex component ConversionBasedUnit ---
+  // --- Instance of plex component ConversionBasedUnit ---
 
-	if (!data->CheckNbParams(num,2,ach,"conversion_based_unit")) return;
+  if (!data->CheckNbParams(num,2,ach,"conversion_based_unit")) return;
 
-	// --- field : name ---
+  // --- field : name ---
 
-	Handle(TCollection_HAsciiString) aName;
-	//szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
-	data->ReadString (num,1,"name",ach,aName);
+  Handle(TCollection_HAsciiString) aName;
+  //szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
+  data->ReadString (num,1,"name",ach,aName);
 
-	// --- field : conversionFactor ---
+  // --- field : conversionFactor ---
 
-	Handle(StepBasic_MeasureWithUnit) aConversionFactor;
-	//szv#4:S4163:12Mar99 `Standard_Boolean stat2 =` not needed
-	data->ReadEntity(num, 2,"conversion_factor", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aConversionFactor);
+  //szv#4:S4163:12Mar99 `Standard_Boolean stat2 =` not needed
+  StepRepr_MeasureWithUnit aConversionFactor;
+  data->ReadEntity(num, 2, "conversion_factor", ach, aConversionFactor);
 
-	num = data->NextForComplex(num);
+  num = data->NextForComplex(num);
 
-	// --- Instance of common supertype NamedUnit ---
+  // --- Instance of common supertype NamedUnit ---
 
-	if (!data->CheckNbParams(num,1,ach,"named_unit")) return;
-	// --- field : dimensions ---
+  if (!data->CheckNbParams(num,1,ach,"named_unit")) return;
+  // --- field : dimensions ---
 
 
-	Handle(StepBasic_DimensionalExponents) aDimensions;
-	//szv#4:S4163:12Mar99 `Standard_Boolean stat3 =` not needed
-	data->ReadEntity(num, 1,"dimensions", ach, STANDARD_TYPE(StepBasic_DimensionalExponents), aDimensions);
+  Handle(StepBasic_DimensionalExponents) aDimensions;
+  //szv#4:S4163:12Mar99 `Standard_Boolean stat3 =` not needed
+  data->ReadEntity(num, 1,"dimensions", ach, STANDARD_TYPE(StepBasic_DimensionalExponents), aDimensions);
 
-	num = data->NextForComplex(num);
+  num = data->NextForComplex(num);
 
-	// --- Instance of plex component TimeUnit ---
+  // --- Instance of plex component TimeUnit ---
 
-	if (!data->CheckNbParams(num,0,ach,"time_unit")) return;
+  if (!data->CheckNbParams(num,0,ach,"time_unit")) return;
 
-	//--- Initialisation of the red entity ---
+  //--- Initialisation of the red entity ---
 
-	ent->Init(aDimensions,aName,aConversionFactor);
+  ent->Init(aDimensions,aName, aConversionFactor);
 }
 
 
-void RWStepBasic_RWConversionBasedUnitAndTimeUnit::WriteStep
-	(StepData_StepWriter& SW,
-	 const Handle(StepBasic_ConversionBasedUnitAndTimeUnit)& ent) const
+void RWStepBasic_RWConversionBasedUnitAndTimeUnit::WriteStep(StepData_StepWriter& SW,
+                                                   const Handle(StepBasic_ConversionBasedUnitAndTimeUnit)& ent) const
 {
 
-	// --- Instance of plex component ConversionBasedUnit ---
+  // --- Instance of plex component ConversionBasedUnit ---
 
-	SW.StartEntity("CONVERSION_BASED_UNIT");
-	// --- field : name ---
+  SW.StartEntity("CONVERSION_BASED_UNIT");
+  // --- field : name ---
 
-	SW.Send(ent->Name());
-	// --- field : conversionFactor ---
+  SW.Send(ent->Name());
+  // --- field : conversionFactor ---
 
-	SW.Send(ent->ConversionFactor());
+  SW.Send(ent->ConversionFactor().Value());
 
-	// --- Instance of plex component TimeUnit ---
+  // --- Instance of plex component TimeUnit ---
 
-	SW.StartEntity("TIME_UNIT");
+  SW.StartEntity("TIME_UNIT");
 
-	// --- Instance of common supertype NamedUnit ---
+  // --- Instance of common supertype NamedUnit ---
 
-	SW.StartEntity("NAMED_UNIT");
-	// --- field : dimensions ---
+  SW.StartEntity("NAMED_UNIT");
+  // --- field : dimensions ---
 
-	SW.Send(ent->Dimensions());
+  SW.Send(ent->Dimensions());
 }
 
 
 void RWStepBasic_RWConversionBasedUnitAndTimeUnit::Share(const Handle(StepBasic_ConversionBasedUnitAndTimeUnit)& ent, Interface_EntityIterator& iter) const
 {
 
-	iter.GetOneItem(ent->Dimensions());
+  iter.GetOneItem(ent->Dimensions());
 
 
-	iter.GetOneItem(ent->ConversionFactor());
+  iter.GetOneItem(ent->ConversionFactor().Value());
 }
 

src/RWStepBasic/RWStepBasic_RWConversionBasedUnitAndVolumeUnit.cxx

@@ -19,18 +19,18 @@
 #include <RWStepBasic_RWConversionBasedUnitAndVolumeUnit.hxx>
 #include <StepBasic_ConversionBasedUnitAndVolumeUnit.hxx>
 #include <StepBasic_DimensionalExponents.hxx>
-#include <StepBasic_MeasureWithUnit.hxx>
 #include <StepData_StepReaderData.hxx>
 #include <StepData_StepWriter.hxx>
+#include <StepRepr_MeasureWithUnit.hxx>
 
 RWStepBasic_RWConversionBasedUnitAndVolumeUnit::RWStepBasic_RWConversionBasedUnitAndVolumeUnit ()
 {
 }
 
 void RWStepBasic_RWConversionBasedUnitAndVolumeUnit::ReadStep(const Handle(StepData_StepReaderData)& data,
-							      const Standard_Integer num0,
-							      Handle(Interface_Check)& ach,
-							      const Handle(StepBasic_ConversionBasedUnitAndVolumeUnit)& ent) const
+                                                              const Standard_Integer num0,
+                                                              Handle(Interface_Check)& ach,
+                                                              const Handle(StepBasic_ConversionBasedUnitAndVolumeUnit)& ent) const
 {
   Standard_Integer num = num0;
   // --- Instance of plex component ConversionBasedUnit ---
@@ -39,8 +39,8 @@ void RWStepBasic_RWConversionBasedUnitAndVolumeUnit::ReadStep(const Handle(StepD
   data->ReadString (num,1,"name",ach,aName);
   
   // --- field : conversionFactor ---
-  Handle(StepBasic_MeasureWithUnit) aConversionFactor;
-  data->ReadEntity(num, 2,"conversion_factor", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aConversionFactor);
+  StepRepr_MeasureWithUnit aConversionFactor;
+  data->ReadEntity(num, 2, "conversion_factor", ach, aConversionFactor);
   
   num = data->NextForComplex(num);
   if (!data->CheckNbParams(num,1,ach,"named_unit")) return;
@@ -50,23 +50,23 @@ void RWStepBasic_RWConversionBasedUnitAndVolumeUnit::ReadStep(const Handle(StepD
   data->NamedForComplex("VOLUME_UNIT","VLMUNT",num0,num,ach);
   if (!data->CheckNbParams(num,0,ach,"volume_unit")) return;
   
-  ent->Init(aDimensions,aName,aConversionFactor);
+  ent->Init(aDimensions,aName, aConversionFactor);
 }
 
 void RWStepBasic_RWConversionBasedUnitAndVolumeUnit::WriteStep(StepData_StepWriter& SW,
-							     const Handle(StepBasic_ConversionBasedUnitAndVolumeUnit)& ent) const
+                   const Handle(StepBasic_ConversionBasedUnitAndVolumeUnit)& ent) const
 {
   SW.StartEntity("CONVERSION_BASED_UNIT");
   SW.Send(ent->Name());
-  SW.Send(ent->ConversionFactor());
+  SW.Send(ent->ConversionFactor().Value());
   SW.StartEntity("NAMED_UNIT");
   SW.Send(ent->Dimensions());
   SW.StartEntity("VOLUME_UNIT");
 }
   
 void RWStepBasic_RWConversionBasedUnitAndVolumeUnit::Share(const Handle(StepBasic_ConversionBasedUnitAndVolumeUnit)& ent, 
-							   Interface_EntityIterator& iter) const
+                                                           Interface_EntityIterator& iter) const
 {
   iter.GetOneItem(ent->Dimensions());
-  iter.GetOneItem(ent->ConversionFactor());
+  iter.GetOneItem(ent->ConversionFactor().Value());
 }

src/RWStepDimTol/RWStepDimTol_RWAngularityTolerance.cxx

@@ -18,12 +18,12 @@
 #include <Interface_Check.hxx>
 #include <Interface_EntityIterator.hxx>
 #include <RWStepDimTol_RWAngularityTolerance.hxx>
-#include <StepBasic_MeasureWithUnit.hxx>
 #include <StepData_StepReaderData.hxx>
 #include <StepData_StepWriter.hxx>
 #include <StepDimTol_AngularityTolerance.hxx>
 #include <StepDimTol_GeometricToleranceTarget.hxx>
 #include <StepDimTol_HArray1OfDatumSystemOrReference.hxx>
+#include <StepRepr_MeasureWithUnit.hxx>
 
 //=======================================================================
 //function : RWStepDimTol_RWAngularityTolerance
@@ -54,8 +54,8 @@ void RWStepDimTol_RWAngularityTolerance::ReadStep (const Handle(StepData_StepRea
   Handle(TCollection_HAsciiString) aGeometricTolerance_Description;
   data->ReadString (num, 2, "geometric_tolerance.description", ach, aGeometricTolerance_Description);
 
-  Handle(StepBasic_MeasureWithUnit) aGeometricTolerance_Magnitude;
-  data->ReadEntity (num, 3, "geometric_tolerance.magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aGeometricTolerance_Magnitude);
+  StepRepr_MeasureWithUnit aMagnitude;
+  data->ReadEntity(num, 3, "magnitude", ach, aMagnitude);
 
   StepDimTol_GeometricToleranceTarget aGeometricTolerance_TolerancedShapeAspect;
   data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, aGeometricTolerance_TolerancedShapeAspect);
@@ -78,7 +78,7 @@ void RWStepDimTol_RWAngularityTolerance::ReadStep (const Handle(StepData_StepRea
   // Initialize entity
   ent->Init(aGeometricTolerance_Name,
             aGeometricTolerance_Description,
-            aGeometricTolerance_Magnitude,
+            aMagnitude,
             aGeometricTolerance_TolerancedShapeAspect,
             aGeometricToleranceWithDatumReference_DatumSystem);
 }
@@ -98,7 +98,7 @@ void RWStepDimTol_RWAngularityTolerance::WriteStep (StepData_StepWriter& SW,
 
   SW.Send (ent->StepDimTol_GeometricTolerance::Description());
 
-  SW.Send (ent->StepDimTol_GeometricTolerance::Magnitude());
+  SW.Send (ent->StepDimTol_GeometricTolerance::Magnitude().Value());
 
   SW.Send (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
 
@@ -123,7 +123,7 @@ void RWStepDimTol_RWAngularityTolerance::Share (const Handle(StepDimTol_Angulari
 
   // Inherited fields of GeometricTolerance
 
-  iter.AddItem (ent->StepDimTol_GeometricTolerance::Magnitude());
+  iter.AddItem (ent->StepDimTol_GeometricTolerance::Magnitude().Value());
 
   iter.AddItem (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
 

src/RWStepDimTol/RWStepDimTol_RWCircularRunoutTolerance.cxx

@@ -18,12 +18,12 @@
 #include <Interface_Check.hxx>
 #include <Interface_EntityIterator.hxx>
 #include <RWStepDimTol_RWCircularRunoutTolerance.hxx>
-#include <StepBasic_MeasureWithUnit.hxx>
 #include <StepData_StepReaderData.hxx>
 #include <StepData_StepWriter.hxx>
 #include <StepDimTol_CircularRunoutTolerance.hxx>
 #include <StepDimTol_GeometricToleranceTarget.hxx>
 #include <StepDimTol_HArray1OfDatumSystemOrReference.hxx>
+#include <StepRepr_MeasureWithUnit.hxx>
 
 //=======================================================================
 //function : RWStepDimTol_RWCircularRunoutTolerance
@@ -54,8 +54,8 @@ void RWStepDimTol_RWCircularRunoutTolerance::ReadStep (const Handle(StepData_Ste
   Handle(TCollection_HAsciiString) aGeometricTolerance_Description;
   data->ReadString (num, 2, "geometric_tolerance.description", ach, aGeometricTolerance_Description);
 
-  Handle(StepBasic_MeasureWithUnit) aGeometricTolerance_Magnitude;
-  data->ReadEntity (num, 3, "geometric_tolerance.magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aGeometricTolerance_Magnitude);
+  StepRepr_MeasureWithUnit aMagnitude;
+  data->ReadEntity(num, 3, "magnitude", ach, aMagnitude);
 
   StepDimTol_GeometricToleranceTarget aGeometricTolerance_TolerancedShapeAspect;
   data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, aGeometricTolerance_TolerancedShapeAspect);
@@ -78,7 +78,7 @@ void RWStepDimTol_RWCircularRunoutTolerance::ReadStep (const Handle(StepData_Ste
   // Initialize entity
   ent->Init(aGeometricTolerance_Name,
             aGeometricTolerance_Description,
-            aGeometricTolerance_Magnitude,
+            aMagnitude,
             aGeometricTolerance_TolerancedShapeAspect,
             aGeometricToleranceWithDatumReference_DatumSystem);
 }
@@ -98,7 +98,7 @@ void RWStepDimTol_RWCircularRunoutTolerance::WriteStep (StepData_StepWriter& SW,
 
   SW.Send (ent->StepDimTol_GeometricTolerance::Description());
 
-  SW.Send (ent->StepDimTol_GeometricTolerance::Magnitude());
+  SW.Send (ent->StepDimTol_GeometricTolerance::Magnitude().Value());
 
   SW.Send (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
 
@@ -123,7 +123,7 @@ void RWStepDimTol_RWCircularRunoutTolerance::Share (const Handle(StepDimTol_Circ
 
   // Inherited fields of GeometricTolerance
 
-  iter.AddItem (ent->StepDimTol_GeometricTolerance::Magnitude());
+  iter.AddItem (ent->StepDimTol_GeometricTolerance::Magnitude().Value());
 
   iter.AddItem (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
 

src/RWStepDimTol/RWStepDimTol_RWCoaxialityTolerance.cxx

@@ -18,12 +18,12 @@
 #include <Interface_Check.hxx>
 #include <Interface_EntityIterator.hxx>
 #include <RWStepDimTol_RWCoaxialityTolerance.hxx>
-#include <StepBasic_MeasureWithUnit.hxx>
 #include <StepData_StepReaderData.hxx>
 #include <StepData_StepWriter.hxx>
 #include <StepDimTol_CoaxialityTolerance.hxx>
 #include <StepDimTol_GeometricToleranceTarget.hxx>
 #include <StepDimTol_HArray1OfDatumSystemOrReference.hxx>
+#include <StepRepr_MeasureWithUnit.hxx>
 
 //=======================================================================
 //function : RWStepDimTol_RWCoaxialityTolerance
@@ -54,8 +54,8 @@ void RWStepDimTol_RWCoaxialityTolerance::ReadStep (const Handle(StepData_StepRea
   Handle(TCollection_HAsciiString) aGeometricTolerance_Description;
   data->ReadString (num, 2, "geometric_tolerance.description", ach, aGeometricTolerance_Description);
 
-  Handle(StepBasic_MeasureWithUnit) aGeometricTolerance_Magnitude;
-  data->ReadEntity (num, 3, "geometric_tolerance.magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aGeometricTolerance_Magnitude);
+  StepRepr_MeasureWithUnit aMagnitude;
+  data->ReadEntity(num, 3, "magnitude", ach, aMagnitude);
 
   StepDimTol_GeometricToleranceTarget aGeometricTolerance_TolerancedShapeAspect;
   data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, aGeometricTolerance_TolerancedShapeAspect);
@@ -78,7 +78,7 @@ void RWStepDimTol_RWCoaxialityTolerance::ReadStep (const Handle(StepData_StepRea
   // Initialize entity
   ent->Init(aGeometricTolerance_Name,
             aGeometricTolerance_Description,
-            aGeometricTolerance_Magnitude,
+            aMagnitude,
             aGeometricTolerance_TolerancedShapeAspect,
             aGeometricToleranceWithDatumReference_DatumSystem);
 }
@@ -98,7 +98,7 @@ void RWStepDimTol_RWCoaxialityTolerance::WriteStep (StepData_StepWriter& SW,
 
   SW.Send (ent->StepDimTol_GeometricTolerance::Description());
 
-  SW.Send (ent->StepDimTol_GeometricTolerance::Magnitude());
+  SW.Send (ent->StepDimTol_GeometricTolerance::Magnitude().Value());
 
   SW.Send (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
 
@@ -123,7 +123,7 @@ void RWStepDimTol_RWCoaxialityTolerance::Share (const Handle(StepDimTol_Coaxiali
 
   // Inherited fields of GeometricTolerance
 
-  iter.AddItem (ent->StepDimTol_GeometricTolerance::Magnitude());
+  iter.AddItem (ent->StepDimTol_GeometricTolerance::Magnitude().Value());
 
   iter.AddItem (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
 

src/RWStepDimTol/RWStepDimTol_RWConcentricityTolerance.cxx

@@ -18,12 +18,12 @@
 #include <Interface_Check.hxx>
 #include <Interface_EntityIterator.hxx>
 #include <RWStepDimTol_RWConcentricityTolerance.hxx>
-#include <StepBasic_MeasureWithUnit.hxx>
 #include <StepData_StepReaderData.hxx>
 #include <StepData_StepWriter.hxx>
 #include <StepDimTol_ConcentricityTolerance.hxx>
 #include <StepDimTol_GeometricToleranceTarget.hxx>
 #include <StepDimTol_HArray1OfDatumSystemOrReference.hxx>
+#include <StepRepr_MeasureWithUnit.hxx>
 
 //=======================================================================
 //function : RWStepDimTol_RWConcentricityTolerance
@@ -54,8 +54,8 @@ void RWStepDimTol_RWConcentricityTolerance::ReadStep (const Handle(StepData_Step
   Handle(TCollection_HAsciiString) aGeometricTolerance_Description;
   data->ReadString (num, 2, "geometric_tolerance.description", ach, aGeometricTolerance_Description);
 
-  Handle(StepBasic_MeasureWithUnit) aGeometricTolerance_Magnitude;
-  data->ReadEntity (num, 3, "geometric_tolerance.magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aGeometricTolerance_Magnitude);
+  StepRepr_MeasureWithUnit aMagnitude;
+  data->ReadEntity(num, 3, "magnitude", ach, aMagnitude);
 
   StepDimTol_GeometricToleranceTarget aGeometricTolerance_TolerancedShapeAspect;
   data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, aGeometricTolerance_TolerancedShapeAspect);
@@ -78,7 +78,7 @@ void RWStepDimTol_RWConcentricityTolerance::ReadStep (const Handle(StepData_Step
   // Initialize entity
   ent->Init(aGeometricTolerance_Name,
             aGeometricTolerance_Description,
-            aGeometricTolerance_Magnitude,
+            aMagnitude,
             aGeometricTolerance_TolerancedShapeAspect,
             aGeometricToleranceWithDatumReference_DatumSystem);
 }
@@ -98,7 +98,7 @@ void RWStepDimTol_RWConcentricityTolerance::WriteStep (StepData_StepWriter& SW,
 
   SW.Send (ent->StepDimTol_GeometricTolerance::Description());
 
-  SW.Send (ent->StepDimTol_GeometricTolerance::Magnitude());
+  SW.Send (ent->StepDimTol_GeometricTolerance::Magnitude().Value());
 
   SW.Send (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
 
@@ -123,7 +123,7 @@ void RWStepDimTol_RWConcentricityTolerance::Share (const Handle(StepDimTol_Conce
 
   // Inherited fields of GeometricTolerance
 
-  iter.AddItem (ent->StepDimTol_GeometricTolerance::Magnitude());
+  iter.AddItem (ent->StepDimTol_GeometricTolerance::Magnitude().Value());
 
   iter.AddItem (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
 

src/RWStepDimTol/RWStepDimTol_RWCylindricityTolerance.cxx

@@ -17,11 +17,11 @@
 
 #include <Interface_EntityIterator.hxx>
 #include <RWStepDimTol_RWCylindricityTolerance.hxx>
-#include <StepBasic_MeasureWithUnit.hxx>
 #include <StepData_StepReaderData.hxx>
 #include <StepData_StepWriter.hxx>
 #include <StepDimTol_CylindricityTolerance.hxx>
 #include <StepDimTol_GeometricToleranceTarget.hxx>
+#include <StepRepr_MeasureWithUnit.hxx>
 
 //=======================================================================
 //function : RWStepDimTol_RWCylindricityTolerance
@@ -52,8 +52,8 @@ void RWStepDimTol_RWCylindricityTolerance::ReadStep (const Handle(StepData_StepR
   Handle(TCollection_HAsciiString) aGeometricTolerance_Description;
   data->ReadString (num, 2, "geometric_tolerance.description", ach, aGeometricTolerance_Description);
 
-  Handle(StepBasic_MeasureWithUnit) aGeometricTolerance_Magnitude;
-  data->ReadEntity (num, 3, "geometric_tolerance.magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aGeometricTolerance_Magnitude);
+  StepRepr_MeasureWithUnit aMagnitude;
+  data->ReadEntity(num, 3, "magnitude", ach, aMagnitude);
 
   StepDimTol_GeometricToleranceTarget aGeometricTolerance_TolerancedShapeAspect;
   data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, aGeometricTolerance_TolerancedShapeAspect);
@@ -61,7 +61,7 @@ void RWStepDimTol_RWCylindricityTolerance::ReadStep (const Handle(StepData_StepR
   // Initialize entity
   ent->Init(aGeometricTolerance_Name,
             aGeometricTolerance_Description,
-            aGeometricTolerance_Magnitude,
+            aMagnitude,
             aGeometricTolerance_TolerancedShapeAspect);
 }
 
@@ -80,7 +80,7 @@ void RWStepDimTol_RWCylindricityTolerance::WriteStep (StepData_StepWriter& SW,
 
   SW.Send (ent->StepDimTol_GeometricTolerance::Description());
 
-  SW.Send (ent->StepDimTol_GeometricTolerance::Magnitude());
+  SW.Send (ent->StepDimTol_GeometricTolerance::Magnitude().Value());
 
   SW.Send (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
 }
@@ -96,7 +96,7 @@ void RWStepDimTol_RWCylindricityTolerance::Share (const Handle(StepDimTol_Cylind
 
   // Inherited fields of GeometricTolerance
 
-  iter.AddItem (ent->StepDimTol_GeometricTolerance::Magnitude());
+  iter.AddItem (ent->StepDimTol_GeometricTolerance::Magnitude().Value());
 
   iter.AddItem (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
 }