Update version to 7.7.1

Fixed problem with texted types
Added checking for null string for subfigure via XCAF transferring

dox/FILES_HTML.txt

@@ -45,6 +45,7 @@ user_guides/visualization/visualization.md
 user_guides/iges/iges.md
 user_guides/step/step.md
 user_guides/xde/xde.md
+user_guides/de_wrapper/de_wrapper.md
 user_guides/ocaf/ocaf.md
 user_guides/draw_test_harness/draw_test_harness.md
 user_guides/inspector/inspector.md

dox/FILES_PDF.txt

@@ -20,6 +20,7 @@ user_guides/vis/vis.md
 user_guides/iges/iges.md
 user_guides/step/step.md
 user_guides/xde/xde.md
+user_guides/de_wrapper/de_wrapper.md
 user_guides/inspector/inspector.md
 user_guides/draw_test_harness/draw_test_harness.md
 

dox/user_guides/de_wrapper/de_wrapper.md

@@ -0,0 +1,413 @@
+Data Exchange Wrapper (DE_Wrapper)  {#occt_user_guides__de_wrapper}
+============================
+
+@tableofcontents
+
+@section occt_de_wrapper_1 Introduction
+
+This guide explains how to use the **Data Exchange Wrapper** (DE Wrapper).
+It provides basic directions on setup, usage and file creation via DE_Wrapper.
+
+The Data Exchange Wrapper (DE Wrapper) module allows reading and writing supported CAD formats to shape objects or special XDE documents, setting up the transfer process for all CAD files.
+
+It is also possible to add support for new CAD formats by prototyping existing tools.
+
+The DE Wrapper component requires @ref occt_user_guides__xde "XDE" toolkit for operation.
+
+This guide mainly explains how to convert CAD files to Open CASCADE Technology (OCCT) shapes and vice versa.
+This guide principally deals with the following OCCT classes:
+  * The Provider class, which loads CAD files and translates their contents to OCCT shapes or XDE documents, or translates OCCT shapes or XDE documents to CAD entities and then writes those entities to a CAD file.
+  * The Configuration class, which contains all information for the transfer process, such as the units, tolerance, and all internal information for the OCC readers or writers.
+  * The wrapper class, which contains all loaded configuration objects with own CAD format, reads or writes CAD files in the format derived from file extension or contents and saves or loads configuration settings for loaded configuration objects.
+
+@section occt_de_wrapper_2 Supported CAD formats
+
+| CAD format | Extensions | RW support | Thread Safety | Presentation | Package |
+| :--------- | :--------- | :--------- | :----------- | :----------- | :------ |
+| STEP | .stp, .step .stepz | RW | No | BRep, Mesh | STEPCAFControl |
+| XCAF | .xbf | RW | Yes | BRep, Mesh | DEXCAFCascade |
+| BREP | .brep | RW | Yes | BRep, Mesh | DEBRepCascade |
+| IGES | .igs, .iges | RW | No | BRep | IGESCAFControl |
+| OBJ | .obj | RW | Yes | Mesh | RWObj |
+| STL | .stl | RW | Yes | Mesh | RWStl |
+| PLY | .ply | W | Yes | Mesh | RWPly |
+| GLTF | .glTF .glb | RW | Yes | Mesh | RWGltf |
+| VRML | .wrl .vrml | RW | Yes | Mesh | Vrml |
+
+**Note** :
+  * The format names in the first column match the FormatName values used for configuration nodes.
+  * The VendorName for all listed CAD formats is "OCC".
+
+@section occt_de_wrapper_3 DE Session Configuration
+
+Any providers can have their own read/write parameters. The transfer process is set up using DE configuration nodes, which hold all relevant parameters. There are two ways to change the parameter values: directly from code or by an external resource file/string.
+The session is a global or static DE_Wrapper object that stores registered DE configuration nodes and wraps DE commands to work with them. It has some configuration parameters of its own and also keeps track of loaded nodes and specilal global parameters.
+
+@subsection occt_de_wrapper_3_1 Getting a DE session. Code sample
+
+Working with a DE session requires a DE_Wrapper object to be loaded or created first.
+
+Getting the global DE_Wrapping object:
+~~~~{.cpp}
+Handle(DE_Wrapper) aSession = DE_Wrapper::GlobalWrapper();
+~~~~
+Creating a local DE_Wrapper:
+~~~~{.cpp}
+Handle(DE_Wrapper) aSession = new DE_Wrapper();
+~~~~
+It is recommended to create a local one-time copy to work with the session, if no global changes are intended.
+~~~~{.cpp}
+Handle(DE_Wrapper) aOneTimeSession = aSession->Copy();
+~~~~
+@subsection occt_de_wrapper_3_2 Configuration resource
+
+Configuration resource is an external file or string of the following format:
+~~~~{.cpp}
+global.priority.STEP :   OCC DTK
+global.general.length.unit :     1
+provider.STEP.OCC.read.precision.val :   0.0001
+~~~~
+
+@subsubsection occt_de_wrapper_3_2_1 Configuration resource: graph of scopes
+   * **global.** is a scope of global parameters
+     *  **priority.** is a scope of priority to use vendors with their providers.
+     *  **general.** is a scope of global configuration parameter values
+     *  <strong>"..."</strong> is an internal configuration with any internal scopes
+     *  <strong>". : "</strong> is a separator of key-value
+     *  __...__ parameter value, can't contain new line symbols.
+   * **provider.** is a scope of configuration providers
+     *  **STEP.** is a scope of CAD format to configure
+     *  **OCC.** is a scope of a vendor or provider
+     *  <strong>"..."</strong> is an internal configuration with any internal scopes
+     *  <strong>". : "</strong> is a separator of key-value
+     *  <strong>"..."</strong> parameter value, can't contain new line symbols.
+
+@subsubsection occt_de_wrapper_3_2_2 Loading configuration resources. Configuring DE Session
+
+The resource should be loaded after the registration of all providers that should be configured. The resource only impacts registered parameters. To configure a new registered provider it is necessary to load the resource again. Parameters not present in the resource will remain unchanged.
+
+There are two ways to check what parameters are available:
+* C++: Open ConfigureNode file and check the InternalParameter field. Each parameter will be described with a comment. To check the global parameters, use the DE_Wrapper class public methods.
+* Resource: Register all available Nodes to the session, then save the configuration and view all existing parameters.
+
+There are two options for loading a resource: recursive and global parameters only. Recursive is the default option to configure all global parameters (units, priority, enable status) and all registered providers. Non-recursive configures only global parameters and ignores all provider settings. This option is the best for updating provider priority.
+
+@subsubsection occt_de_wrapper_3_2_3 Loading configuration resources. Code sample
+
+Configuring using a resource string:
+~~~~{.cpp}
+  Handle(DE_Wrapper) aSession = DE_Wrapper::GlobalWrapper();
+  TCollection_AsciiString aString =
+    "global.priority.STEP :   OCC DTK\n"
+    "global.general.length.unit : 1\n"
+    "provider.STEP.OCC.read.precision.val : 0.\n";
+  Standard_Boolean aIsRecursive = Standard_True;
+  if (!aSession->Load(aString, aIsRecursive))
+  {
+    Message::SendFail() << "Error: configuration is incorrect";
+  }
+~~~~
+Configuring using a resource file:
+~~~~{.cpp}
+  Handle(DE_Wrapper) aSession = DE_Wrapper::GlobalWrapper();
+  TCollection_AsciiString aPathToFile = "";
+  Standard_Boolean aIsRecursive = Standard_True;
+  if (!aSession->Load(aPathToFile, aIsRecursive))
+  {
+    Message::SendFail() << "Error: configuration is incorrect";
+  }
+~~~~
+@subsubsection occt_de_wrapper_3_2_4 Loading configuration resources. DRAW sample
+
+Configuring using a resource string:
+~~~~{.cpp}
+set conf "
+global.priority.STEP :   OCC
+global.general.length.unit :     1
+provider.STEP.OCC.read.iges.bspline.continuity :         1
+provider.STEP.OCC.read.precision.mode :  0
+provider.STEP.OCC.read.precision.val :   0.0001
+"
+LoadConfiguration ${conf} -recursive on
+~~~~
+
+Configuring using a resource file:
+~~~~{.cpp}
+set pathToFile ""
+LoadConfiguration ${pathToFile} -recursive on
+~~~~
+
+@subsubsection occt_de_wrapper_3_2_5 Saving configuration resources. Dump of configuration DE Session
+
+Saving the configuration of a DE Session involves dumping all parameters of registered providers.
+If a parameter did not change during the session, its value remains as default.
+
+There are two ways to save a resource: recursive and global parameters only. Recursive is the way to dump all registered provider information. Non-recursive dumps only global parameters, for example, save priority of vendors or the length unit.
+
+It is possible to filter what vendors or providers to save by providing the correct name of the vendor or provider.
+
+@subsubsection occt_de_wrapper_3_2_6 Saving configuration resources. Code sample
+
+Dump to resource string. If the vendors list is empty, saves all vendors. If the providers list is empty, saves all providers of valid vendors.
+~~~~{.cpp}
+  Handle(DE_Wrapper) aSession = DE_Wrapper::GlobalWrapper();
+  TColStd_ListOfAsciiString aFormats;
+  TColStd_ListOfAsciiString aVendors;
+  aFormats.Appends("STEP");
+  aVendors.Appends("OCC");
+  Standard_Boolean aIsRecursive = Standard_True;
+  TCollection_AsciiString aConf = aSession->aConf->Save(aIsRecursive, aFormats, aVendors);
+~~~~
+Configure using a resource file. If the vendors list is empty, saves all vendors. If the providers list is empty, saves all providers of valid vendors.
+~~~~{.cpp}
+  Handle(DE_Wrapper) aSession = DE_Wrapper::GlobalWrapper();
+  TCollection_AsciiString aPathToFile = "";
+  TColStd_ListOfAsciiString aFormats;
+  TColStd_ListOfAsciiString aVendors;
+  aFormats.Appends("STEP");
+  aVendors.Appends("OCC");
+  Standard_Boolean aIsRecursive = Standard_True;
+  if (!aSession->Save(aPathToFile, aIsRecursive, aFormats,aVendors))
+  {
+    Message::SendFail() << "Error: configuration is not saved";
+  }
+~~~~
+@subsubsection occt_de_wrapper_3_2_7 Saving configuration resources. DRAW sample
+
+Dump configuration to string. If no list of vendors is passed or it is empty, all vendors are saved. If no providers list is passed or it is empty, all providers of valid vendors are saved.
+~~~~{.cpp}
+set vendors "OCC"
+set format "STEP"
+set dump_conf [DumpConfiguration -recursive on -format ${format} -vendor ${vendors}]
+~~~~
+
+Dump configuration to file. If no vendors list are set as an argument or it is empty, saves all vendors. If no providers list as argument or it is empty, saves all providers of valid vendors:
+~~~~{.cpp}
+set vendors "OCC"
+set format "STEP"
+set pathToFile ""
+DumpConfiguration -path ${pathToFile} -recursive on -format ${format} -vendor ${vendors}
+~~~~
+
+@subsection occt_de_wrapper_3_3 Registering providers
+
+To transfer a CAD file using DE Wrapper, it is necessary to register a CAD provider.
+The provider contains internal and global parameters that have default values in the creation stage.
+All registered providers are set to the map with information about its vendor and kept as smart handles. Therefore, it is possible to change the values via handle from external code.
+
+@subsubsection occt_de_wrapper_3_3_1 Registering providers. Code sample
+
+It is nesessary to register only one ConfigurationNode for all needed formats.
+~~~~{.cpp}
+Handle(DE_Wrapper) aSession = DE_Wrapper::GlobalWrapper();
+Handle(DE_ConfigurationNode) aNode = new STEPCAFControl_ConfigurationNode();
+aSession->Bind(aNode);
+~~~~
+@subsubsection occt_de_wrapper_3_3_2 Registering providers. DRAW Sample
+
+Use DRAW with all providers registered by the following command:
+~~~~{.cpp}
+pload XDE
+~~~~
+
+@subsubsection occt_de_wrapper_3_3_3 Realtime initialization. Code sample
+
+It is possible to change a paramater from code using a smart pointer.
+
+~~~~{.cpp}
+// global variable
+static Handle(STEPCAFControl_ConfigurationNode) THE_STEP_NODE;
+
+static Handle(DE_ConfigurationNode) RegisterStepNode()
+{
+  Handle(DE_Wrapper) aSession = DE_Wrapper::GlobalWrapper();
+  if (!THE_STEP_NODE.IsNull())
+  {
+    return THE_STEP_NODE;
+  }
+
+  THE_STEP_NODE = new STEPCAFControl_ConfigurationNode();
+  aSession->Bind(THE_STEP_NODE);
+  return THE_STEP_NODE;
+}
+
+// Change parameter value
+THE_STEP_NODE->InternalParameters.ReadRelationship = false;
+THE_STEP_NODE->InternalParameters.ReadName = false;
+THE_STEP_NODE->InternalParameters.ReadProps = false;
+~~~~
+
+@subsection occt_de_wrapper_3_4 Priority of Vendors
+
+DE session is able to work with several vendors with the same supported CAD format. To choose the preffered vendor for each format, use a special priority list.
+
+If the high priority vendor's provider is not supported, a transfer operation is needed (write/read), then the next vendor will be chosen.
+
+@subsubsection occt_de_wrapper_3_4_1 Priority of Vendors. Code sample
+
+~~~~{.cpp}
+  Handle(DE_Wrapper) aSession = DE_Wrapper::GlobalWrapper();
+  TCollection_AsciiString aFormat = "STEP";
+  TColStd_ListOfAsciiString aVendors;
+  aVendors.Appends("OCC"); // high priority
+  aVendors.Appends("DTK");
+  // Flag to disable not choosen vendors, in this case configuration is possible
+  // otherwise, lower their priority and continue to check ability to transfer
+  Standard_Boolean aToDisable = Standard_True;
+  aSession->ChangePriority(aFormat, aVendors, aToDisable);
+~~~~
+
+@subsubsection occt_de_wrapper_3_4_2 Priority of Vendors. DRAW Sample
+
+It is recommended to disable recursion and update only global parameters.
+~~~~{.cpp}
+set conf "
+global.priority.STEP :   OCC DTK
+"
+LoadConfiguration ${conf} -recursive off
+~~~~
+
+@section occt_de_wrapper_4 Transfer of CAD files
+
+To transfer from a CAD file to OCC or from OCC to a CAD file, it is necessary to use a configured DE_Wrapper object. It can be local, one-time or global. Global configuration of DE_Wrapper propagates to all nodes via transfer. There are two options for transferring: using OCC shape or XCAF document. It is possible to work only with real path to/from the file. Streaming is not supported (yet).
+
+The format of input/output file is automatically determined by its extension or contents.
+
+@subsection occt_de_wrapper_4_1 Transfer of CAD files. Code samples
+
+Reading STEP file to Shape.
+~~~~{.cpp}
+  Handle(DE_Wrapper) aSession = DE_Wrapper::GlobalWrapper();
+  TCollection_AsciiString aPathToFile = "example.stp";
+  TopoDS_Shape aShRes;
+  if (!aSession->Read(aPathToFile, aShRes))
+  {
+    Message::SendFail() << "Error: Can't read file";
+  }
+~~~~
+
+Writing Shape to STEP file.
+~~~~{.cpp}
+  Handle(DE_Wrapper) aSession = DE_Wrapper::GlobalWrapper();
+  TCollection_AsciiString aPathToFile = "example.stp";
+  TopoDS_Shape aShFrom = ...;
+  if (!aSession->Write(aPathToFile, aShRes))
+  {
+    Message::SendFail() << "Error: Can't write file";
+  }
+~~~~
+
+Reading STEP file into XCAF document.
+~~~~{.cpp}
+  Handle(DE_Wrapper) aSession = DE_Wrapper::GlobalWrapper();
+  TCollection_AsciiString aPathToFile = "example.stp";
+  Handle(TDocStd_Document) aDoc = ...;
+  if (!aSession->Read(aPathToFile, aDoc))
+  {
+    Message::SendFail() << "Error: Can't read file";
+  }
+~~~~
+
+Writing XCAF document into STEP.
+~~~~{.cpp}
+  Handle(DE_Wrapper) aSession = DE_Wrapper::GlobalWrapper();
+  TCollection_AsciiString aPathToFile = "example.stp";
+  Handle(TDocStd_Document) aDoc = ...;
+  if (!aSession->Write(aPathToFile, aDoc))
+  {
+    Message::SendFail() << "Error: Can't write file";
+  }
+~~~~
+
+@subsection occt_de_wrapper_4_2 Transfer of CAD files. DRAW samples
+
+Reading a STEP file into a Shape.
+~~~~{.cpp}
+set fileName "sample.stp"
+readfile shape ${fileName}
+~~~~
+
+Writing a Shape into STEP.
+~~~~{.cpp}
+set fileName "sample.stp"
+writefile shape ${fileName}
+~~~~
+
+Reading STEP into XCAF document.
+~~~~{.cpp}
+set fileName "sample.stp"
+ReadFile D ${fileName}
+~~~~
+
+Writing XCAF document into STEP.
+~~~~{.cpp}
+set fileName "sample.stp"
+WriteFile D ${fileName}
+~~~~
+
+@subsection occt_de_wrapper_4_3 Transfer using DE Provider. Code sample
+
+It is possible to read and write CAD files directly from a special provider.
+
+~~~~{.cpp}
+// Creating or getting node
+Handle(STEPCAFControl_ConfigurationNode) aNode = new STEPCAFControl_ConfigurationNode();
+// Creationg an one-time provider
+Handle(DE_Provider) aProvider = aNode->BuildProvider();
+// Setting configuration with all parameters
+aProvider->SetNode(aNode);
+if (!aProvider->Read(...))
+{
+  Message::SendFail() << "Error: Can't read STEP file";
+}
+if (!aProvider->Write(...))
+{
+  Message::SendFail() << "Error: Can't write STEP file";
+}
+~~~~
+
+@subsection occt_de_wrapper_4_4 Temporary configuration via transfer
+
+It is possible to change the configuration of only one transfer operation. To avoid changing parameters in a session, one-time clone of the session can be created and used for transfer. This way is recommended for use in multithreaded mode.
+
+@subsubsection occt_de_wrapper_4_4_1 Temporary configuration via transfer. Code sample
+
+Code sample to configure via transfer.
+~~~~{.cpp}
+  Handle(DE_Wrapper) aSession = DE_Wrapper::GlobalWrapper()->Copy();
+  TCollection_AsciiString aString =
+    "global.priority.STEP :   OCC DTK\n"
+    "global.general.length.unit : 1\n"
+    "provider.STEP.OCC.read.precision.val : 0.\n";
+  if (!aSession->Load(aString, aIsRecursive))
+  {
+    Message::SendFail() << "Error: configuration is incorrect";
+  }
+  TCollection_AsciiString aPathToFile = "example.stp";
+  TopoDS_Shape aShRes;
+  if (!aSession->Read(aPathToFile, aShRes))
+  {
+    Message::SendFail() << "Error: Can't read file";
+  }
+~~~~
+
+@subsubsection occt_de_wrapper_4_4_2 Temporary configuration via transfer. DRAW sample
+
+Code sample to configure via transfer within DRAW command.
+~~~~{.cpp}
+set fileName "sample.stp"
+readfile S5 $filename -conf "global.general.length.unit : 1000 "
+~~~~
+
+Code sample to configure via transfer as variable.
+~~~~{.cpp}
+set fileName "sample.stp"
+set conf "
+global.priority.STEP :   OCC
+global.general.length.unit :     1
+provider.STEP.OCC.read.iges.bspline.continuity :         1
+provider.STEP.OCC.read.precision.mode :  0
+provider.STEP.OCC.read.precision.val :   0.0001
+"
+readfile S5 $filename -conf ${conf}
+~~~~

dox/user_guides/user_guides.md

@@ -13,6 +13,7 @@ OCCT User Guides are organized by OCCT modules:
 * @subpage occt_user_guides__iges "IGES Translator"
 * @subpage occt_user_guides__step "STEP Translator"
 * @subpage occt_user_guides__xde "Extended Data Exchange (XDE)"
+* @subpage occt_user_guides__de_wrapper "Data Exchange Wrapper (DE Wrapper)"
 * @subpage occt_user_guides__ocaf "Open CASCADE Application Framework (OCAF)"
 * @subpage occt_user_guides__test_harness "DRAW Test Harness"
 * @subpage occt_user_guides__inspector "Inspector"

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_PaveFiller_6.cxx

@@ -62,6 +62,7 @@
 #include <IntTools_SequenceOfCurves.hxx>
 #include <IntTools_SequenceOfPntOn2Faces.hxx>
 #include <IntTools_Tools.hxx>
+#include <NCollection_IncAllocator.hxx>
 #include <NCollection_Vector.hxx>
 #include <Precision.hxx>
 #include <TColStd_ListOfInteger.hxx>
@@ -578,14 +579,12 @@ void BOPAlgo_PaveFiller::MakeBlocks(const Message_ProgressRange& theRange)
   Standard_Integer i, nF1, nF2, aNbC, aNbP, j;
   Standard_Integer nV1, nV2;
   Standard_Real aT1, aT2;
-  Handle(NCollection_BaseAllocator) aAllocator;
+  Handle(NCollection_BaseAllocator) aAllocator = new NCollection_IncAllocator;
   BOPDS_ListIteratorOfListOfPaveBlock aItLPB;
   TopoDS_Edge aES;
   Handle(BOPDS_PaveBlock) aPBOut;
   //
   //-----------------------------------------------------scope f
-  aAllocator=
-    NCollection_BaseAllocator::CommonBaseAllocator();
   //
   TColStd_ListOfInteger aLSE(aAllocator), aLBV(aAllocator);
   TColStd_MapOfInteger aMVOnIn(100, aAllocator), aMVCommon(100, aAllocator),

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/BRepAlgo/BRepAlgo_Loop.cxx

@@ -42,12 +42,14 @@
 #include <TopTools_SequenceOfShape.hxx>
 
 #include <stdio.h>
+//#define OCCT_DEBUG_ALGO
+//#define DRAW
 #ifdef DRAW
 #include <DBRep.hxx>
 #pragma comment(lib,"TKDraw")
 #endif
 #ifdef OCCT_DEBUG_ALGO
-Standard_Boolean AffichLoop  = Standard_False;
+Standard_Boolean AffichLoop  = Standard_True;
 Standard_Integer NbLoops     = 0;
 Standard_Integer NbWires     = 1;
 static char* name = new char[100];
@@ -58,7 +60,8 @@ static char* name = new char[100];
 //purpose  : 
 //=======================================================================
 
-BRepAlgo_Loop::BRepAlgo_Loop()
+BRepAlgo_Loop::BRepAlgo_Loop():
+  myTolConf (0.001)
 {
 }
 
@@ -185,7 +188,6 @@ static TopoDS_Vertex  UpdateClosedEdge(const TopoDS_Edge&         E,
   Standard_Boolean OnStart = 0, OnEnd = 0;
   //// modified by jgv, 13.04.04 for OCC5634 ////
   TopExp::Vertices (E,V1,V2);
-  //Standard_Real    Tol = Precision::Confusion();
   Standard_Real    Tol = BRep_Tool::Tolerance( V1 );
   ///////////////////////////////////////////////
   
@@ -427,13 +429,12 @@ static void StoreInMVE (const TopoDS_Face&                  F,
 			TopoDS_Edge&                  E,
 			TopTools_IndexedDataMapOfShapeListOfShape& MVE,
 			Standard_Boolean&                   YaCouture,
-			TopTools_DataMapOfShapeShape& VerticesForSubstitute )
+			TopTools_DataMapOfShapeShape& VerticesForSubstitute,
+            const Standard_Real theTolConf)
 {      
   TopoDS_Vertex V1, V2, V;
   TopTools_ListOfShape Empty;
   
-  Standard_Real Tol = 0.001; //5.e-05; //5.e-07;
-//  gp_Pnt P1, P2, P;
   gp_Pnt P1, P;
   BRep_Builder BB;
   for (Standard_Integer iV = 1; iV <= MVE.Extent(); iV++)
@@ -449,7 +450,7 @@ static void StoreInMVE (const TopoDS_Face&                  F,
 	{
 	  V1 = TopoDS::Vertex( itl.Value() );
 	  P1 = BRep_Tool::Pnt( V1 );
-	  if (P.IsEqual( P1, Tol ) && !V.IsSame(V1))
+	  if (P.IsEqual( P1, theTolConf ) && !V.IsSame(V1))
 	    {
 	      V.Orientation( V1.Orientation() );
 	      if (VerticesForSubstitute.IsBound( V1 ))
@@ -574,7 +575,7 @@ void BRepAlgo_Loop::Perform()
         TopoDS_Edge& E = TopoDS::Edge(itl1.Value());
         if (!Emap.Add(E))
           continue;
-        StoreInMVE(myFace,E,MVE,YaCouture,myVerticesForSubstitute);
+        StoreInMVE(myFace,E,MVE,YaCouture,myVerticesForSubstitute, myTolConf);
       }
     }
   }
@@ -586,7 +587,7 @@ void BRepAlgo_Loop::Perform()
   for (itl.Initialize(myConstEdges); itl.More(); itl.Next()) {
     TopoDS_Edge& E = TopoDS::Edge(itl.Value());
     if (DejaVu.Add(E))
-      StoreInMVE(myFace,E,MVE,YaCouture,myVerticesForSubstitute);
+      StoreInMVE(myFace,E,MVE,YaCouture,myVerticesForSubstitute, myTolConf);
   }
 
 #ifdef DRAW
@@ -626,42 +627,42 @@ void BRepAlgo_Loop::Perform()
     //--------------------------------
     RemovePendingEdges(MVE);
 
-    if (MVE.Extent() == 0) break; 
+    if (MVE.Extent() == 0) break;
     //--------------------------------
     // Start edge.
     //--------------------------------
     EF = CE = TopoDS::Edge(MVE(1).First());
-    TopExp::Vertices(CE,V1,V2);
+    TopExp::Vertices(CE, V1, V2);
     //--------------------------------
     // VF vertex start of new wire
     //--------------------------------
-    if (CE.Orientation() == TopAbs_FORWARD) { CV = VF = V1;}
-    else                                    { CV = VF = V2;}
+    if (CE.Orientation() == TopAbs_FORWARD) { CV = VF = V1; }
+    else { CV = VF = V2; }
     if (!MVE.Contains(CV)) continue;
     TopTools_ListOfShape& aListEdges = MVE.ChangeFromKey(CV);
-    for ( itl.Initialize(aListEdges); itl.More(); itl.Next()) {
+    for (itl.Initialize(aListEdges); itl.More(); itl.Next()) {
       if (itl.Value().IsEqual(CE)) {
-	aListEdges.Remove(itl);
-	break;
+        aListEdges.Remove(itl);
+        break;
       }
     }
-    End  = Standard_False;
-    
+    End = Standard_False;
+
     while (!End) {
       //-------------------------------
       // Construction of a wire.
       //-------------------------------
-      TopExp::Vertices(CE,V1,V2);
+      TopExp::Vertices(CE, V1, V2);
       if (!CV.IsSame(V1)) CV = V1; else CV = V2;
 
-      B.Add (NW,CE);
+      B.Add(NW, CE);
       UsedEdges.Add(CE);
 
       if (!MVE.Contains(CV) || MVE.FindFromKey(CV).IsEmpty()) {
         End = Standard_True;
       }
       else {
-        End = !SelectEdge(myFace,CE,CV,NE,MVE.ChangeFromKey(CV));
+        End = !SelectEdge(myFace, CE, CV, NE, MVE.ChangeFromKey(CV));
         if (!End) {
           CE = NE;
           if (MVE.FindFromKey(CV).IsEmpty())
@@ -672,35 +673,41 @@ void BRepAlgo_Loop::Perform()
     //--------------------------------------------------
     // Add new wire to the set of wires
     //------------------------------------------------
-    Standard_Real Tol = 0.001; //5.e-05; //5.e-07;
-    TopExp_Explorer explo( NW, TopAbs_VERTEX );
-    for (; explo.More(); explo.Next())
-      {
-      const TopoDS_Vertex& aV = TopoDS::Vertex( explo.Current() );
-      Handle(BRep_TVertex)& TV = *((Handle(BRep_TVertex)*) &(aV).TShape());
-      TV->Tolerance( Tol );
-      TV->Modified( Standard_True );
-      }
-    for (explo.Init( NW, TopAbs_EDGE ); explo.More(); explo.Next())
-      {
-      const TopoDS_Edge& aE = TopoDS::Edge( explo.Current() );
-      Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*) &(aE).TShape());
-      TE->Tolerance( Tol );
-      TE->Modified( Standard_True );
-      }
 
-    if (VF.IsSame(CV) && SamePnt2d(VF,EF,CE,myFace))
+    if (VF.IsSame(CV))
     {
-      NW.Closed (Standard_True);
-      myNewWires.Append (NW);
+      if (SamePnt2d(VF, EF, CE, myFace))
+      {
+        NW.Closed(Standard_True);
+        myNewWires.Append(NW);
+      }
+      else if(BRep_Tool::Tolerance(VF) < myTolConf)
+      {
+        BRep_Builder aBB;
+        aBB.UpdateVertex(VF, myTolConf);
+        if (SamePnt2d(VF, EF, CE, myFace))
+        {
+          NW.Closed(Standard_True);
+          myNewWires.Append(NW);
+        }
+#ifdef OCCT_DEBUG_ALGO
+        else
+        {
+          std::cout << "BRepAlgo_Loop: Open Wire" << std::endl;
+          if (AffichLoop)
+            std::cout << "OpenWire is : NW_" << NbLoops << "_" << NbWires << std::endl;
+        }
+#endif
+      }
     }
 #ifdef OCCT_DEBUG_ALGO
     else {
-      std::cout <<"BRepAlgo_Loop: Open Wire"<<std::endl;
+      std::cout << "BRepAlgo_Loop: Open Wire" << std::endl;
       if (AffichLoop)
-        std::cout << "OpenWire is : NW_"<<NbLoops<<"_"<<NbWires<<std::endl;
-      }
+        std::cout << "OpenWire is : NW_" << NbLoops << "_" << NbWires << std::endl;
+    }
 #endif
+
 #ifdef DRAW
     if (AffichLoop) {
       sprintf(name,"NW_%d_%d",NbLoops,NbWires++);	
@@ -777,8 +784,6 @@ void BRepAlgo_Loop::CutEdge (const TopoDS_Edge&          E,
       VF = TopoDS::Vertex(aLocalV);
       aLocalV = VCEI.Oriented(TopAbs_REVERSED); 
       VL = TopoDS::Vertex(aLocalV);
-//      VF = TopoDS::Vertex(VCEI.Oriented(TopAbs_FORWARD));
-//      VL = TopoDS::Vertex(VCEI.Oriented(TopAbs_REVERSED)); 
     }
     SV.Prepend(VF);
     SV.Append(VL);
@@ -813,13 +818,9 @@ void BRepAlgo_Loop::CutEdge (const TopoDS_Edge&          E,
       B.Add  (NewEdge,aLocalEdge);
       aLocalEdge = V2.Oriented(TopAbs_REVERSED);
       B.Add  (TopoDS::Edge(NewEdge),aLocalEdge);
-//      B.Add  (NewEdge,V1.Oriented(TopAbs_FORWARD));
-//      B.Add  (NewEdge,V2.Oriented(TopAbs_REVERSED));
       if (V1.IsSame(VF)) 
 	U1 = f;
       else 
-//	U1=BRep_Tool::Parameter
-//	  (TopoDS::Vertex(V1.Oriented(TopAbs_INTERNAL)),WE);
 	{
 	  TopoDS_Shape aLocalV = V1.Oriented(TopAbs_INTERNAL);
 	  U1=BRep_Tool::Parameter(TopoDS::Vertex(aLocalV),WE);
@@ -830,8 +831,6 @@ void BRepAlgo_Loop::CutEdge (const TopoDS_Edge&          E,
 	{
 	  TopoDS_Shape aLocalV = V2.Oriented(TopAbs_INTERNAL);
 	  U2=BRep_Tool::Parameter(TopoDS::Vertex(aLocalV),WE);
-//	U2=BRep_Tool::Parameter
-//	  (TopoDS::Vertex(V2.Oriented(TopAbs_INTERNAL)),WE);
 	}
       B.Range (TopoDS::Edge(NewEdge),U1,U2);
 #ifdef DRAW

src/BRepAlgo/BRepAlgo_Loop.hxx

@@ -86,8 +86,17 @@ public:
   
   Standard_EXPORT void VerticesForSubstitute (TopTools_DataMapOfShapeShape& VerVerMap);
 
+  //! Set maximal tolerance used for comparing distaces between vertices. 
+  void SetTolConf(const Standard_Real theTolConf)
+  {
+    myTolConf = theTolConf;
+  }
 
-
+  //! Get maximal tolerance used for comparing distaces between vertices. 
+  Standard_Real GetTolConf() const
+  {
+    return myTolConf;
+  }
 
 protected:
 
@@ -108,6 +117,7 @@ private:
   TopTools_DataMapOfShapeListOfShape myCutEdges;
   TopTools_DataMapOfShapeShape myVerticesForSubstitute;
   BRepAlgo_Image myImageVV;
+  Standard_Real myTolConf;
 
 
 };

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/BRepExtrema/BRepExtrema_ProximityDistTool.cxx

@@ -43,6 +43,8 @@ BRepExtrema_ProximityDistTool::BRepExtrema_ProximityDistTool()
 //=======================================================================
 BRepExtrema_ProximityDistTool::BRepExtrema_ProximityDistTool (const Handle(BRepExtrema_TriangleSet)& theSet1,
                                                               const Standard_Integer theNbSamples1,
+                                                              const BVH_Array3d& theAddVertices1,
+                                                              const NCollection_Vector<ProxPnt_Status>& theAddStatus1,
                                                               const Handle(BRepExtrema_TriangleSet)& theSet2,
                                                               const BRepExtrema_ShapeList& theShapeList1,
                                                               const BRepExtrema_ShapeList& theShapeList2)
@@ -55,6 +57,7 @@ BRepExtrema_ProximityDistTool::BRepExtrema_ProximityDistTool (const Handle(BRepE
 {
   LoadTriangleSets (theSet1, theSet2);
   LoadShapeLists (theShapeList1, theShapeList2);
+  LoadAdditionalPointsFirstSet (theAddVertices1, theAddStatus1);
 }
 
 //=======================================================================
@@ -69,7 +72,7 @@ void BRepExtrema_ProximityDistTool::LoadTriangleSets (const Handle(BRepExtrema_T
 }
 
 //=======================================================================
-//function : LoadTriangleSets
+//function : LoadShapeLists
 //purpose  : Loads the given list of subshapes into the proximity tool
 //=======================================================================
 void BRepExtrema_ProximityDistTool::LoadShapeLists (const BRepExtrema_ShapeList& theShapeList1,
@@ -78,23 +81,33 @@ void BRepExtrema_ProximityDistTool::LoadShapeLists (const BRepExtrema_ShapeList&
   myShapeList1 = theShapeList1;
   myShapeList2 = theShapeList2;
 }
-//=======================================================================
-//function : Perform
-//purpose  : Performs searching of the proximity distance
-//=======================================================================
-void BRepExtrema_ProximityDistTool::Perform()
-{
-  SetBVHSet (mySet2.get());
 
-  const BVH_Array3d& aVertices1 = mySet1->GetVertices();
-  Standard_Integer aVtxSize = (Standard_Integer)aVertices1.size();
+//=======================================================================
+//function : LoadAdditionalPointsFirstSet
+//purpose  : Loads given additional vertices and their statuses
+//=======================================================================
+void BRepExtrema_ProximityDistTool::LoadAdditionalPointsFirstSet (const BVH_Array3d& theAddVertices1,
+                                                                  const NCollection_Vector<ProxPnt_Status>& theAddStatus1)
+{
+  myAddVertices1 = theAddVertices1;
+  myAddStatus1 = theAddStatus1;
+}
+
+//=======================================================================
+//function : goThroughtSet1
+//purpose  : Goes throught vertices from the 1st set
+//=======================================================================
+void BRepExtrema_ProximityDistTool::goThroughtSet1 (const BVH_Array3d& theVertices1,
+                                                    const Standard_Boolean theIsAdditionalSet)
+{
+  Standard_Integer aVtxSize = (Standard_Integer)theVertices1.size();
   Standard_Integer aVtxStep = Max (myNbSamples1 <= 0 ? 1 : aVtxSize / myNbSamples1, 1);
   for (Standard_Integer aVtxIdx = 0; aVtxIdx < aVtxSize; aVtxIdx += aVtxStep)
   {
     myDistance = std::numeric_limits<Standard_Real>::max();
     myMinDistance = std::numeric_limits<Standard_Real>::max();
     myIsDone = Standard_False;
-    SetObject (aVertices1[aVtxIdx]);
+    SetObject (theVertices1[aVtxIdx]);
 
     ComputeDistance();
 
@@ -102,20 +115,31 @@ void BRepExtrema_ProximityDistTool::Perform()
 
     if (IsDone() && myDistance > myProxDist)
     {
-      myPnt1 = aVertices1[aVtxIdx];
+      myPnt1 = theVertices1[aVtxIdx];
       myPnt2 = myExtremaPoint;
       myProxDist = myDistance;
       myProxVtxIdx1 = aVtxIdx;
+      myIsProxVtx1FromAddSet = theIsAdditionalSet;
       myProxPrjState = myExtPrjState;
     }
   }
+}
 
-   myIsDone = myProxDist > -1.;
+//=======================================================================
+//function : Perform
+//purpose  : Performs searching of the proximity distance
+//=======================================================================
+void BRepExtrema_ProximityDistTool::Perform()
+{
+  SetBVHSet (mySet2.get());
+  goThroughtSet1 (mySet1->GetVertices(), Standard_False);
+  goThroughtSet1 (myAddVertices1, Standard_True);
 
-   if (myIsDone)
-   {
-     DefineStatusProxPnt();
-   }
+  myIsDone = myProxDist > -1.;
+  if (myIsDone)
+  {
+    DefineStatusProxPnt();
+  }
 }
 
 static Standard_Real pointBoxSquareMaxDistance (const BVH_Vec3d& thePoint,
@@ -247,7 +271,12 @@ Standard_Real BRepExtrema_ProximityDistTool::ComputeDistance()
   return myDistance;
 }
 
-static Standard_Boolean isNodeOnBorder (const Standard_Integer theNodeIdx, const Handle (Poly_Triangulation)& theTr)
+//=======================================================================
+//function : IsNodeOnBorder
+//purpose  : Returns true if the node is on the boarder
+//=======================================================================
+Standard_Boolean BRepExtrema_ProximityDistTool::IsNodeOnBorder (const Standard_Integer theNodeIdx,
+                                                                const Handle(Poly_Triangulation)& theTr)
 {
   Poly_Connect aPolyConnect (theTr);
 
@@ -279,12 +308,49 @@ static Standard_Boolean isNodeOnBorder (const Standard_Integer theNodeIdx, const
   return Standard_False;
 }
 
+//=======================================================================
+//function : IsEdgeOnBorder
+//purpose  : Returns true if the edge is on the boarder
+//=======================================================================
+Standard_Boolean BRepExtrema_ProximityDistTool::IsEdgeOnBorder (const Standard_Integer theTrgIdx,
+                                                                const Standard_Integer theFirstEdgeNodeIdx,
+                                                                const Standard_Integer theSecondEdgeNodeIdx,
+                                                                const Handle(Poly_Triangulation)& theTr)
+{
+  Poly_Connect aPolyConnect (theTr);
+
+  Standard_Integer aAdjTrg[3];
+  aPolyConnect.Triangles (theTrgIdx, aAdjTrg[0], aAdjTrg[1], aAdjTrg[2]); //indices of adjacent triangles
+
+  for (Standard_Integer j = 0; j < 3; j++)
+  {
+    Standard_Integer k = (j + 1) % 3;
+    if (aAdjTrg[j] == 0) //free segment of triangle
+    {
+      //are ends of free segment and it is a part of border
+      if (j == theFirstEdgeNodeIdx &&
+          k == theSecondEdgeNodeIdx)
+      {
+        return Standard_True;
+      }
+    }
+  }
+
+  return Standard_False;
+}
+
 //=======================================================================
 //function : defineStatusProxPnt1
 //purpose  : Defines the status of proximity point from 1st BVH
 //=======================================================================
 void BRepExtrema_ProximityDistTool::defineStatusProxPnt1()
 {
+  if (myIsProxVtx1FromAddSet)
+  {
+    myPntStatus1 = myAddStatus1[myProxVtxIdx1];
+    return;
+  }
+
   Standard_Integer aFaceID1 = mySet1->GetShapeIDOfVtx (myProxVtxIdx1);
 
   if (myShapeList1 (aFaceID1).ShapeType() == TopAbs_EDGE)
@@ -314,9 +380,9 @@ void BRepExtrema_ProximityDistTool::defineStatusProxPnt1()
 
     TopLoc_Location aLocation;
     const TopoDS_Face& aF = TopoDS::Face (myShapeList1 (aFaceID1));
-    Handle (Poly_Triangulation) aTr = BRep_Tool::Triangulation (aF, aLocation);
+    Handle(Poly_Triangulation) aTr = BRep_Tool::Triangulation (aF, aLocation);
 
-    if (isNodeOnBorder (aNodeIdx, aTr))
+    if (IsNodeOnBorder (aNodeIdx, aTr))
     {
       myPntStatus1 = ProxPnt_Status_BORDER;
     }
@@ -398,7 +464,7 @@ void BRepExtrema_ProximityDistTool::defineStatusProxPnt2()
     {
       TopLoc_Location aLocation;
       const TopoDS_Face& aF = TopoDS::Face (myShapeList2 (aFaceID2));
-      Handle (Poly_Triangulation) aTr = BRep_Tool::Triangulation (aF, aLocation);
+      Handle(Poly_Triangulation) aTr = BRep_Tool::Triangulation (aF, aLocation);
 
       NCollection_Array1<Standard_Integer> aVtxIndicesOfTrg;
       mySet2->GetVtxIndices (aTrgIdx, aVtxIndicesOfTrg);
@@ -408,7 +474,7 @@ void BRepExtrema_ProximityDistTool::defineStatusProxPnt2()
         Standard_Integer aNodeNum = myProxPrjState.GetNumberOfFirstNode();
         Standard_Integer aNodeIdx = mySet2->GetVtxIdxInShape (aVtxIndicesOfTrg[aNodeNum]) + 1;
 
-        if (isNodeOnBorder (aNodeIdx, aTr))
+        if (IsNodeOnBorder (aNodeIdx, aTr))
         {
           myPntStatus2 = ProxPnt_Status_BORDER;
         }
@@ -419,27 +485,18 @@ void BRepExtrema_ProximityDistTool::defineStatusProxPnt2()
       }
       else if (myProxPrjState.GetPrjState() == BVH_PrjState::BVH_PrjStateInTriangle_EDGE)
       {
-        myPntStatus2 = ProxPnt_Status_MIDDLE;
-
-        Poly_Connect aPolyConnect (aTr);
         Standard_Integer aTrgIdxInShape = mySet2->GetTrgIdxInShape (aTrgIdx) + 1;
 
-        Standard_Integer aAdjTrg[3];
-        aPolyConnect.Triangles (aTrgIdxInShape, aAdjTrg[0], aAdjTrg[1], aAdjTrg[2]); //indices of adjacent triangles
-
-        for (Standard_Integer j = 0; j < 3; j++)
+        if (IsEdgeOnBorder (aTrgIdxInShape,
+                            myProxPrjState.GetNumberOfFirstNode(),
+                            myProxPrjState.GetNumberOfLastNode(),
+                            aTr))
         {
-          Standard_Integer k = (j + 1) % 3;
-          if (aAdjTrg[j] == 0) //free segment of triangle
-          {
-            //aVtxIndicesOfTrg[j] and aVtxIndicesOfTrg[k] are ends of free segment and it is a part of border
-            if (j == myProxPrjState.GetNumberOfFirstNode() &&
-                k == myProxPrjState.GetNumberOfLastNode())
-            {
-              myPntStatus2 = ProxPnt_Status_BORDER;
-              break;
-            }
-          }
+          myPntStatus2 = ProxPnt_Status_BORDER;
+        }
+        else
+        {
+          myPntStatus2 = ProxPnt_Status_MIDDLE;
         }
       } //else if (myProxPrjState.GetPrjState() == BVH_PrjState::BVH_PrjStateInTriangle_EDGE)
     }

src/BRepExtrema/BRepExtrema_ProximityDistTool.hxx

@@ -21,6 +21,7 @@
 #include <BRepExtrema_TriangleSet.hxx>
 #include <BVH_Distance.hxx>
 #include <BVH_Tools.hxx>
+#include <Poly_Triangulation.hxx>
 
 //! Tool class for computation the proximity distance from first 
 //! primitive set to second one that is the maximal from minimum 
@@ -93,6 +94,8 @@ public:
   //! Creates new tool for the given element sets.
   Standard_EXPORT BRepExtrema_ProximityDistTool (const Handle(BRepExtrema_TriangleSet)& theSet1,
                                                  const Standard_Integer theNbSamples1,
+                                                 const BVH_Array3d& theAddVertices1,
+                                                 const NCollection_Vector<ProxPnt_Status>& theAddStatus1,
                                                  const Handle(BRepExtrema_TriangleSet)& theSet2,
                                                  const BRepExtrema_ShapeList& theShapeList1,
                                                  const BRepExtrema_ShapeList& theShapeList2);
@@ -107,6 +110,10 @@ public:
   Standard_EXPORT void LoadShapeLists (const BRepExtrema_ShapeList& theShapeList1,
                                        const BRepExtrema_ShapeList& theShapeList2);
 
+  //! Loads given additional vertices and their statuses.
+  void LoadAdditionalPointsFirstSet (const BVH_Array3d& theAddVertices1,
+                                     const NCollection_Vector<ProxPnt_Status>& theAddStatus1);
+
   //! Performs searching of the proximity distance.
   Standard_EXPORT void Perform();
 
@@ -121,6 +128,20 @@ public: //! @name Reject/Accept implementations
   Standard_EXPORT virtual Standard_Boolean Accept (const Standard_Integer theSgmIdx,
                                                    const Standard_Real&) Standard_OVERRIDE;
 
+public:
+
+  //! Returns true if the node is on the boarder.
+  Standard_EXPORT static Standard_Boolean IsNodeOnBorder (const Standard_Integer theNodeIdx,
+                                                          const Handle (Poly_Triangulation)& theTr);
+
+  //! Returns true if the edge is on the boarder.
+  Standard_EXPORT static Standard_Boolean IsEdgeOnBorder (const Standard_Integer theTrgIdx,
+                                                          const Standard_Integer theFirstEdgeNodeIdx,
+                                                          const Standard_Integer theSecondEdgeNodeIdx,
+                                                          const Handle (Poly_Triangulation)& theTr);
+
+public:
+
   //! Returns points on triangles sets, which provide the proximity distance.
   void ProximityPoints (BVH_Vec3d& thePoint1, BVH_Vec3d& thePoint2) const
   {
@@ -148,6 +169,10 @@ protected:
 
 private:
 
+  //! Goes throught vertices from the 1st set.
+  void goThroughtSet1 (const BVH_Array3d& aVertices1,
+                       const Standard_Boolean theIsAdditionalSet);
+
   //! Defines the status of proximity point from 1st BVH.
   void defineStatusProxPnt1();
 
@@ -183,6 +208,11 @@ private:
 
   Standard_Integer myNbSamples1; //!< Number of samples points on the first shape
 
+  //! Is vertex corresponding to proximity point of 1st shape from additional set
+  Standard_Integer myIsProxVtx1FromAddSet;
+  BVH_Array3d myAddVertices1; //!< Additional vertices on the 1st shape
+  NCollection_Vector<ProxPnt_Status> myAddStatus1; //!< Status of additional vertices on the 1st shape
+
   //! Vertex index from 1st BVH corresponding to proximity point of 1st shape
   Standard_Integer myProxVtxIdx1;
 

src/BRepExtrema/BRepExtrema_ProximityValueTool.cxx

@@ -1,4 +1,4 @@
-// Created on: 2022-08-08
+// Created on: 2022-08-08
 // Created by: Kseniya NOSULKO
 // Copyright (c) 2022 OPEN CASCADE SAS
 //
@@ -14,17 +14,32 @@
 // commercial license or contractual agreement.
 
 #include <BRepExtrema_ProximityValueTool.hxx>
+#include <BRepExtrema_ProximityDistTool.hxx>
+
+#include <BRep_Tool.hxx>
+#include <BRepAdaptor_Curve.hxx>
+#include <BRepGProp.hxx>
+#include <GCPnts_AbscissaPoint.hxx>
+#include <GCPnts_QuasiUniformAbscissa.hxx>
+#include <GProp_GProps.hxx> 
+#include <Poly_Connect.hxx>
+#include <TopoDS.hxx>
 
 //=======================================================================
 //function : BRepExtrema_ProximityValueTool
 //purpose  : Creates new unitialized proximity tool
 //=======================================================================
 BRepExtrema_ProximityValueTool::BRepExtrema_ProximityValueTool()
-: myDistance (std::numeric_limits<Standard_Real>::max()),
+: myIsRefinementRequired1 (Standard_False),
+  myIsRefinementRequired2 (Standard_False),
+  myDistance (std::numeric_limits<Standard_Real>::max()),
   myIsDone (Standard_False),
   myNbSamples1(0),
   myNbSamples2(0)
-{}
+{
+  // Should be initialized later
+  myIsInitS1 = myIsInitS2 = Standard_False;
+}
 
 //=======================================================================
 //function : BRepExtrema_ProximityValueTool
@@ -34,13 +49,15 @@ BRepExtrema_ProximityValueTool::BRepExtrema_ProximityValueTool (const Handle(BRe
                                                                 const Handle(BRepExtrema_TriangleSet)& theSet2,
                                                                 const BRepExtrema_ShapeList& theShapeList1,
                                                                 const BRepExtrema_ShapeList& theShapeList2)
-: myDistance (std::numeric_limits<Standard_Real>::max()),
+: myIsRefinementRequired1 (Standard_False),
+  myIsRefinementRequired2 (Standard_False),
+  myDistance (std::numeric_limits<Standard_Real>::max()),
   myIsDone (Standard_False),
-  myNbSamples1(0),
-  myNbSamples2(0)
+  myNbSamples1 (0),
+  myNbSamples2 (0)
 {
-  LoadTriangleSets (theSet1, theSet2);
   LoadShapeLists (theShapeList1, theShapeList2);
+  LoadTriangleSets (theSet1, theSet2);
 }
 
 //=======================================================================
@@ -53,7 +70,94 @@ void BRepExtrema_ProximityValueTool::LoadTriangleSets (const Handle(BRepExtrema_
   mySet1 = theSet1;
   mySet2 = theSet2;
 
-  myIsDone = Standard_False;
+  MarkDirty();
+}
+
+//=======================================================================
+//function : calcEdgeRefinementStep
+//purpose  : Calculates the edge refinement step
+//=======================================================================
+static Standard_Real calcEdgeRefinementStep (const TopoDS_Edge& theEdge,
+                                             const Standard_Integer theNbNodes)
+{
+  if (theNbNodes < 2)
+    return 0;
+
+  BRepAdaptor_Curve aBAC (theEdge);
+  Standard_Real aLen = GCPnts_AbscissaPoint::Length (aBAC);
+  return aLen / (Standard_Real)(theNbNodes - 1);
+}
+
+//=======================================================================
+//function : calcFaceRefinementStep
+//purpose  : Calculates the face refinement step as an approximate square
+// (Shape area / number triangles) * 2
+//=======================================================================
+static Standard_Real calcFaceRefinementStep (const TopoDS_Face& theFace,
+                                             const Standard_Integer theNbTrg)
+{
+  if (theNbTrg < 1)
+    return 0;
+
+  GProp_GProps props;
+  BRepGProp::SurfaceProperties (theFace, props);
+  Standard_Real aArea = props.Mass();
+  return 2 * (aArea / (Standard_Real)theNbTrg);
+}
+
+//=======================================================================
+//function : getInfoForRefinement
+//purpose  : Gets shape data for further refinement
+//=======================================================================
+Standard_Boolean BRepExtrema_ProximityValueTool::getInfoForRefinement (const TopoDS_Shape& theShape,
+                                                                       TopAbs_ShapeEnum& theShapeType,
+                                                                       Standard_Integer& theNbNodes,
+                                                                       Standard_Real& theStep)
+{
+  if (theShape.ShapeType() == TopAbs_FACE)
+  {
+    theShapeType = TopAbs_FACE;
+    TopoDS_Face aF = TopoDS::Face (theShape);
+
+    TopLoc_Location aLocation;
+    Handle(Poly_Triangulation) aTriangulation = BRep_Tool::Triangulation (aF, aLocation);
+
+    if (aTriangulation.IsNull())
+    {
+      return Standard_False;
+    }
+
+    theNbNodes = aTriangulation->NbNodes();
+    Standard_Integer aNbTrg = aTriangulation->NbTriangles();
+    theStep = calcFaceRefinementStep (aF, aNbTrg);
+  }
+  else if (theShape.ShapeType() == TopAbs_EDGE)
+  {
+    theShapeType = TopAbs_EDGE;
+    TopoDS_Edge aE = TopoDS::Edge (theShape);
+
+    TopLoc_Location aLocation;
+    Handle(Poly_Polygon3D) aPolygon = BRep_Tool::Polygon3D (aE, aLocation);
+
+    if (aPolygon.IsNull())
+    {
+      return Standard_False;
+    }
+
+    theNbNodes = aPolygon->NbNodes();
+    theStep = calcEdgeRefinementStep (aE, theNbNodes);
+  }
+  else
+  {
+    return Standard_False;
+  }
+
+  if (theStep < Precision::Confusion())
+  {
+    return Standard_False;
+  }
+
+  return Standard_True;
 }
 
 //=======================================================================
@@ -66,7 +170,13 @@ void BRepExtrema_ProximityValueTool::LoadShapeLists (const BRepExtrema_ShapeList
   myShapeList1 = theShapeList1;
   myShapeList2 = theShapeList2;
 
-  myIsDone = Standard_False;
+  myShape1 = theShapeList1 (0);
+  myIsInitS1 = getInfoForRefinement (myShape1, myShapeType1, myNbNodes1, myStep1);
+
+  myShape2 = theShapeList2 (0);
+  myIsInitS2 = getInfoForRefinement (myShape2, myShapeType2, myNbNodes2, myStep2);
+
+  MarkDirty();
 }
 
 //=======================================================================
@@ -79,7 +189,7 @@ void BRepExtrema_ProximityValueTool::SetNbSamplePoints(const Standard_Integer th
   myNbSamples1 = theSamples1;
   myNbSamples2 = theSamples2;
 
-  myIsDone = Standard_False;
+  MarkDirty();
 }
 
 //=======================================================================
@@ -88,6 +198,8 @@ void BRepExtrema_ProximityValueTool::SetNbSamplePoints(const Standard_Integer th
 //=======================================================================
 Standard_Real BRepExtrema_ProximityValueTool::computeProximityDist (const Handle(BRepExtrema_TriangleSet)& theSet1,
                                                                     const Standard_Integer theNbSamples1,
+                                                                    const BVH_Array3d& theAddVertices1,
+                                                                    const NCollection_Vector<ProxPnt_Status>& theAddStatus1,
                                                                     const Handle(BRepExtrema_TriangleSet)& theSet2,
                                                                     const BRepExtrema_ShapeList& theShapeList1,
                                                                     const BRepExtrema_ShapeList& theShapeList2,
@@ -96,7 +208,8 @@ Standard_Real BRepExtrema_ProximityValueTool::computeProximityDist (const Handle
                                                                     ProxPnt_Status& thePointStatus1,
                                                                     ProxPnt_Status& thePointStatus2) const
 {
-  BRepExtrema_ProximityDistTool aProxDistTool (theSet1, theNbSamples1, theSet2, theShapeList1, theShapeList2);
+  BRepExtrema_ProximityDistTool aProxDistTool (theSet1, theNbSamples1, theAddVertices1, theAddStatus1,
+                                               theSet2, theShapeList1, theShapeList2);
   aProxDistTool.Perform();
 
   if (!aProxDistTool.IsDone())
@@ -108,21 +221,311 @@ Standard_Real BRepExtrema_ProximityValueTool::computeProximityDist (const Handle
   return aProxDistTool.ProximityDistance();
 }
 
+//=======================================================================
+//function : getEdgeAdditionalVertices
+//purpose  : Gets additional vertices and their statuses on the edge with the input step
+//=======================================================================
+Standard_Boolean BRepExtrema_ProximityValueTool::getEdgeAdditionalVertices (
+  const TopoDS_Edge& theEdge,
+  const Standard_Real theStep,
+  BVH_Array3d& theAddVertices,
+  NCollection_Vector<ProxPnt_Status>& theAddStatuses)
+{
+  BRepAdaptor_Curve aBAC (theEdge);
+  
+  if (!aBAC.Is3DCurve() || theStep < Precision::Confusion())
+  {
+    return Standard_False;
+  }
+
+  Standard_Real aLen = GCPnts_AbscissaPoint::Length (aBAC);
+  Standard_Integer aNbSamplePoints = (Standard_Integer) (aLen / theStep) + 1;
+
+  GCPnts_QuasiUniformAbscissa aGCPnts (aBAC, Max (3, aNbSamplePoints));
+
+  if (!aGCPnts.IsDone())
+    return Standard_False;
+
+  Standard_Integer aNbNodes = aGCPnts.NbPoints();
+  for (Standard_Integer aVertIdx = 2; aVertIdx < aNbNodes; ++aVertIdx) //don't add extreme points
+  {
+    Standard_Real aPar = aGCPnts.Parameter (aVertIdx);
+    gp_Pnt aP = aBAC.Value (aPar);
+
+    theAddVertices.push_back (BVH_Vec3d (aP.X(), aP.Y(), aP.Z()));
+    theAddStatuses.Append (ProxPnt_Status::ProxPnt_Status_MIDDLE);
+  }
+
+  return Standard_True;
+}
+
+//=======================================================================
+//function : doRecurTrgSplit
+//purpose  : Splits the triangle into two ones recursively, halving the longest side
+//           untill the area of ​​the current triangle > input step
+//! @param theTrg points of the triangle to be splitted
+//! @param theEdgesStatus status of triangle edges - on the border or middle of the face
+//! @param theTol telerance used in search of coincidence points
+//! @param theStep minimum area of ​​the resulting triangle
+//! @param theAddVertices vertices obtained halving sides
+//! @param theAddStatuses status of obtained vertices - on the border or middle of the face,
+//! from triangulation of which the input triangle is
+//=======================================================================
+void BRepExtrema_ProximityValueTool::doRecurTrgSplit (const gp_Pnt (&theTrg)[3],
+                                                      const ProxPnt_Status (&theEdgesStatus)[3],
+                                                      const Standard_Real theTol,
+                                                      const Standard_Real theStep,
+                                                      BVH_Array3d& theAddVertices,
+                                                      NCollection_Vector<ProxPnt_Status>& theAddStatuses)
+{
+  gp_XYZ aTrgSide1 = theTrg[1].Coord() - theTrg[0].Coord();
+  gp_XYZ aTrgSide2 = theTrg[2].Coord() - theTrg[0].Coord();
+  Standard_Real aTrgArea = 0.5 * aTrgSide1.CrossMagnitude (aTrgSide2);
+
+  if (aTrgArea - theStep < Precision::SquareConfusion())
+    return;
+
+  Standard_Real aD[3] { theTrg[0].Distance (theTrg[1]),
+                        theTrg[1].Distance (theTrg[2]),
+                        theTrg[2].Distance (theTrg[0]) };
+  Standard_Integer aBisectedEdgeIdx = aD[0] > aD[1] ? (aD[0] > aD[2] ? 0 : 2) : (aD[1] > aD[2] ? 1 : 2);
+  gp_Pnt aCenterOfMaxSide (theTrg[aBisectedEdgeIdx].Coord());
+  aCenterOfMaxSide.BaryCenter (0.5, theTrg[(aBisectedEdgeIdx + 1) % 3], 0.5);
+
+  Bnd_Box aBox;
+  aBox.Add (aCenterOfMaxSide);
+  aBox.Enlarge (theTol);
+  myInspector.SetCurrent (aCenterOfMaxSide.Coord());
+  myCells.Inspect (aBox.CornerMin().XYZ(), aBox.CornerMax().XYZ(), myInspector);
+  
+  if (myInspector.IsNeedAdd()) //is point aCenterOfMaxSide unique
+  {
+    BVH_Vec3d aBisectingPnt (aCenterOfMaxSide.X(), aCenterOfMaxSide.Y(), aCenterOfMaxSide.Z());
+    theAddVertices.push_back (aBisectingPnt);
+    theAddStatuses.Append (theEdgesStatus[aBisectedEdgeIdx]);
+    myInspector.Add (aCenterOfMaxSide.Coord());
+    myCells.Add (static_cast<BRepExtrema_VertexInspector::Target>(theAddVertices.size()),
+                 aBox.CornerMin().XYZ(), aBox.CornerMax().XYZ());
+  }
+
+  gp_Pnt aTrg1[3] = { theTrg[0], theTrg[1], theTrg[2] };
+  gp_Pnt aTrg2[3] = { theTrg[0], theTrg[1], theTrg[2] };
+  ProxPnt_Status aEdgesStatus1[3] = { theEdgesStatus[0], theEdgesStatus[1], theEdgesStatus[2] };
+  ProxPnt_Status aEdgesStatus2[3] = { theEdgesStatus[0], theEdgesStatus[1], theEdgesStatus[2] };
+  switch (aBisectedEdgeIdx)
+  {
+  case 0:
+    aTrg1[0] = aTrg2[1] = aCenterOfMaxSide;
+    aEdgesStatus1[2] = aEdgesStatus2[1] = ProxPnt_Status::ProxPnt_Status_MIDDLE;
+    break;
+  case 1:
+    aTrg1[1] = aTrg2[2] = aCenterOfMaxSide;
+    aEdgesStatus1[0] = aEdgesStatus2[2] = ProxPnt_Status::ProxPnt_Status_MIDDLE;
+    break;
+  case 2:
+    aTrg1[2] = aTrg2[0] = aCenterOfMaxSide;
+    aEdgesStatus1[1] = aEdgesStatus2[0] = ProxPnt_Status::ProxPnt_Status_MIDDLE;
+    break;
+  }
+
+  doRecurTrgSplit (aTrg1, aEdgesStatus1, theTol, theStep, theAddVertices, theAddStatuses);
+  doRecurTrgSplit (aTrg2, aEdgesStatus2, theTol, theStep, theAddVertices, theAddStatuses);
+}
+
+static Standard_Real getModelRange (const TopLoc_Location& theLocation,
+                                    const Handle(Poly_Triangulation)& theTr)
+{
+  Bnd_Box aBox;
+  theTr->MinMax (aBox, theLocation.Transformation());
+  Standard_Real aXm = 0.0, aYm = 0.0, aZm = 0.0, aXM = 0.0, aYM = 0.0, aZM = 0.0;
+  aBox.Get (aXm, aYm, aZm, aXM, aYM, aZM);
+  Standard_Real aRange = aXM - aXm;
+  aRange = Max (aRange, aYM - aYm);
+  aRange = Max (aRange, aZM - aZm);
+
+  return aRange;
+}
+
+static void getNodesOfTrg (const Standard_Integer theTriIdx,
+                           const TopLoc_Location& theLocation,
+                           const Handle (Poly_Triangulation)& theTr,
+                           gp_Pnt (&theTrg)[3])
+{
+  Standard_Integer aVtxIdx1;
+  Standard_Integer aVtxIdx2;
+  Standard_Integer aVtxIdx3;
+
+  theTr->Triangle (theTriIdx).Get (aVtxIdx1, aVtxIdx2, aVtxIdx3);
+
+  gp_Pnt aVtx1 = theTr->Node (aVtxIdx1);
+  aVtx1.Transform (theLocation);
+  theTrg[0] = aVtx1;
+
+  gp_Pnt aVtx2 = theTr->Node (aVtxIdx2);
+  aVtx2.Transform (theLocation);
+  theTrg[1] = aVtx2;
+
+  gp_Pnt aVtx3 = theTr->Node (aVtxIdx3);
+  aVtx3.Transform (theLocation);
+  theTrg[2] = aVtx3;
+}
+
+// Gets status of triangle edges - on the border or middle of the face
+static void getEdgesStatus(const Standard_Integer theTriIdx,
+                           const Handle(Poly_Triangulation)& theTr,
+                           ProxPnt_Status (&theEdgesStatus1)[3])
+{
+  for (Standard_Integer j = 0; j < 3; j++)
+  {
+    Standard_Integer k = (j + 1) % 3;
+
+    if (BRepExtrema_ProximityDistTool::IsEdgeOnBorder (theTriIdx, j, k, theTr))
+    {
+      theEdgesStatus1[j] = ProxPnt_Status::ProxPnt_Status_BORDER;
+    }
+    else
+    {
+      theEdgesStatus1[j] = ProxPnt_Status::ProxPnt_Status_MIDDLE;
+    }
+  }
+}
+
+//=======================================================================
+//function : getFaceAdditionalVertices
+//purpose  : Gets additional vertices and their statuses on the face with the input step (triangle square)
+//=======================================================================
+Standard_Boolean BRepExtrema_ProximityValueTool::getFaceAdditionalVertices (
+  const TopoDS_Face& theFace,
+  const Standard_Real theStep,
+  BVH_Array3d& theAddVertices,
+  NCollection_Vector<ProxPnt_Status>& theAddStatuses)
+{
+  Standard_Real aTol = Precision::Confusion();
+
+  TopLoc_Location aLocation;
+  Handle(Poly_Triangulation) aTr = BRep_Tool::Triangulation (theFace, aLocation);
+
+  if (aTr.IsNull())
+  {
+    return Standard_False;
+  }
+
+  myCells.Reset (Max (aTol, getModelRange (aLocation, aTr) / IntegerLast()));
+
+  for (Standard_Integer aTriIdx = 1; aTriIdx <= aTr->NbTriangles(); ++aTriIdx)
+  {
+    gp_Pnt aTrg[3];
+    ProxPnt_Status aEdgesStatus[3];
+    getNodesOfTrg (aTriIdx, aLocation, aTr, aTrg);
+    getEdgesStatus (aTriIdx, aTr, aEdgesStatus);
+    doRecurTrgSplit (aTrg, aEdgesStatus, aTol, theStep, theAddVertices, theAddStatuses);
+  }
+
+  return Standard_True;
+}
+
+//=======================================================================
+//function : getShapesVertices
+//purpose  : Gets additional vertices on shapes with refining a coarser one if it's needed
+//=======================================================================
+Standard_Boolean BRepExtrema_ProximityValueTool::getShapesAdditionalVertices()
+{
+  // estimate the density of meshes of shapes to add points to a coarcer one
+  // target steps for refinement
+  Standard_Real aStep1 = myStep1;
+  Standard_Real aStep2 = myStep2;
+
+  if ((myShapeType1 == TopAbs_EDGE) && (myShapeType2 == TopAbs_EDGE))
+  {
+    if (myNbSamples1 > myNbNodes1) // 1st edge needs refinement
+    {
+      aStep1 = calcEdgeRefinementStep (TopoDS::Edge (myShape1), myNbSamples1);
+      myIsRefinementRequired1 = Standard_True;
+    }
+
+    if (myNbSamples2 > myNbNodes2) // 2nd edge needs refinement
+    {
+      aStep2 = calcEdgeRefinementStep (TopoDS::Edge (myShape2), myNbSamples2);
+      myIsRefinementRequired2 = Standard_True;
+    }
+
+    if (aStep1 / aStep2 > 2.) // 1st edge needs refinement
+    {
+      myIsRefinementRequired1 = Standard_True;
+      aStep1 = aStep2;
+    }
+    else if (aStep2 / aStep1 > 2.) // 2nd edge needs refinement
+    {
+      myIsRefinementRequired2 = Standard_True;
+      aStep2 = aStep1;
+    }
+
+    if (myIsRefinementRequired1)
+    {
+      if (!getEdgeAdditionalVertices (TopoDS::Edge (myShape1), aStep1, myAddVertices1, myAddStatus1))
+      {
+        return Standard_False;
+      }
+    }
+
+    if (myIsRefinementRequired2)
+    {
+      if (!getEdgeAdditionalVertices (TopoDS::Edge (myShape2), aStep2, myAddVertices2, myAddStatus2))
+      {
+        return Standard_False;
+      }
+    }
+  }
+  else if ((myShapeType1 == TopAbs_FACE) && (myShapeType2 == TopAbs_FACE))
+  {
+    if (aStep1 / aStep2 > 2) // 1st face needs refinement
+    {
+      myIsRefinementRequired1 = Standard_True;
+      aStep1 = myStep2;
+    }
+    else if (aStep2 / aStep1 > 2.) // 2nd face needs refinement
+    {
+      myIsRefinementRequired2 = Standard_True;
+      aStep2 = myStep1;
+    }
+
+    if (myIsRefinementRequired1)
+    {
+      return getFaceAdditionalVertices (TopoDS::Face (myShape1), aStep1, myAddVertices1, myAddStatus1);
+    }
+
+    if (myIsRefinementRequired2)
+    {
+      return getFaceAdditionalVertices (TopoDS::Face (myShape2), aStep2, myAddVertices2, myAddStatus2);
+    }
+  }
+
+  return Standard_True;
+}
+
 //=======================================================================
 //function : Perform
 //purpose  : Performs the computation of the proximity value
 //=======================================================================
 void BRepExtrema_ProximityValueTool::Perform (Standard_Real& theTolerance)
 {
-  myIsDone = Standard_False;
+  if (!myIsInitS1 || !myIsInitS2 || (myShapeType1 != myShapeType2))
+    return;
+
+  //get vertices on shapes with refining a coarser mesh if it's needed
+  if (!getShapesAdditionalVertices())
+    return;
 
   // max(min) dist from the 1st shape to the 2nd one
   BVH_Vec3d aP1_1, aP1_2;
   ProxPnt_Status aPointStatus1_1 = ProxPnt_Status::ProxPnt_Status_UNKNOWN;
   ProxPnt_Status aPointStatus1_2 = ProxPnt_Status::ProxPnt_Status_UNKNOWN;
 
-  Standard_Real aProximityDist1 = computeProximityDist (mySet1, myNbSamples1, mySet2, myShapeList1, myShapeList2,
-                                                        aP1_1, aP1_2, aPointStatus1_1, aPointStatus1_2);
+  Standard_Real aProximityDist1 = computeProximityDist (mySet1, myNbSamples1, myAddVertices1, myAddStatus1,
+                                                        mySet2,
+                                                        myShapeList1, myShapeList2,
+                                                        aP1_1, aP1_2,
+                                                        aPointStatus1_1, aPointStatus1_2);
 
   if (aProximityDist1 < 0.)
     return;
@@ -132,8 +535,11 @@ void BRepExtrema_ProximityValueTool::Perform (Standard_Real& theTolerance)
   ProxPnt_Status aPointStatus2_1 = ProxPnt_Status::ProxPnt_Status_UNKNOWN;
   ProxPnt_Status aPointStatus2_2 = ProxPnt_Status::ProxPnt_Status_UNKNOWN;
 
-  Standard_Real aProximityDist2 = computeProximityDist (mySet2, myNbSamples2, mySet1, myShapeList2, myShapeList1,
-                                                        aP2_2, aP2_1, aPointStatus2_2, aPointStatus2_1);
+  Standard_Real aProximityDist2 = computeProximityDist (mySet2, myNbSamples2, myAddVertices2, myAddStatus2,
+                                                        mySet1,
+                                                        myShapeList2, myShapeList1,
+                                                        aP2_2, aP2_1,
+                                                        aPointStatus2_2, aPointStatus2_1);
 
   if (aProximityDist2 < 0.)
     return;
@@ -159,3 +565,23 @@ void BRepExtrema_ProximityValueTool::Perform (Standard_Real& theTolerance)
   myIsDone = Standard_True;
   theTolerance = myDistance;
 }
+
+//=======================================================================
+//function : Inspect
+//purpose  : Used for selection and storage of coinciding nodes
+//=======================================================================
+NCollection_CellFilter_Action BRepExtrema_VertexInspector::Inspect (const Standard_Integer theTarget)
+{
+  myIsNeedAdd = Standard_True;
+
+  const gp_XYZ& aPnt = myPoints.Value (theTarget - 1);
+  Standard_Real aDx, aDy, aDz;
+  aDx = myCurrent.X() - aPnt.X();
+  aDy = myCurrent.Y() - aPnt.Y();
+  aDz = myCurrent.Z() - aPnt.Z();
+
+  if ((aDx * aDx <= myTol) && (aDy * aDy <= myTol) && (aDz * aDz <= myTol))
+    myIsNeedAdd = Standard_False;
+
+  return CellFilter_Keep;
+}

src/BRepExtrema/BRepExtrema_ProximityValueTool.hxx

@@ -1,4 +1,4 @@
-// Created on: 2022-08-08
+// Created on: 2022-08-08
 // Created by: Kseniya NOSULKO
 // Copyright (c) 2022 OPEN CASCADE SAS
 //
@@ -18,9 +18,67 @@
 
 #include <BRepExtrema_ProximityDistTool.hxx>
 #include <BRepExtrema_TriangleSet.hxx>
+#include <NCollection_CellFilter.hxx>
+#include <Precision.hxx>
+
+typedef NCollection_Vector<gp_XYZ> VectorOfPoint;
+
+//! Class BRepExtrema_VertexInspector
+//!   derived from NCollection_CellFilter_InspectorXYZ
+//!   This class define the Inspector interface for CellFilter algorithm,
+//!   working with gp_XYZ points in 3d space.
+//!   Used in search of coincidence points with a certain tolerance.
+class BRepExtrema_VertexInspector : public NCollection_CellFilter_InspectorXYZ
+{
+public:
+  typedef Standard_Integer Target;
+
+  //! Constructor; remembers the tolerance
+  BRepExtrema_VertexInspector()
+  : myTol (Precision::SquareConfusion()),
+    myIsNeedAdd (Standard_True)
+  {}
+
+  //! Keep the points used for comparison
+  void Add (const gp_XYZ& thePnt)
+  {
+    myPoints.Append (thePnt);
+  }
+
+  //! Set tolerance for comparison of point coordinates
+  void SetTol (const Standard_Real theTol)
+  {
+    myTol = theTol;
+  }
+
+  //! Set current point to search for coincidence
+  void SetCurrent (const gp_XYZ& theCurPnt)
+  {
+    myCurrent = theCurPnt;
+    myIsNeedAdd = Standard_True;
+  }
+
+  Standard_Boolean IsNeedAdd()
+  {
+    return myIsNeedAdd;
+  }
+
+  //! Implementation of inspection method
+  Standard_EXPORT NCollection_CellFilter_Action Inspect (const Standard_Integer theTarget);
+
+private:
+  Standard_Real myTol;
+  Standard_Boolean myIsNeedAdd;
+  VectorOfPoint myPoints;
+  gp_XYZ myCurrent;
+};
+
+typedef NCollection_CellFilter<BRepExtrema_VertexInspector> BRepExtrema_CellFilter;
+typedef typename BRepExtrema_ProximityDistTool::ProxPnt_Status ProxPnt_Status;
 
 //! Tool class for computation of the proximity value from one BVH
 //! primitive set to another, solving max(min) problem.
+//! Handles only edge/edge or face/face cases.
 //! This tool is not intended to be used independently, and is integrated
 //! in other classes, implementing algorithms based on shape tessellation
 //! (BRepExtrema_ShapeProximity and BRepExtrema_SelfIntersection).
@@ -29,8 +87,6 @@
 //! on the quality of input tessellation(s).
 class BRepExtrema_ProximityValueTool
 {
-public:
-  typedef typename BRepExtrema_ProximityDistTool::ProxPnt_Status ProxPnt_Status;
 
 public:
 
@@ -86,9 +142,17 @@ public:
 
 private:
 
+  //! Gets shape data for further refinement.
+  Standard_Boolean getInfoForRefinement (const TopoDS_Shape& theShapes,
+                                         TopAbs_ShapeEnum& theShapeType,
+                                         Standard_Integer& theNbNodes,
+                                         Standard_Real& theStep);
+
   //! Returns the computed proximity value from first BVH to another one.
   Standard_Real computeProximityDist (const Handle(BRepExtrema_TriangleSet)& theSet1,
                                       const Standard_Integer theNbSamples1,
+                                      const BVH_Array3d& theAddVertices1,
+                                      const NCollection_Vector<ProxPnt_Status>& theAddStatus1,
                                       const Handle(BRepExtrema_TriangleSet)& theSet2,
                                       const BRepExtrema_ShapeList& theShapeList1,
                                       const BRepExtrema_ShapeList& theShapeList2,
@@ -97,6 +161,29 @@ private:
                                       ProxPnt_Status& thePointStatus1,
                                       ProxPnt_Status& thePointStatus2) const;
 
+  //! Gets additional vertices on shapes with refining a coarser one if it's needed.
+  Standard_Boolean getShapesAdditionalVertices();
+
+  //! Gets additional vertices and their statuses on the edge with the input step.
+  Standard_Boolean getEdgeAdditionalVertices (const TopoDS_Edge& theEdge,
+                                              const Standard_Real theStep,
+                                              BVH_Array3d& theAddVertices,
+                                              NCollection_Vector<ProxPnt_Status>& theAddStatuses);
+
+  //! Gets additional vertices and their statuses on the face with the input step (triangle square).
+  Standard_Boolean getFaceAdditionalVertices (const TopoDS_Face& theFace,
+                                              const Standard_Real theStep,
+                                              BVH_Array3d& theAddVertices,
+                                              NCollection_Vector<ProxPnt_Status>& theAddStatuses);
+
+  //! Splits the triangle recursively, halving the longest side
+  //! to the area of ​​the current triangle > input step
+  void doRecurTrgSplit (const gp_Pnt (&theTrg)[3],
+                        const ProxPnt_Status (&theEdgesStatus)[3],
+                        const Standard_Real theTol,
+                        const Standard_Real theStep,
+                        BVH_Array3d& theAddVertices,
+                        NCollection_Vector<ProxPnt_Status>& theAddStatuses);
 private:
 
   //! Set of all mesh primitives of the 1st shape.
@@ -109,6 +196,35 @@ private:
   //! List of subshapes of the 2nd shape.
   BRepExtrema_ShapeList myShapeList2;
 
+  //! The 1st shape.
+  TopoDS_Shape myShape1;
+  //! The 2nd shape.
+  TopoDS_Shape myShape2;
+
+  BVH_Array3d myAddVertices1; //!< Additional vertices on the 1st shape if its mesh is coarser.
+  BVH_Array3d myAddVertices2; //!< Additional vertices on the 2nd shape if its mesh is coarser.
+
+  NCollection_Vector<ProxPnt_Status> myAddStatus1; //!< Status of additional vertices on the 1st shape.
+  NCollection_Vector<ProxPnt_Status> myAddStatus2; //!< Status of additional vertices on the 2nd shape.
+
+  Standard_Boolean myIsInitS1; //!< Is the 1st shape initialized?
+  Standard_Boolean myIsInitS2; //!< Is the 2nd shape initialized?
+
+  Standard_Boolean myIsRefinementRequired1; //!< Flag about the need to refine the 1st shape.
+  Standard_Boolean myIsRefinementRequired2; //!< Flag about the need to refine the 2nd shape.
+
+  Standard_Integer myNbNodes1; //!< Number of nodes in triangulation of the 1st shape.
+  Standard_Integer myNbNodes2; //!< Number of nodes in triangulation of the 2nd shape.
+
+  Standard_Real myStep1; //!< Step for getting vertices on the 1st shape.
+  Standard_Real myStep2; //!< Step for getting vertices on the 2nd shape.
+
+  BRepExtrema_CellFilter myCells;
+  BRepExtrema_VertexInspector myInspector;
+
+  TopAbs_ShapeEnum myShapeType1; //!< 1st shape type.
+  TopAbs_ShapeEnum myShapeType2; //!< 2nd shape type.
+
   Standard_Real myDistance;  //!< Distance
   Standard_Boolean myIsDone; //!< State of the algorithm
 

src/BRepExtrema/BRepExtrema_ShapeProximity.cxx

@@ -129,6 +129,7 @@ void BRepExtrema_ShapeProximity::Perform()
                                     myElementSet2);
     myProxValTool.LoadShapeLists (myShapeList1,
                                   myShapeList2);
+    myProxValTool.SetNbSamplePoints (myNbSamples1, myNbSamples2);
 
     myProxValTool.Perform (myTolerance);
     myProxValTool.ProximityPoints(myProxPoint1, myProxPoint2);

src/BRepExtrema/BRepExtrema_ShapeProximity.hxx

@@ -37,7 +37,8 @@
 //! on distance less than the given tolerance from each other.
 //!
 //! Second approach:
-//! Compute the proximity value between two shapes if the tolerance is not defined (Precision::Infinite()).
+//! Compute the proximity value between two shapes (handles only edge/edge or face/face cases)
+//! if the tolerance is not defined (Precision::Infinite()).
 //! In this case the proximity value is a minimal thickness of a layer containing both shapes.
 //!
 //! For the both approaches the high performance is achieved through the use of existing
@@ -46,8 +47,6 @@
 //! triangulation).
 class BRepExtrema_ShapeProximity
 {
-public:
-  typedef typename BRepExtrema_ProximityValueTool::ProxPnt_Status ProxPnt_Status;
 
 public:
 

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/BRepFill_TrimShellCorner.cxx

@@ -56,6 +56,7 @@
 #include <TopTools_MapOfShape.hxx>
 #include <TopTools_SequenceOfShape.hxx>
 #include <BRepExtrema_ExtCC.hxx>
+#include <ShapeFix_Edge.hxx>
 
 static TopoDS_Edge FindEdgeCloseToBisectorPlane(const TopoDS_Vertex& theVertex,
                                                 TopoDS_Compound&     theComp,
@@ -534,6 +535,26 @@ BRepFill_TrimShellCorner::MakeFacesNonSec(const Standard_Integer
 
     if(bHasNewEdge) {
       aNewEdge.Orientation(TopAbs_FORWARD);
+
+      // Refer to BrepFill_Sweep.cxx BuildEdge Construct an edge via an iso
+      gp_Pnt P1, P2;
+      Standard_Real p11, p12, p21, p22;
+      P1 = BRep_Tool::Pnt(TopExp::FirstVertex(TopoDS::Edge(aNewEdge)));
+      P2 = BRep_Tool::Pnt(TopExp::LastVertex(TopoDS::Edge(aNewEdge)));
+
+      TopoDS_Edge aERef = TopoDS::Edge(fit == 1 ? aE1 : aE2);
+      p11 = P1.Distance(BRep_Tool::Pnt(TopExp::FirstVertex(aERef)));
+      p22 = P2.Distance(BRep_Tool::Pnt(TopExp::LastVertex(aERef)));
+      p12 = P1.Distance(BRep_Tool::Pnt(TopExp::LastVertex(aERef)));
+      p21 = P2.Distance(BRep_Tool::Pnt(TopExp::FirstVertex(aERef)));
+
+      if (p11 > p12 && p22 > p21) {
+        aNewEdge.Reverse();
+      }
+
+      // for nonPlane surface, we should add pCurve
+      Handle(ShapeFix_Edge) sfe = new ShapeFix_Edge();
+      sfe->FixAddPCurve(aNewEdge, TopoDS::Face(aFace), Standard_False);
     }
 
     TopTools_ListOfShape aOrderedList;

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

@@ -802,7 +802,7 @@ static void GetEdgeTol(const TopoDS_Edge& theEdge,
     }
     if(temp > d2) d2 = temp;
   }
-  d2 = 1.5*sqrt(d2);
+  d2 = 1.05*sqrt(d2);
   theEdTol = d2;
 }
 
@@ -884,10 +884,6 @@ static void UpdShTol(const TopTools_DataMapOfShapeReal& theShToTol,
     case TopAbs_VERTEX: 
       {
         const Handle(BRep_TVertex)& aTV = *((Handle(BRep_TVertex)*)&aNsh.TShape());
-        //
-        if(aTV->Locked())
-          throw TopoDS_LockedShape("BRep_Builder::UpdateVertex");
-        //
         if (theVForceUpdate)
           aTV->Tolerance(aTol);
         else
@@ -965,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);
@@ -1709,8 +1708,8 @@ static void InternalUpdateTolerances(const TopoDS_Shape& theOldShape,
   for (iCur=1; iCur<=nbV; iCur++) {
     tol=0;
     const TopoDS_Vertex& V = TopoDS::Vertex(parents.FindKey(iCur));
-    Bnd_Box box;
-    box.Add(BRep_Tool::Pnt(V));
+    gp_Pnt aPV = BRep_Tool::Pnt(V);
+    Standard_Real aMaxDist = 0.;
     gp_Pnt p3d;
     for (lConx.Initialize(parents(iCur)); lConx.More(); lConx.Next()) {
       const TopoDS_Edge& E = TopoDS::Edge(lConx.Value());
@@ -1732,8 +1731,10 @@ static void InternalUpdateTolerances(const TopoDS_Shape& theOldShape,
           if (!C.IsNull()) { // edge non degenerated
             p3d = C->Value(par);
             p3d.Transform(L.Transformation());
-            box.Add(p3d);
-          }
+            Standard_Real aDist = p3d.SquareDistance(aPV);
+            if (aDist > aMaxDist)
+              aMaxDist = aDist;
+           }
         }
         else if (cr->IsCurveOnSurface()) {
           const Handle(Geom_Surface)& Su = cr->Surface();
@@ -1745,21 +1746,22 @@ static void InternalUpdateTolerances(const TopoDS_Shape& theOldShape,
           gp_Pnt2d p2d = PC->Value(par);
           p3d = Su->Value(p2d.X(),p2d.Y());
           p3d.Transform(L.Transformation());
-          box.Add(p3d);
+          Standard_Real aDist = p3d.SquareDistance(aPV);
+          if (aDist > aMaxDist)
+            aMaxDist = aDist;
           if (!PC2.IsNull()) {
             p2d = PC2->Value(par);
             p3d = Su->Value(p2d.X(),p2d.Y());
             p3d.Transform(L.Transformation());
-            box.Add(p3d);
+            aDist = p3d.SquareDistance(aPV);
+            if (aDist > aMaxDist)
+              aMaxDist = aDist;
           }
         }
         itcr.Next();
       }
     }
-    Standard_Real aXmin, aYmin, aZmin, aXmax, aYmax, aZmax;
-    box.Get(aXmin, aYmin, aZmin, aXmax, aYmax, aZmax);
-    aXmax -= aXmin; aYmax -= aYmin; aZmax -= aZmin;
-    tol = Max(tol,sqrt(aXmax*aXmax+aYmax*aYmax+aZmax*aZmax));
+    tol = Max(tol, sqrt(aMaxDist));
     tol += 2.*Epsilon(tol);
     //
     Standard_Real aVTol = BRep_Tool::Tolerance(V);

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

@@ -336,8 +336,10 @@ static BRepOffset_Error checkSinglePoint(const Standard_Real theUParam,
                                          const NCollection_Vector<gp_Pnt>& theBadPoints);
 
 //---------------------------------------------------------------------
-static void UpdateTolerance (      TopoDS_Shape&               myShape,
-                             const TopTools_IndexedMapOfShape& myFaces);
+static void UpdateTolerance (      TopoDS_Shape&               theShape,
+                             const TopTools_IndexedMapOfShape& theFaces,
+                             const TopoDS_Shape& theInitShape);
+
 static Standard_Real ComputeMaxDist(const gp_Pln& thePlane, 
                                     const Handle(Geom_Curve)& theCrv,
                                     const Standard_Real theFirst,
@@ -908,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;
@@ -1036,8 +1051,16 @@ void BRepOffset_MakeOffset::MakeOffsetShape(const Message_ProgressRange& theRang
   // MAJ Tolerance edge and Vertex
   // ----------------------------
   if (!myOffsetShape.IsNull()) {
-    UpdateTolerance (myOffsetShape,myFaces);
-    BRepLib::UpdateTolerances( myOffsetShape );
+    if (myThickening)
+    {
+      UpdateTolerance(myOffsetShape, myFaces, myShape);
+    }
+    else
+    {
+      TopoDS_Shape aDummy;
+      UpdateTolerance(myOffsetShape, myFaces, aDummy);
+    }
+    BRepLib::UpdateTolerances(myOffsetShape);
   }
 
   CorrectConicalFaces();
@@ -2950,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()))
       {
@@ -3165,13 +3218,38 @@ void BRepOffset_MakeOffset::MakeMissingWalls (const Message_ProgressRange& theRa
       } //if both edges are arcs of circles
       if (NewFace.IsNull())
       {
-        BRepLib_MakeFace MF(theWire, Standard_True); //Only plane
-        if (MF.Error() == BRepLib_FaceDone)
+        Standard_Real anEdgeTol = BRep_Tool::Tolerance(anEdge);
+        //Tolerances of input shape should not be increased by BRepLib_MakeFace
+        BRepLib_FindSurface aFindPlane(theWire, anEdgeTol, Standard_True); //only plane
+        IsPlanar = Standard_False;
+        if(aFindPlane.Found() && aFindPlane.ToleranceReached() <= anEdgeTol)
         {
-          NewFace = MF.Face();
-          IsPlanar = Standard_True;
+          Standard_Real f, l;
+          Handle(Geom_Curve) aGC = BRep_Tool::Curve(anEdge, f, l);
+          Handle(Geom_Plane) aPln = Handle(Geom_Plane)::DownCast(aFindPlane.Surface());
+          Standard_Real aMaxDist = ComputeMaxDist(aPln->Pln(), aGC, f, l);
+          if (aMaxDist <= anEdgeTol)
+          {
+            BRepLib_MakeFace MF(aPln->Pln(), theWire);
+            if (MF.IsDone())
+            {
+              NewFace = MF.Face();
+              TopoDS_Iterator anItE(theWire);
+              for (; anItE.More(); anItE.Next())
+              {
+                const TopoDS_Edge& anE = TopoDS::Edge(anItE.Value());
+                if (anE.IsSame(anEdge))
+                  continue;
+                aGC = BRep_Tool::Curve(anE, f, l);
+                aMaxDist = ComputeMaxDist(aPln->Pln(), aGC, f, l);
+                BB.UpdateEdge(anE, aMaxDist);
+              }
+              IsPlanar = Standard_True;
+            }
+          }
         }
-        else //Extrusion (by thrusections)
+        //
+        if(!IsPlanar) //Extrusion (by thrusections)
         {
           Handle(Geom_Curve) EdgeCurve = BRep_Tool::Curve(anEdge, fpar, lpar);
           Handle(Geom_TrimmedCurve) TrEdgeCurve =
@@ -3185,7 +3263,6 @@ void BRepOffset_MakeOffset::MakeMissingWalls (const Message_ProgressRange& theRa
           ThrusecGenerator.AddCurve( TrOffsetCurve );
           ThrusecGenerator.Perform( Precision::PConfusion() );
           theSurf = ThrusecGenerator.Surface();
-          //theSurf = new Geom_SurfaceOfLinearExtrusion( TrOffsetCurve, OffsetDir );
           Standard_Real Uf, Ul, Vf, Vl;
           theSurf->Bounds(Uf, Ul, Vf, Vl);
           TopLoc_Location Loc;
@@ -3272,8 +3349,14 @@ void BRepOffset_MakeOffset::MakeMissingWalls (const Message_ProgressRange& theRa
           BB.Range( anE3, FirstPar, LastPar );
         }
       }
-      BRepLib::SameParameter(NewFace);
-      BRepTools::Update(NewFace);
+
+      if (!IsPlanar)
+      {
+        // For planar faces these operations are useless,
+        // because there are no curves on surface
+        BRepLib::SameParameter(NewFace);
+        BRepTools::Update(NewFace);
+      }
       //Check orientation
       TopAbs_Orientation anOr = OrientationOfEdgeInFace(anEdge, aFaceOfEdge);
       TopAbs_Orientation OrInNewFace = OrientationOfEdgeInFace(anEdge, NewFace);
@@ -3781,6 +3864,7 @@ void BRepOffset_MakeOffset::EncodeRegularity ()
 #endif
 }
 
+
 //=======================================================================
 //function : ComputeMaxDist
 //purpose  : 
@@ -3807,13 +3891,15 @@ Standard_Real ComputeMaxDist(const gp_Pln& thePlane,
   }
   return sqrt(aMaxDist)*1.05;
 }
+
 //=======================================================================
-//function : UpDateTolerance
+//function : UpdateTolerance
 //purpose  : 
 //=======================================================================
 
 void UpdateTolerance (TopoDS_Shape& S,
-                      const TopTools_IndexedMapOfShape& Faces)
+                      const TopTools_IndexedMapOfShape& Faces,
+                      const TopoDS_Shape& theInitShape)
 {
   BRep_Builder B;
   TopTools_MapOfShape View;
@@ -3829,12 +3915,31 @@ void UpdateTolerance (TopoDS_Shape& S,
     }
   }
   
-  Standard_Real Tol;
-  TopExp_Explorer ExpF;
-  for (ExpF.Init(S, TopAbs_FACE); ExpF.More(); ExpF.Next())
+  // The edges of initial shape are  not modified
+  TopTools_MapOfShape aMapInitF;
+  if (!theInitShape.IsNull())
   {
-    const TopoDS_Shape& F = ExpF.Current();
-    if (Faces.Contains(F))
+    TopExp_Explorer anExpF(theInitShape, TopAbs_FACE);
+    for (; anExpF.More(); anExpF.Next()) {
+      aMapInitF.Add(anExpF.Current());
+      TopExp_Explorer anExpE;
+      for (anExpE.Init(anExpF.Current(), TopAbs_EDGE); anExpE.More(); anExpE.Next()) {
+        View.Add(anExpE.Current());
+        TopoDS_Iterator anItV(anExpE.Current());
+        for (; anItV.More(); anItV.Next())
+        {
+          View.Add(anItV.Value());
+        }
+      }
+    }
+  }
+  
+  Standard_Real Tol;
+  TopExp_Explorer anExpF(S, TopAbs_FACE);
+  for (; anExpF.More(); anExpF.Next())
+  {
+    const TopoDS_Shape& F = anExpF.Current();
+    if (Faces.Contains(F) || aMapInitF.Contains(F))
     {
       continue;
     }
@@ -3843,6 +3948,7 @@ void UpdateTolerance (TopoDS_Shape& S,
     for (Exp.Init(F, TopAbs_EDGE); Exp.More(); Exp.Next()) {
       TopoDS_Edge E = TopoDS::Edge(Exp.Current());
       Standard_Boolean isUpdated = Standard_False;
+      Standard_Real aCurrTol = BRep_Tool::Tolerance(E);
       if (aBAS.GetType() == GeomAbs_Plane)
       {
         //Edge does not seem to have pcurve on plane,
@@ -3850,17 +3956,22 @@ void UpdateTolerance (TopoDS_Shape& S,
         Standard_Real aFirst, aLast;
         Handle(Geom_Curve) aCrv = BRep_Tool::Curve(E, aFirst, aLast);
         Standard_Real aMaxDist = ComputeMaxDist(aBAS.Plane(), aCrv, aFirst, aLast);
-        E.Locked (Standard_False);
-        B.UpdateEdge(E, aMaxDist);
-        isUpdated = Standard_True;
+        if (aMaxDist > aCurrTol)
+        {
+          B.UpdateEdge(E, aMaxDist);
+          isUpdated = Standard_True;
+        }
       }
       if (View.Add(E))
       {
-
+        E.Locked(Standard_False);       
         BRepCheck_Edge EdgeCorrector(E);
         Tol = EdgeCorrector.Tolerance();
-        B.UpdateEdge(E, Tol);
-        isUpdated = Standard_True;
+        if (Tol > aCurrTol)
+        {
+          B.UpdateEdge(E, Tol);
+          isUpdated = Standard_True;
+        }
       }
       if (isUpdated)
       {
@@ -3869,11 +3980,11 @@ void UpdateTolerance (TopoDS_Shape& S,
         TopExp::Vertices(E, V[0], V[1]);
 
         for (Standard_Integer i = 0; i <= 1; i++) {
+          V[i].Locked(Standard_False);
           if (View.Add(V[i])) {
             Handle(BRep_TVertex) TV = Handle(BRep_TVertex)::DownCast(V[i].TShape());
             TV->Tolerance(0.);
             BRepCheck_Vertex VertexCorrector(V[i]);
-            V[i].Locked (Standard_False);
             B.UpdateVertex(V[i], VertexCorrector.Tolerance());
             // use the occasion to clean the vertices.
             (TV->ChangePoints()).Clear();
@@ -4953,6 +5064,53 @@ Standard_Boolean BRepOffset_MakeOffset::IsPlanar()
       if (aPlanarityChecker.IsPlanar())
       {
         gp_Pln aPln = aPlanarityChecker.Plan();
+        Standard_Real u1, u2, v1, v2, um, vm;
+        aSurf->Bounds(u1, u2, v1, v2);
+        Standard_Boolean isInf1 = Precision::IsInfinite(u1), isInf2 = Precision::IsInfinite(u2);
+        if (!isInf1 && !isInf2)
+        {
+          um = (u1 + u2) / 2.;
+        }
+        else if(isInf1 && !isInf2)
+        {
+          um = u2 - 1.;
+        }
+        else if(!isInf1 && isInf2)
+        {
+          um = u1 + 1.;
+        }
+        else //isInf1 && isInf2
+        {
+          um = 0.;
+        }
+        isInf1 = Precision::IsInfinite(v1), isInf2 = Precision::IsInfinite(v2);
+        if (!isInf1 && !isInf2)
+        {
+          vm = (v1 + v2) / 2.;
+        }
+        else if (isInf1 && !isInf2)
+        {
+          vm = v2 - 1.;
+        }
+        else if(!isInf1 && isInf2)
+        {
+          vm = v1 + 1.;
+        }
+        else //isInf1 && isInf2
+        {
+          vm = 0.;
+        }
+        gp_Pnt aP;
+        gp_Vec aD1, aD2;
+        aBAS.D1(um, vm, aP, aD1, aD2);
+        gp_Vec aNorm = aD1.Crossed(aD2);
+        gp_Dir aPlnNorm = aPln.Position().Direction();
+        if (aNorm.Dot(aPlnNorm) < 0.)
+        {
+          aPlnNorm.Reverse();
+          gp_Ax1 anAx(aPln.Position().Location(), aPlnNorm);
+          aPln.SetAxis(anAx);
+        }
         Handle(Geom_Plane) aPlane = new Geom_Plane(aPln);
         TopoDS_Face aPlanarFace;
         aBB.MakeFace(aPlanarFace, aPlane, aTolForFace);

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/BSplCLib/BSplCLib.cxx

@@ -4234,6 +4234,133 @@ void BSplCLib::Resolution(      Standard_Real&        Poles,
     UTolerance = Tolerance3D / RealSmall();
 }
 
+//=======================================================================
+// function : Intervals 
+// purpose  : 
+//=======================================================================
+Standard_Integer BSplCLib::Intervals (const TColStd_Array1OfReal& theKnots,
+                                      const TColStd_Array1OfInteger& theMults,
+                                      Standard_Integer theDegree,
+                                      Standard_Boolean isPeriodic,
+                                      Standard_Integer theContinuity,
+                                      Standard_Real theFirst,
+                                      Standard_Real theLast,
+                                      Standard_Real theTolerance,
+                                      TColStd_Array1OfReal* theIntervals) 
+{
+  // remove all knots with multiplicity less or equal than (degree - continuity) except first and last
+  Standard_Integer aFirstIndex = isPeriodic ? 1 : FirstUKnotIndex (theDegree, theMults);
+  Standard_Integer aLastIndex = isPeriodic ? theKnots.Size() : LastUKnotIndex (theDegree, theMults);
+  TColStd_Array1OfReal aNewKnots (1, aLastIndex - aFirstIndex + 1);
+  Standard_Integer aNbNewKnots = 0;
+  for (Standard_Integer anIndex = aFirstIndex; anIndex <= aLastIndex; anIndex++)
+  {
+    if (theMults(anIndex) > (theDegree - theContinuity) ||
+    anIndex == aFirstIndex ||
+    anIndex == aLastIndex)
+    {
+      aNbNewKnots++;
+      aNewKnots(aNbNewKnots) = theKnots[anIndex];
+    }
+  }
+  aNewKnots.Resize (1, aNbNewKnots, Standard_True);
+
+  // the range boundaries 
+  Standard_Real aCurFirst = theFirst;
+  Standard_Real aCurLast = theLast;
+  Standard_Real aPeriod = 0.0;
+  Standard_Integer aFirstPeriod = 0;
+  Standard_Integer aLastPeriod = 0;
+  // move boundaries into period
+  if (isPeriodic)
+  {
+    Standard_Real aLower = theKnots.First();
+    Standard_Real anUpper = theKnots.Last();
+    aPeriod = anUpper - aLower;
+    
+    while (aCurFirst < aLower)
+    {
+      aCurFirst += aPeriod;
+      aFirstPeriod--;
+    }
+    while (aCurLast < aLower)
+    {
+      aCurLast += aPeriod;
+      aLastPeriod--;
+    }
+    while (aCurFirst >= anUpper)
+    {
+      aCurFirst -= aPeriod;
+      aFirstPeriod += 1;
+    }
+    while (aCurLast >= anUpper)
+    {
+      aCurLast -= aPeriod;
+      aLastPeriod += 1;
+    }
+  }
+  // locate the left and nearest knot for boundaries
+  Standard_Integer anIndex1 = 0;
+  Standard_Integer anIndex2 = 0;
+  Standard_Real aDummyDouble;
+  // we use version of LocateParameter that doesn't need multiplicities
+  LocateParameter(theDegree, aNewKnots, TColStd_Array1OfInteger(), aCurFirst, Standard_False, 1, aNbNewKnots, anIndex1, aDummyDouble);
+  LocateParameter(theDegree, aNewKnots, TColStd_Array1OfInteger(), aCurLast, Standard_False, 1, aNbNewKnots, anIndex2, aDummyDouble);
+  // the case when the beginning of the range coincides with the next knot
+  if (anIndex1 < aNbNewKnots && Abs(aNewKnots[anIndex1 + 1] - aCurFirst) < theTolerance)
+  {
+    anIndex1 += 1;
+  }
+  // the case when the ending of the range coincides with the current knot
+  if (aNbNewKnots && Abs(aNewKnots[anIndex2] - aCurLast) < theTolerance)
+  {
+    anIndex2 -= 1;
+  }
+  Standard_Integer aNbIntervals = anIndex2 - anIndex1 + 1 + (aLastPeriod - aFirstPeriod) * (aNbNewKnots - 1);
+  
+  // fill the interval array
+  if (theIntervals)
+  {
+    theIntervals->Resize (1, aNbIntervals + 1, Standard_False);
+    if (isPeriodic && aLastPeriod != aFirstPeriod)
+    {
+      Standard_Integer anIndex = 1;
+      // part from the begging of range to the end of the first period
+      for (Standard_Integer i = anIndex1; i < aNewKnots.Size(); i++, anIndex++)
+      {
+        theIntervals->ChangeValue(anIndex) = aNewKnots[i] + aFirstPeriod * aPeriod;
+      }
+      // full periods
+      for (Standard_Integer aPeriodNum = aFirstPeriod + 1; aPeriodNum < aLastPeriod; aPeriodNum++)
+      {
+        for (Standard_Integer i = 1; i < aNewKnots.Size(); i++, anIndex++)
+        {
+          theIntervals->ChangeValue(anIndex) = aNewKnots[i] + aPeriodNum * aPeriod;
+        }
+      }
+      // part from the begging of the last period to the end of range
+      for (Standard_Integer i = 1; i <= anIndex2; i++, anIndex++)
+      {
+        theIntervals->ChangeValue(anIndex) = aNewKnots[i] + aLastPeriod * aPeriod;
+      }
+    }
+    else
+    {
+      Standard_Integer anIndex = 1;
+      for (Standard_Integer i = anIndex1; i <= anIndex2; i++, anIndex++)
+      {
+        theIntervals->ChangeValue(anIndex) = aNewKnots[i] + aFirstPeriod * aPeriod;
+      }
+    }
+    // update the first position (the begging of range doesn't coincide with the knot at anIndex1 in general)
+    theIntervals->ChangeValue(1) = theFirst;
+    // write the ending of the range (we didn't write it at all)
+    theIntervals->ChangeValue(aNbIntervals + 1) = theLast;
+  }
+  
+  return aNbIntervals;
+}
+
 //=======================================================================
 // function: FlatBezierKnots
 // purpose :

src/BSplCLib/BSplCLib.hxx

@@ -1456,8 +1456,26 @@ public:
   //! we have |f (u1) - f (u0)| < Tolerance3D
   Standard_EXPORT static void Resolution (const TColgp_Array1OfPnt2d& Poles, const TColStd_Array1OfReal* Weights, const Standard_Integer NumPoles, const TColStd_Array1OfReal& FlatKnots, const Standard_Integer Degree, const Standard_Real Tolerance3D, Standard_Real& UTolerance);
 
-
-
+  //! Splits the given range to BSpline intervals of given continuity
+  //! @param[in] theKnots the knots of BSpline
+  //! @param[in] theMults the knots' multiplicities
+  //! @param[in] theDegree the degree of BSpline
+  //! @param[in] isPeriodic the periodicity of BSpline
+  //! @param[in] theContinuity the target interval's continuity 
+  //! @param[in] theFirst the begin of the target range
+  //! @param[in] theLast the end of the target range
+  //! @param[in] theTolerance the tolerance
+  //! @param[in,out] theIntervals the array to store intervals if isn't nullptr
+  //! @return the number of intervals
+  Standard_EXPORT static Standard_Integer Intervals (const TColStd_Array1OfReal& theKnots,
+                                                     const TColStd_Array1OfInteger& theMults,
+                                                     Standard_Integer theDegree,
+                                                     Standard_Boolean isPeriodic,
+                                                     Standard_Integer theContinuity,
+                                                     Standard_Real theFirst,
+                                                     Standard_Real theLast,
+                                                     Standard_Real theTolerance,
+                                                     TColStd_Array1OfReal* theIntervals);
 
 protected:
 

src/BSplCLib/BSplCLib_2.cxx

@@ -1157,82 +1157,97 @@ void BSplCLib::MergeBSplineKnots
   index,
   num_knots ;
   if (StartValue < EndValue - Tolerance) {
-    TColStd_Array1OfReal knots1(1,Knots1.Length()) ;
-    TColStd_Array1OfReal knots2(1,Knots2.Length()) ;
-    degree = Degree1 + Degree2 ;
-    index = 1 ;
+    TColStd_Array1OfReal knots1(1, Knots1.Length());
+    TColStd_Array1OfReal knots2(1, Knots2.Length());
+    degree = Degree1 + Degree2;
+    index = 1;
 
-    for (ii = Knots1.Lower() ; ii <= Knots1.Upper() ; ii++) {
-      knots1(index) = Knots1(ii) ;
-      index += 1 ;
+    for (ii = Knots1.Lower(); ii <= Knots1.Upper(); ii++) {
+      knots1(index) = Knots1(ii);
+      index += 1;
     }
-    index = 1 ;
+    index = 1;
 
-    for (ii = Knots2.Lower() ; ii <= Knots2.Upper() ; ii++) {
-      knots2(index) = Knots2(ii) ;
-      index += 1 ;
+    for (ii = Knots2.Lower(); ii <= Knots2.Upper(); ii++) {
+      knots2(index) = Knots2(ii);
+      index += 1;
     }
     BSplCLib::Reparametrize(StartValue,
-			    EndValue,
-			    knots1) ;
-    
-    BSplCLib::Reparametrize(StartValue,
-			    EndValue,
-			    knots2) ;
-    num_knots = 0 ;
-    jj =  1 ;
+      EndValue,
+      knots1);
 
-    for (ii = 1 ; ii <= knots1.Length() ; ii++) {
+    BSplCLib::Reparametrize(StartValue,
+      EndValue,
+      knots2);
+    num_knots = 0;
+    jj = 1;
+
+    for (ii = 1; ii <= knots1.Length(); ii++) {
 
       while (jj <= knots2.Length() && knots2(jj) <= knots1(ii) - Tolerance) {
-	jj += 1 ;
-	num_knots += 1 ;
+        jj += 1;
+        num_knots += 1;
       }
 
       while (jj <= knots2.Length() && knots2(jj) <= knots1(ii) + Tolerance) {
-	jj += 1 ;
+        jj += 1;
       }
-      num_knots += 1 ;
+      num_knots += 1;
     }
-    NewKnots = 
-      new TColStd_HArray1OfReal(1,num_knots) ;
+    NewKnots =
+      new TColStd_HArray1OfReal(1, num_knots);
     NewMults =
-      new TColStd_HArray1OfInteger(1,num_knots) ;
-    num_knots = 1 ;
-    jj = 1 ;
+      new TColStd_HArray1OfInteger(1, num_knots);
+    num_knots = 1;
+    jj = 1;
 
-    for (ii = 1 ; ii <= knots1.Length() ; ii++) {
+    for (ii = 1; ii <= knots1.Length(); ii++) {
 
       while (jj <= knots2.Length() && knots2(jj) <= knots1(ii) - Tolerance) {
-	NewKnots->ChangeArray1()(num_knots) = knots2(jj) ;
-        NewMults->ChangeArray1()(num_knots) = Mults2(jj) + Degree1 ;
-	jj += 1 ;
-	num_knots += 1 ;
+        NewKnots->ChangeArray1()(num_knots) = knots2(jj);
+        NewMults->ChangeArray1()(num_knots) = Mults2(jj) + Degree1;
+        jj += 1;
+        num_knots += 1;
       }
-      set_mults_flag = 0 ;
+      set_mults_flag = 0;
 
       while (jj <= knots2.Length() && knots2(jj) <= knots1(ii) + Tolerance) {
-	continuity = Min(Degree1 - Mults1(ii), Degree2 - Mults2(jj)) ;
-        set_mults_flag = 1 ;
-	NewMults->ChangeArray1()(num_knots) = degree - continuity ;
-	jj += 1 ;
+        continuity = Min(Degree1 - Mults1(ii), Degree2 - Mults2(jj));
+        set_mults_flag = 1;
+        NewMults->ChangeArray1()(num_knots) = degree - continuity;
+        jj += 1;
       }
 
-      NewKnots->ChangeArray1()(num_knots) = knots1(ii) ;
-      if (! set_mults_flag) {
-	NewMults->ChangeArray1()(num_knots) = Mults1(ii) + Degree2 ;
+      NewKnots->ChangeArray1()(num_knots) = knots1(ii);
+      if (!set_mults_flag) {
+        NewMults->ChangeArray1()(num_knots) = Mults1(ii) + Degree2;
       }
-      num_knots += 1 ;
+      num_knots += 1;
     }
-    num_knots -= 1 ;
-    NewMults->ChangeArray1()(1) = degree + 1 ;
-    NewMults->ChangeArray1()(num_knots) = degree + 1 ;
-    index = 0 ;
+    num_knots -= 1;
+    NewMults->ChangeArray1()(1) = degree + 1;
+    NewMults->ChangeArray1()(num_knots) = degree + 1;
+    index = 0;
 
-    for (ii = 1 ; ii <= num_knots ; ii++) {
-      index += NewMults->Value(ii) ;
+    for (ii = 1; ii <= num_knots; ii++) {
+      index += NewMults->Value(ii);
     }
-    NumPoles = index  - degree - 1  ;
+    NumPoles = index - degree - 1;
+  }
+  else
+  {
+    degree = Degree1 + Degree2;
+    num_knots = 2;
+    NewKnots =
+      new TColStd_HArray1OfReal(1, num_knots);
+    NewKnots->ChangeArray1()(1) = StartValue;
+    NewKnots->ChangeArray1()(num_knots) = EndValue;
+
+    NewMults = 
+      new TColStd_HArray1OfInteger(1, num_knots);
+    NewMults->ChangeArray1()(1) = degree + 1;
+    NewMults->ChangeArray1()(num_knots) = degree + 1;
+    NumPoles = BSplCLib::NbPoles(degree, Standard_False, NewMults->Array1());
   }
 }
       

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/DrawTrSurf/DrawTrSurf_Debug.cxx

@@ -27,7 +27,7 @@
 // intended for use from debugger prompt (Command Window in Visual Studio)
 
 //! Save geometric object identified by pointer to handle
-const char* DrawTrSurf_Set (const char* theNameStr, void* theHandlePtr)
+Standard_EXPORT const char* DrawTrSurf_Set (const char* theNameStr, void* theHandlePtr)
 {
   if (theNameStr == 0 || theHandlePtr == 0)
   {
@@ -57,7 +57,7 @@ const char* DrawTrSurf_Set (const char* theNameStr, void* theHandlePtr)
 }
 
 //! Set point to DRAW variable
-const char* DrawTrSurf_SetPnt (const char* theNameStr, void* thePntPtr)
+Standard_EXPORT const char* DrawTrSurf_SetPnt (const char* theNameStr, void* thePntPtr)
 {
   if (theNameStr == 0 || thePntPtr == 0)
   {
@@ -77,7 +77,7 @@ const char* DrawTrSurf_SetPnt (const char* theNameStr, void* thePntPtr)
 }
 
 //! Set 2d point to DRAW variable
-const char* DrawTrSurf_SetPnt2d (const char* theNameStr, void* thePnt2dPtr)
+Standard_EXPORT const char* DrawTrSurf_SetPnt2d (const char* theNameStr, void* thePnt2dPtr)
 {
   if (theNameStr == 0 || thePnt2dPtr == 0)
   {
@@ -102,17 +102,17 @@ const char* DrawTrSurf_SetPnt2d (const char* theNameStr, void* thePnt2dPtr)
 // work with them (DBX could, on SUN Solaris).
 #ifndef _MSC_VER
 
-const char* DrawTrSurf_Set (const char* name, const Handle(Standard_Transient)& G)
+Standard_EXPORT const char* DrawTrSurf_Set (const char* name, const Handle(Standard_Transient)& G)
 {
   return DrawTrSurf_Set (name, (void*)&G);
 }
 
-const char* DrawTrSurf_Set (const char* theName, const gp_Pnt& thePnt)
+Standard_EXPORT const char* DrawTrSurf_Set (const char* theName, const gp_Pnt& thePnt)
 {
   return DrawTrSurf_SetPnt (theName, (void*)&thePnt);
 }
 
-const char* DrawTrSurf_Set (const char* theName, const gp_Pnt2d& thePnt2d)
+Standard_EXPORT const char* DrawTrSurf_Set (const char* theName, const gp_Pnt2d& thePnt2d)
 {
   return DrawTrSurf_SetPnt2d (theName, (void*)&thePnt2d);
 }

src/ExpToCasExe/EXTERNLIB

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

src/Extrema/Extrema_ExtCC.cxx

@@ -674,7 +674,10 @@ void Extrema_ExtCC::PrepareParallelResult(const Standard_Real theUt11,
         Extrema_ExtPElC ExtPCir(aPCirc2,
                                 Extrema_CurveTool::Circle (*myC[0]),
                                 Precision::Confusion(), theUt11, theUt12);
-
+        if (ExtPCir.NbExt() < 1)
+        {
+          continue;
+        }
         Standard_Real aMinSqD = ExtPCir.SquareDistance(1);
         for (Standard_Integer anExtID = 2; anExtID <= ExtPCir.NbExt(); anExtID++)
         {

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/Geom2dAdaptor/Geom2dAdaptor_Curve.cxx

@@ -58,65 +58,6 @@ static const Standard_Real PosTol = Precision::PConfusion() / 2;
 
 IMPLEMENT_STANDARD_RTTIEXT(Geom2dAdaptor_Curve, Adaptor2d_Curve2d)
 
-static void DefinFPeriod(const Standard_Real theLower,
-  const Standard_Real theUpper,
-  const Standard_Real theEps,
-  const Standard_Real thePeriod,
-  Standard_Real &theCurFirst,
-  Standard_Integer &theFPer);
-
-static void DefinLPeriod(const Standard_Real theLower,
-  const Standard_Real theUpper,
-  const Standard_Real theEps,
-  const Standard_Real thePeriod,
-  Standard_Real &theCurLast,
-  Standard_Integer &theLPer);
-
-static Standard_Integer LocalNbIntervals(const TColStd_Array1OfReal& theTK,
-  const TColStd_Array1OfInteger& theTM,
-  const TColStd_Array1OfInteger& theInter,
-  const Standard_Integer theCurDegree,
-  const Standard_Integer theNb,
-  const Standard_Integer theNbInt,
-  const Standard_Real theFirst,
-  const Standard_Real theLast,
-  const Standard_Real theEps,
-  const Standard_Boolean thePeriodicCur,
-  Standard_Integer theNbIntervals,
-  Standard_Real theLower = 0,
-  Standard_Real thePeriod = 0,
-  Standard_Integer theIndex1 = 0,
-  Standard_Integer theIndex2 = 0);
-
-static void WriteIntervals(const TColStd_Array1OfReal &theTK,
-  const TColStd_Array1OfInteger &theInter,
-  const Standard_Integer theNbInt,
-  const Standard_Integer theIndex1,
-  const Standard_Integer theIndex2,
-  const Standard_Real theCurPeriod,
-  const Standard_Boolean theFlagForFirst,
-  TColStd_Array1OfReal &theT,
-  TColStd_Array1OfInteger &theFinalIntervals,
-  Standard_Integer &theNbIntervals,
-  Standard_Integer &theCurInt);
-
-static void SpreadInt(const TColStd_Array1OfReal &theTK,
-  const TColStd_Array1OfInteger &theTM,
-  const TColStd_Array1OfInteger &theInter,
-  const Standard_Integer theCurDegree,
-  const Standard_Integer theNb,
-  const Standard_Integer theFPer,
-  const Standard_Integer theLPer,
-  const Standard_Integer theNbInt,
-  const Standard_Real theLower,
-  const Standard_Real theFirst,
-  const Standard_Real theLast,
-  const Standard_Real thePeriod,
-  const Standard_Real theLastParam,
-  const Standard_Real theEps,
-  TColStd_Array1OfReal &theT,
-  Standard_Integer &theNbIntervals);
-
 //=======================================================================
 //function : ShallowCopy
 //purpose  : 
@@ -354,158 +295,6 @@ GeomAbs_Shape Geom2dAdaptor_Curve::Continuity() const
   }
 }
 
-//=======================================================================
-//function : DefinFPeriod
-//purpose  :
-//=======================================================================
-
-void DefinFPeriod(const Standard_Real theLower,
-  const Standard_Real theUpper,
-  const Standard_Real theEps,
-  const Standard_Real thePeriod,
-  Standard_Real &theCurFirst,
-  Standard_Integer &theFPer)
-{
-  if (theCurFirst >= theLower)
-  {
-    while (theCurFirst >= theUpper)
-    {
-      theCurFirst = theCurFirst - thePeriod;
-      theFPer++;
-    }
-    if (Abs(theUpper - theCurFirst) <= theEps)
-    {
-      theFPer++;
-      theCurFirst = theLower;
-    }
-  }
-  else
-  {
-    while (theCurFirst < theLower)
-    {
-      theCurFirst = theCurFirst + thePeriod;
-      if (Abs(theLower - theCurFirst) > theEps)
-      {
-        theFPer--;
-      }
-    }
-
-    if (Abs(theUpper - theCurFirst) <= theEps)
-    {
-      theCurFirst = theLower;
-    }
-  }
-}
-
-//=======================================================================
-//function : DefinLPeriod
-//purpose  :
-//=======================================================================
-
-void DefinLPeriod(const Standard_Real theLower,
-  const Standard_Real theUpper,
-  const Standard_Real theEps,
-  const Standard_Real thePeriod,
-  Standard_Real &theCurLast,
-  Standard_Integer &theLPer)
-{
-  if (theCurLast >= theLower)
-  {
-    if ((theCurLast >= theUpper) && (Abs(theCurLast - theUpper) <= theEps))
-    {
-      theCurLast = theUpper;
-    }
-    else
-    {
-      while (theCurLast >= theUpper)
-      {
-        theCurLast = theCurLast - thePeriod;
-        theLPer++;
-      }
-      if (Abs(theUpper - theCurLast) <= theEps)
-      {
-        theCurLast = theLower;
-      }
-    }
-  }
-  else
-  {
-    while (theCurLast < theLower)
-    {
-      theCurLast = theCurLast + thePeriod;
-      if (Abs(theLower - theCurLast) > theEps)
-      {
-        theLPer--;
-      }
-    }
-    if (Abs(theUpper - theCurLast) <= theEps)
-    {
-      theCurLast = theLower;
-    }
-  }
-}
-
-//=======================================================================
-//function : LocalNbIntervals
-//purpose  :
-//=======================================================================
-
-Standard_Integer LocalNbIntervals(const TColStd_Array1OfReal& theTK,
-  const TColStd_Array1OfInteger& theTM,
-  const TColStd_Array1OfInteger& theInter,
-  const Standard_Integer theCurDegree,
-  const Standard_Integer theNb,
-  const Standard_Integer theNbInt,
-  const Standard_Real theFirst,
-  const Standard_Real theLast,
-  const Standard_Real theEps,
-  const Standard_Boolean thePeriodicCur,
-  Standard_Integer theNbIntervals,
-  Standard_Real theLower,
-  Standard_Real thePeriod,
-  Standard_Integer theIndex1,
-  Standard_Integer theIndex2)
-{
-  Standard_Real aNewFirst = theFirst;
-  Standard_Real aNewLast = theLast;
-  if (theIndex1 == 0)
-  {
-    BSplCLib::LocateParameter(theCurDegree, theTK, theTM, theFirst,
-      thePeriodicCur, 1, theNb, theIndex1, aNewFirst);
-  }
-  if (theIndex2 == 0)
-  {
-    BSplCLib::LocateParameter(theCurDegree, theTK, theTM, theLast,
-      thePeriodicCur, 1, theNb, theIndex2, aNewLast);
-  }
-  // Protection against theFirst = UFirst - eps, which located as ULast - eps
-  if (thePeriodicCur && ((aNewLast - aNewFirst) < Precision::PConfusion()))
-  {
-    if (Abs(aNewLast - theLower) < Precision::PConfusion())
-    {
-      aNewLast += thePeriod;
-    }
-    else
-    {
-      aNewFirst -= thePeriod;
-    }
-  }
-
-  if (Abs(aNewFirst - theTK(theIndex1 + 1)) < theEps)
-  {
-    theIndex1++;
-  }
-  if ((aNewLast - theTK(theIndex2)) > theEps)
-  {
-    theIndex2++;
-  }
-  for (Standard_Integer i = 1; i <= theNbInt; i++)
-  {
-    if (theInter(i) > theIndex1 && theInter(i) < theIndex2) theNbIntervals++;
-  }
-  return theNbIntervals;
-}
-
 //=======================================================================
 //function : NbIntervals
 //purpose  : 
@@ -513,187 +302,49 @@ Standard_Integer LocalNbIntervals(const TColStd_Array1OfReal& theTK,
 
 Standard_Integer Geom2dAdaptor_Curve::NbIntervals(const GeomAbs_Shape S) const
 {
-  Standard_Integer myNbIntervals = 1;
-  Standard_Integer NbSplit;
-  if (myTypeCurve == GeomAbs_BSplineCurve) {
-    Standard_Integer FirstIndex = myBSplineCurve->FirstUKnotIndex();
-    Standard_Integer LastIndex = myBSplineCurve->LastUKnotIndex();
-    TColStd_Array1OfInteger Inter(1, LastIndex - FirstIndex + 1);
-    Standard_Boolean aContPer = (S >= Continuity()) && myBSplineCurve->IsPeriodic();
-    Standard_Boolean aContNotPer = (S > Continuity()) && !myBSplineCurve->IsPeriodic();
-    if (aContPer || aContNotPer) {
-      Standard_Integer Cont;
-      switch (S) {
-      case GeomAbs_G1:
-      case GeomAbs_G2:
-        throw Standard_DomainError("Geom2dAdaptor_Curve::NbIntervals");
-        break;
-      case GeomAbs_C0:
-        myNbIntervals = 1;
-        break;
-      case GeomAbs_C1:
-      case GeomAbs_C2:
-      case GeomAbs_C3:
-      case GeomAbs_CN:
-      {
-        if (S == GeomAbs_C1) Cont = 1;
-        else if (S == GeomAbs_C2) Cont = 2;
-        else if (S == GeomAbs_C3) Cont = 3;
-        else                       Cont = myBSplineCurve->Degree();
-        Standard_Integer Degree = myBSplineCurve->Degree();
-        Standard_Integer NbKnots = myBSplineCurve->NbKnots();
-        TColStd_Array1OfInteger Mults(1, NbKnots);
-        myBSplineCurve->Multiplicities(Mults);
-        NbSplit = 1;
-        Standard_Integer Index = FirstIndex;
-        Inter(NbSplit) = Index;
-        Index++;
-        NbSplit++;
-        while (Index < LastIndex)
-        {
-          if (Degree - Mults(Index) < Cont)
-          {
-            Inter(NbSplit) = Index;
-            NbSplit++;
-          }
-          Index++;
-        }
-        Inter(NbSplit) = Index;
-
-        Standard_Integer NbInt = NbSplit - 1;
-
-        Standard_Integer Nb = myBSplineCurve->NbKnots();
-        TColStd_Array1OfReal    TK(1, Nb);
-        TColStd_Array1OfInteger TM(1, Nb);
-        myBSplineCurve->Knots(TK);
-        myBSplineCurve->Multiplicities(TM);
-        Standard_Real Eps = Min(Resolution(Precision::Confusion()),
-          Precision::PConfusion());
-
-        myNbIntervals = 1;
-
-        if (!myBSplineCurve->IsPeriodic())
-        {
-          myNbIntervals = LocalNbIntervals(TK, TM, Inter, Degree, Nb, NbInt,
-            myFirst, myLast, Eps, Standard_False, myNbIntervals);
-        }
-        else
-        {
-          Standard_Real aCurFirst = myFirst;
-          Standard_Real aCurLast = myLast;
-
-          Standard_Real aLower = myBSplineCurve->FirstParameter();
-          Standard_Real anUpper = myBSplineCurve->LastParameter();
-
-          if ((Abs(aCurFirst - aLower) < Eps) && (aCurFirst < aLower))
-          {
-            aCurFirst = aLower;
-          }
-          if ((Abs(aCurLast - anUpper) < Eps) && (aCurLast < anUpper))
-          {
-            aCurLast = anUpper;
-          }
-
-          Standard_Real aPeriod = myBSplineCurve->Period();
-          Standard_Integer aLPer = 1; Standard_Integer aFPer = 1;
-          
-          if ((Abs(aLower - myFirst) < Eps) && (aCurFirst < aLower))
-          {
-            aCurFirst = aLower;
-          }
-          else
-          {
-            DefinFPeriod(aLower, anUpper,
-              Eps, aPeriod, aCurFirst, aFPer);
-          }
-          DefinLPeriod(aLower, anUpper,
-            Eps, aPeriod, aCurLast, aLPer);
-
-          if ((Abs(aLower - myFirst) < Eps) && (Abs(anUpper - myLast) < Eps))
-          {
-            myNbIntervals = NbInt;
-          }
-          else
-          {
-            Standard_Integer aSumPer = Abs(aLPer - aFPer);
-            
-            Standard_Real aFirst = 0;
-            if (aLower < 0 && anUpper == 0)
-            {
-              if (Abs(aCurLast) < Eps)
-              {
-                aCurLast = 0;
-              }
-              aFirst = aLower;
-            }
-
-            if (aSumPer <= 1)
-            {
-              if ((Abs(myFirst - TK(Nb) - aPeriod * (aFPer - 1)) <= Eps) && (myLast < (TK(Nb) + aPeriod * (aLPer - 1))))
-              {
-                myNbIntervals = LocalNbIntervals(TK, TM, Inter, Degree, Nb, NbInt,
-                  myFirst, myLast, Eps, Standard_True, myNbIntervals, aLower, aPeriod);
-                return myNbIntervals;
-              }
-              if ((Abs(myFirst - aLower) < Eps) && (Abs(myLast - anUpper) < Eps))
-              {
-                myNbIntervals = LocalNbIntervals(TK, TM, Inter, Degree, Nb, NbInt,
-                  myFirst, myLast, Eps, Standard_True, myNbIntervals, aLower, aPeriod);
-                return myNbIntervals;
-              }
-            }
-
-            if (aSumPer != 0)
-            {
-              Standard_Integer aFInt = 0;
-              Standard_Integer aLInt = 0;
-              Standard_Integer aPInt = NbInt;
-
-              if ((aCurFirst != aPeriod) || ((aCurFirst != anUpper) && (Abs(myFirst) < Eps)))
-              {
-              aFInt = 1;
-              }
-              if ((aCurLast != 0) && (aCurLast != anUpper))
-              {
-                aLInt = 1;
-              }
-
-              aFInt = LocalNbIntervals(TK, TM, Inter, Degree, Nb, NbInt,
-                aCurFirst, anUpper, Eps, Standard_True, aFInt, aLower, aPeriod);
-
-              if (aCurLast == anUpper)
-              {
-                aLInt = NbInt;
-              }
-              else
-              {
-                if (Abs(aCurLast - aFirst) > Eps)
-                {
-                  aLInt = LocalNbIntervals(TK, TM, Inter, Degree, Nb, NbInt,
-                    aFirst, aCurLast, Eps, Standard_True, aLInt, aLower, aPeriod, 1);
-                }
-                else
-                {
-                  aLInt = LocalNbIntervals(TK, TM, Inter, Degree, Nb, NbInt,
-                    aFirst, aCurLast, Eps, Standard_True, aLInt, aLower, aPeriod);
-                }
-              }
-
-              myNbIntervals = aFInt + aLInt + aPInt * (aSumPer - 1);
-            }
-            else
-            {
-              myNbIntervals = LocalNbIntervals(TK, TM, Inter, Degree, Nb, NbInt,
-                aCurFirst, aCurLast, Eps, Standard_True, myNbIntervals, aLower, aPeriod);
-            }
-          }
-        }
-      }
-      break;
-      }
+  if (myTypeCurve == GeomAbs_BSplineCurve)
+  {
+    if ((!myBSplineCurve->IsPeriodic() && S <= Continuity()) || S == GeomAbs_C0)
+    {
+      return 1;
     }
+    
+    Standard_Integer aDegree = myBSplineCurve->Degree();
+    Standard_Integer aCont;
+
+    switch (S)
+    {
+      case GeomAbs_C1:
+        aCont = 1;
+        break;
+      case GeomAbs_C2:
+        aCont = 2;
+        break;
+      case GeomAbs_C3:
+        aCont = 3;
+        break;
+      case GeomAbs_CN:
+        aCont = aDegree;
+        break;
+      default:
+        throw Standard_DomainError ("Geom2dAdaptor_Curve::NbIntervals()");
+    }
+
+    Standard_Real anEps = Min(Resolution(Precision::Confusion()), Precision::PConfusion());
+
+    return BSplCLib::Intervals(myBSplineCurve->Knots(),
+                               myBSplineCurve->Multiplicities(),
+                               aDegree,
+                               myBSplineCurve->IsPeriodic(),
+                               aCont,
+                               myFirst,
+                               myLast,
+                               anEps,
+                               nullptr);
   }
+
   else if (myTypeCurve == GeomAbs_OffsetCurve){
+    Standard_Integer myNbIntervals = 1;
     GeomAbs_Shape BaseS=GeomAbs_C0;
     switch(S){
     case GeomAbs_G1:
@@ -705,208 +356,14 @@ Standard_Integer Geom2dAdaptor_Curve::NbIntervals(const GeomAbs_Shape S) const
     case GeomAbs_C2: BaseS = GeomAbs_C3; break;
     default: BaseS = GeomAbs_CN;
     }
-    Geom2dAdaptor_Curve anAdaptor( Handle(Geom2d_OffsetCurve)::DownCast(myCurve)->BasisCurve() );
+    Geom2dAdaptor_Curve anAdaptor (Handle(Geom2d_OffsetCurve)::DownCast(myCurve)->BasisCurve(), myFirst, myLast);
     myNbIntervals = anAdaptor.NbIntervals(BaseS);
+    return myNbIntervals;
   }
 
-  return myNbIntervals;
-}
-
-//=======================================================================
-//function : WriteIntervals
-//purpose  :
-//=======================================================================
-
-void WriteIntervals(const TColStd_Array1OfReal &theTK,
-  const TColStd_Array1OfInteger &theInter,
-  const Standard_Integer theNbInt,
-  const Standard_Integer theIndex1,
-  const Standard_Integer theIndex2,
-  const Standard_Real theCurPeriod,
-  const Standard_Boolean theFlagForFirst,
-  TColStd_Array1OfReal &theT,
-  TColStd_Array1OfInteger &theFinalIntervals,
-  Standard_Integer &theNbIntervals,
-  Standard_Integer &theCurInt)
-{
-  if (theFlagForFirst)
-  {
-    for (Standard_Integer anId = 1; anId <= theNbInt; anId++)
-    {
-      if (theInter(anId) > theIndex1 && theInter(anId) <= theIndex2)
-      {
-        theNbIntervals++;
-        theFinalIntervals(theNbIntervals) = theInter(anId);
-      }
-    }
-  }
   else
   {
-    for (Standard_Integer anId = 1; anId <= theNbInt; anId++)
-    {
-      if (theInter(anId) > theIndex1 && theInter(anId) < theIndex2)
-      {
-        theNbIntervals++;
-        theFinalIntervals(theNbIntervals) = theInter(anId);
-      }
-    }
-  }
-
-  theFinalIntervals(theNbIntervals + 1) = theIndex2;
-
-  for (Standard_Integer anId = theCurInt; anId <= theNbIntervals + 1; anId++)
-  {
-    theT(anId) = theTK(theFinalIntervals(anId)) + theCurPeriod;
-    theCurInt++;
-  }
-}
-
-//=======================================================================
-//function : SpreadInt
-//purpose  :
-//=======================================================================
-void SpreadInt(const TColStd_Array1OfReal &theTK,
-  const TColStd_Array1OfInteger &theTM,
-  const TColStd_Array1OfInteger &theInter,
-  const Standard_Integer theCurDegree,
-  const Standard_Integer theNb,
-  const Standard_Integer theFPer,
-  const Standard_Integer theLPer,
-  const Standard_Integer theNbInt,
-  const Standard_Real theLower,
-  const Standard_Real theFirst,
-  const Standard_Real theLast,
-  const Standard_Real thePeriod,
-  const Standard_Real theLastParam,
-  const Standard_Real theEps,
-  TColStd_Array1OfReal &theT,
-  Standard_Integer &theNbIntervals)
-{
-  Standard_Integer anIndex1 = 0;
-  Standard_Integer anIndex2 = 0;
-  Standard_Real aNewFirst, aNewLast;
-  Standard_Integer anUpper;
-  BSplCLib::LocateParameter(theCurDegree, theTK, theTM, theFirst,
-    Standard_True, 1, theNb, anIndex1, aNewFirst);
-  BSplCLib::LocateParameter(theCurDegree, theTK, theTM, theLastParam,
-    Standard_True, 1, theNb, anIndex2, aNewLast);
-
-  if (Abs(aNewFirst - theTK(anIndex1 + 1)) < theEps)
-  {
-    anIndex1++;
-  }
-  if ((aNewLast - theTK(anIndex2)) > theEps)
-  {
-    anIndex2++;
-  }
-  theNbIntervals = 1;
-
-  if (anIndex1 == theNb)
-  {
-    anIndex1 = 1;
-  }
-  
-  // Count the max number of boundaries of intervals
-  if (Abs(theLPer - theFPer) > 1)
-  {
-    anUpper = theNb - anIndex1 + anIndex2 + (theLPer - theFPer - 1) * theNb + 1;
-  }
-  else
-  {
-    anUpper = theNb - anIndex1 + anIndex2 + 1;
-  }
-
-  if (theLPer == theFPer)
-  {
-    anUpper = theInter.Upper();
-  }
-  TColStd_Array1OfInteger aFinalIntervals(1, anUpper);
-  aFinalIntervals(1) = anIndex1;
-
-  // If first and last are in the same period
-  if ((Abs(theLPer - theFPer) == 0))
-  {
-    Standard_Integer aCurInt = 1;
-    Standard_Real aCurPeriod = theFPer * thePeriod;
-
-    if (theFirst == aNewFirst && theLast == aNewLast)
-    {
-      aCurPeriod = 0;
-    }
-    WriteIntervals(theTK, theInter, theNbInt, anIndex1,
-      anIndex2, aCurPeriod, Standard_False, theT, aFinalIntervals, theNbIntervals, aCurInt);
-    return;
-  }
-
-  // If the first and the last are in neighboring periods
-  if (Abs(theLPer - theFPer) == 1)
-  {
-    Standard_Integer aCurInt = 1;
-
-    if (Abs(theLastParam - theLower) < theEps)
-    {
-      WriteIntervals(theTK, theInter, theNbInt, anIndex1,
-        theNb, theFPer * thePeriod, Standard_True, theT, aFinalIntervals, theNbIntervals, aCurInt);
-      return;
-    }
-    else
-    {
-      // For period with first
-      WriteIntervals(theTK, theInter, theNbInt, anIndex1,
-        theNb, theFPer * thePeriod, Standard_True, theT, aFinalIntervals, theNbIntervals, aCurInt);
-      // For period with last
-      theNbIntervals++;
-      WriteIntervals(theTK, theInter, theNbInt, 1,
-        anIndex2, theLPer * thePeriod, Standard_False, theT, aFinalIntervals, theNbIntervals, aCurInt);
-      return;
-    }
-  }
-  // If the first and the last are far apart
-  if (Abs(theLPer - theFPer) > 1)
-  {
-    Standard_Integer aCurInt = 1;
-    if (Abs(theLastParam - theLower) < theEps)
-    {
-      WriteIntervals(theTK, theInter, theNbInt, anIndex1,
-        theNb, theFPer * thePeriod, Standard_True, theT, aFinalIntervals, theNbIntervals, aCurInt);
-
-      Standard_Integer aNbPer = Abs(theLPer - theFPer);
-      Standard_Integer aCurPer = theFPer + 1;
-
-      while (aNbPer > 1)
-      {
-        theNbIntervals++;
-        WriteIntervals(theTK, theInter, theNbInt, 1,
-          theNb, aCurPer * thePeriod, Standard_True, theT, aFinalIntervals, theNbIntervals, aCurInt);
-
-        aNbPer--;
-        aCurPer++;
-      }
-      return;
-    }
-    else
-    {
-      // For period with first
-      WriteIntervals(theTK, theInter, theNbInt, anIndex1,
-        theNb, theFPer * thePeriod, Standard_True, theT, aFinalIntervals, theNbIntervals, aCurInt);
-
-      Standard_Integer aNbPer = Abs(theLPer - theFPer);
-      Standard_Integer aCurPer = theFPer + 1;
-      while (aNbPer > 1)
-      {
-        theNbIntervals++;
-        WriteIntervals(theTK, theInter, theNbInt, 1,
-          theNb, aCurPer * thePeriod, Standard_True, theT, aFinalIntervals, theNbIntervals, aCurInt);
-
-        aNbPer--;
-        aCurPer++;
-      }
-      // For period with last
-      theNbIntervals++;
-      WriteIntervals(theTK, theInter, theNbInt, 1,
-        anIndex2, theLPer * thePeriod, Standard_False, theT, aFinalIntervals, theNbIntervals, aCurInt);
-      return;
-    }
+    return 1;
   }
 }
 
@@ -915,156 +372,53 @@ void SpreadInt(const TColStd_Array1OfReal &theTK,
 //purpose  : 
 //=======================================================================
 
-void Geom2dAdaptor_Curve::Intervals(TColStd_Array1OfReal& T,
-				    const GeomAbs_Shape S   ) const 
+void Geom2dAdaptor_Curve::Intervals (TColStd_Array1OfReal& T, const GeomAbs_Shape S) const 
 {
-  Standard_Integer myNbIntervals = 1;
-  Standard_Integer NbSplit;
-  if (myTypeCurve == GeomAbs_BSplineCurve) {
-    Standard_Integer FirstIndex = myBSplineCurve->FirstUKnotIndex();
-    Standard_Integer LastIndex  = myBSplineCurve->LastUKnotIndex();
-    TColStd_Array1OfInteger Inter (1, LastIndex-FirstIndex+1);
-    Standard_Boolean aContPer = (S >= Continuity()) && myBSplineCurve->IsPeriodic();
-    Standard_Boolean aContNotPer = (S > Continuity()) && !myBSplineCurve->IsPeriodic();
-    if (aContPer || aContNotPer) {
-      Standard_Integer Cont;
-      switch ( S) {
-      case GeomAbs_G1:
-      case GeomAbs_G2:
-	throw Standard_DomainError("Geom2dAdaptor_Curve::NbIntervals");
-	break;
-      case GeomAbs_C0:
-	myNbIntervals = 1;
-	break;
-      case GeomAbs_C1:
-      case GeomAbs_C2:
-      case GeomAbs_C3: 
-      case GeomAbs_CN: 
-      {
-        if (S == GeomAbs_C1) Cont = 1;
-        else if (S == GeomAbs_C2) Cont = 2;
-        else if (S == GeomAbs_C3) Cont = 3;
-        else                       Cont = myBSplineCurve->Degree();
-        Standard_Integer Degree = myBSplineCurve->Degree();
-        Standard_Integer NbKnots = myBSplineCurve->NbKnots();
-        TColStd_Array1OfInteger Mults(1, NbKnots);
-        myBSplineCurve->Multiplicities(Mults);
-        NbSplit = 1;
-        Standard_Integer Index = FirstIndex;
-        Inter(NbSplit) = Index;
-        Index++;
-        NbSplit++;
-        while (Index < LastIndex)
-        {
-          if (Degree - Mults(Index) < Cont)
-          {
-            Inter(NbSplit) = Index;
-            NbSplit++;
-          }
-          Index++;
-        }
-        Inter(NbSplit) = Index;
-        Standard_Integer NbInt = NbSplit - 1;
-
-        Standard_Integer Nb = myBSplineCurve->NbKnots();
-        Standard_Integer Index1 = 0;
-        Standard_Integer Index2 = 0;
-        Standard_Real newFirst, newLast;
-        TColStd_Array1OfReal    TK(1, Nb);
-        TColStd_Array1OfInteger TM(1, Nb);
-        myBSplineCurve->Knots(TK);
-        myBSplineCurve->Multiplicities(TM);
-        Standard_Real Eps = Min(Resolution(Precision::Confusion()),
-          Precision::PConfusion());
-
-        if (!myBSplineCurve->IsPeriodic())
-        {
-          BSplCLib::LocateParameter(myBSplineCurve->Degree(), TK, TM, myFirst,
-            myBSplineCurve->IsPeriodic(),
-            1, Nb, Index1, newFirst);
-          BSplCLib::LocateParameter(myBSplineCurve->Degree(), TK, TM, myLast,
-            myBSplineCurve->IsPeriodic(),
-            1, Nb, Index2, newLast);
-
-
-          // On decale eventuellement les indices  
-          // On utilise une "petite" tolerance, la resolution ne doit 
-                // servir que pour les tres longue courbes....(PRO9248)
-          if (Abs(newFirst - TK(Index1 + 1)) < Eps) Index1++;
-          if (newLast - TK(Index2) > Eps) Index2++;
-
-          Inter(1) = Index1;
-          myNbIntervals = 1;
-          for (Standard_Integer i = 1; i <= NbInt; i++) {
-            if (Inter(i) > Index1 && Inter(i) < Index2) {
-              myNbIntervals++;
-              Inter(myNbIntervals) = Inter(i);
-            }
-          }
-          Inter(myNbIntervals + 1) = Index2;
-
-          Standard_Integer ii = T.Lower() - 1;
-          for (Standard_Integer I = 1; I <= myNbIntervals + 1; I++) {
-            T(ii + I) = TK(Inter(I));
-          }
-        }
-        else
-        {
-          Standard_Real aFirst = myFirst;
-          Standard_Real aLast = myLast;
-
-          Standard_Real aCurFirst = aFirst;
-          Standard_Real aCurLast = aLast;
-
-          Standard_Real aPeriod = myBSplineCurve->Period();
-          Standard_Real aLower = myBSplineCurve->FirstParameter();
-          Standard_Real anUpper = myBSplineCurve->LastParameter();
-
-          Standard_Integer aLPer = 0; Standard_Integer aFPer = 0;
-
-          if (Abs(myFirst - aLower) <= Eps)
-          {
-            aCurFirst = aLower;
-            aFirst = aCurFirst;
-          }
-          if (Abs(myLast - anUpper) <= Eps)
-          {
-            aCurLast = anUpper;
-            aLast = aCurLast;
-          }
-
-          if ((Abs(aLower - myFirst) < Eps) && (aCurFirst < aLower))
-          {
-            aCurFirst = aLower;
-          }
-          else
-          {
-            DefinFPeriod(aLower, anUpper,
-              Eps, aPeriod, aCurFirst, aFPer);
-          }
-          DefinLPeriod(aLower, anUpper,
-            Eps, aPeriod, aCurLast, aLPer);
-
-          if (myFirst == aLower)
-          {
-            aFPer = 0;
-          }
-
-          SpreadInt(TK, TM, Inter, myBSplineCurve->Degree(), Nb, aFPer, aLPer, NbInt, aLower, myFirst, myLast, aPeriod,
-            aCurLast, Eps, T, myNbIntervals);
-          T(T.Lower()) = aFirst;
-          T(T.Lower() + myNbIntervals) = aLast;
-          return;
-
-        }
-      }
-      T(T.Lower()) = myFirst;
-      T(T.Lower() + myNbIntervals) = myLast;
+  if (myTypeCurve == GeomAbs_BSplineCurve)
+  {
+    if ((!myBSplineCurve->IsPeriodic() && S <= Continuity()) || S == GeomAbs_C0)
+    {
+      T( T.Lower() ) = myFirst;
+      T( T.Lower() + 1 ) = myLast;
       return;
-      }
     }
+
+    Standard_Integer aDegree = myBSplineCurve->Degree();
+    Standard_Integer aCont;
+
+    switch (S)
+    {
+      case GeomAbs_C1:
+        aCont = 1;
+        break;
+      case GeomAbs_C2:
+        aCont = 2;
+        break;
+      case GeomAbs_C3:
+        aCont = 3;
+        break;
+      case GeomAbs_CN:
+        aCont = aDegree;
+        break;
+      default:
+        throw Standard_DomainError ("Geom2dAdaptor_Curve::Intervals()");
+    }
+
+    Standard_Real anEps = Min(Resolution(Precision::Confusion()), Precision::PConfusion());
+
+    BSplCLib::Intervals(myBSplineCurve->Knots(),
+                        myBSplineCurve->Multiplicities(),
+                        aDegree,
+                        myBSplineCurve->IsPeriodic(),
+                        aCont,
+                        myFirst,
+                        myLast,
+                        anEps,
+                        &T);
   }
+
   else if (myTypeCurve == GeomAbs_OffsetCurve){
+    Standard_Integer myNbIntervals = 1;
     GeomAbs_Shape BaseS=GeomAbs_C0;
     switch(S){
     case GeomAbs_G1:
@@ -1077,13 +431,18 @@ void Geom2dAdaptor_Curve::Intervals(TColStd_Array1OfReal& T,
     default: BaseS = GeomAbs_CN;
     }
 
-    Geom2dAdaptor_Curve anAdaptor( Handle(Geom2d_OffsetCurve)::DownCast(myCurve)->BasisCurve() );
+    Geom2dAdaptor_Curve anAdaptor (Handle(Geom2d_OffsetCurve)::DownCast(myCurve)->BasisCurve(), myFirst, myLast);
     myNbIntervals = anAdaptor.NbIntervals(BaseS);
     anAdaptor.Intervals(T, BaseS);
+    T( T.Lower() ) = myFirst;
+    T( T.Lower() + myNbIntervals ) = myLast;
   }
 
-  T( T.Lower() ) = myFirst;
-  T( T.Lower() + myNbIntervals ) = myLast;
+  else
+  {
+    T( T.Lower() ) = myFirst;
+    T( T.Lower() + 1 ) = myLast;
+  }
 }
 
 //=======================================================================

src/Geom2dConvert/Geom2dConvert.cxx

@@ -515,7 +515,6 @@ static Handle(Geom2d_BSplineCurve) MultNumandDenom(const Handle(Geom2d_BSplineCu
   Handle(TColStd_HArray1OfReal)      resKnots;
   Handle(TColStd_HArray1OfInteger)   resMults; 
   Standard_Real                      start_value,end_value;
-  Standard_Real                      tolerance=Precision::Confusion();
   Standard_Integer                   resNbPoles,degree,
                                      ii,jj,
 				     aStatus;
@@ -527,6 +526,7 @@ static Handle(Geom2d_BSplineCurve) MultNumandDenom(const Handle(Geom2d_BSplineCu
   BS->KnotSequence(BSFlatKnots);
   start_value = BSKnots(1);
   end_value = BSKnots(BS->NbKnots());
+  Standard_Real tolerance = 10.*Epsilon(Abs(end_value));
 
   a->Knots(aKnots);
   a->Poles(aPoles);
@@ -565,22 +565,6 @@ static Handle(Geom2d_BSplineCurve) MultNumandDenom(const Handle(Geom2d_BSplineCu
 			     degree,
 			     resDenPoles,
 			     aStatus);
-//  BSplCLib::FunctionMultiply(law_evaluator,
-//			     BS->Degree(),
-//			     BSFlatKnots,
-//			     BSPoles,
-//			     resFlatKnots,
-//			     degree,
-//			     resNumPoles,
-//			     aStatus);
-//  BSplCLib::FunctionMultiply(law_evaluator,
-//			     BS->Degree(),
-//			     BSFlatKnots,
-//			     BSWeights,
-//			     resFlatKnots,
-//			     degree,
-//			     resDenPoles,
-//			     aStatus);
   for (ii=1;ii<=resNbPoles;ii++)
     for(jj=1;jj<=2;jj++) 
       resPoles(ii).SetCoord(jj,resNumPoles(ii).Coord(jj)/resDenPoles(ii));
@@ -1339,24 +1323,22 @@ void  Geom2dConvert::ConcatC1(TColGeom2d_Array1OfBSplineCurve&           ArrayOf
 	     Curve1Poles(ii).SetCoord(jj,Curve1Poles(ii).Coord(jj)*Curve1Weights(ii));
 //POP pour NT
 	 Geom2dConvert_reparameterise_evaluator ev (aPolynomialCoefficient);
-//	 BSplCLib::FunctionReparameterise(reparameterise_evaluator,
 	 BSplCLib::FunctionReparameterise(ev,
 					  Curve1->Degree(),
 					  Curve1FlatKnots,
 					  Curve1Poles,
 					  FlatKnots,
-                                          aNewCurveDegree,
+                      aNewCurveDegree,
 					  NewPoles,
 					  aStatus
 					  );
-         TColStd_Array1OfReal NewWeights(1, FlatKnots.Length() - (aNewCurveDegree + 1));
-//	 BSplCLib::FunctionReparameterise(reparameterise_evaluator,
+     TColStd_Array1OfReal NewWeights(1, FlatKnots.Length() - (aNewCurveDegree + 1));
 	 BSplCLib::FunctionReparameterise(ev,
 					  Curve1->Degree(),
 					  Curve1FlatKnots,
 					  Curve1Weights,
 					  FlatKnots,
-                                          aNewCurveDegree,
+                      aNewCurveDegree,
 					  NewWeights,
 					  aStatus
 					  );

src/GeomAdaptor/GeomAdaptor_Curve.cxx

@@ -58,65 +58,6 @@ static const Standard_Real PosTol = Precision::PConfusion() / 2;
 
 IMPLEMENT_STANDARD_RTTIEXT(GeomAdaptor_Curve, Adaptor3d_Curve)
 
-static void DefinFPeriod(const Standard_Real theLower,
-  const Standard_Real theUpper,
-  const Standard_Real theEps,
-  const Standard_Real thePeriod,
-  Standard_Real &theCurFirst,
-  Standard_Integer &theFPer);
-
-static void DefinLPeriod(const Standard_Real theLower,
-  const Standard_Real theUpper,
-  const Standard_Real theEps,
-  const Standard_Real thePeriod,
-  Standard_Real &theCurLast,
-  Standard_Integer &theLPer);
-
-static Standard_Integer LocalNbIntervals(const TColStd_Array1OfReal& theTK,
-  const TColStd_Array1OfInteger& theTM,
-  const TColStd_Array1OfInteger& theInter,
-  const Standard_Integer theCurDegree,
-  const Standard_Integer theNb,
-  const Standard_Integer theNbInt,
-  const Standard_Real theFirst,
-  const Standard_Real theLast,
-  const Standard_Real theEps,
-  const Standard_Boolean thePeriodicCur,
-  Standard_Integer theNbIntervals,
-  Standard_Real theLower = 0,
-  Standard_Real thePeriod = 0,
-  Standard_Integer theIndex1 = 0,
-  Standard_Integer theIndex2 = 0);
-
-static void WriteIntervals(const TColStd_Array1OfReal &theTK,
-  const TColStd_Array1OfInteger &theInter,
-  const Standard_Integer theNbInt,
-  const Standard_Integer theIndex1,
-  const Standard_Integer theIndex2,
-  const Standard_Real theCurPeriod,
-  const Standard_Boolean theFlagForFirst,
-  TColStd_Array1OfReal &theT,
-  TColStd_Array1OfInteger &theFinalIntervals,
-  Standard_Integer &theNbIntervals,
-  Standard_Integer &theCurInt);
-
-static void SpreadInt(const TColStd_Array1OfReal &theTK,
-  const TColStd_Array1OfInteger &theTM,
-  const TColStd_Array1OfInteger &theInter,
-  const Standard_Integer theCurDegree,
-  const Standard_Integer theNb,
-  const Standard_Integer theFPer,
-  const Standard_Integer theLPer,
-  const Standard_Integer theNbInt,
-  const Standard_Real theLower,
-  const Standard_Real theFirst,
-  const Standard_Real theLast,
-  const Standard_Real thePeriod,
-  const Standard_Real theLastParam,
-  const Standard_Real theEps,
-  TColStd_Array1OfReal &theT,
-  Standard_Integer &theNbIntervals);
-
 //=======================================================================
 //function : ShallowCopy
 //purpose  : 
@@ -310,159 +251,6 @@ GeomAbs_Shape GeomAdaptor_Curve::Continuity() const
   return GeomAbs_CN;
 }
 
-//=======================================================================
-//function : DefinFPeriod
-//purpose  :
-//=======================================================================
-
-void DefinFPeriod(const Standard_Real theLower,
-  const Standard_Real theUpper,
-  const Standard_Real theEps,
-  const Standard_Real thePeriod,
-  Standard_Real &theCurFirst,
-  Standard_Integer &theFPer)
-{
-  if (theCurFirst >= theLower)
-  {
-    while (theCurFirst >= theUpper)
-    {
-      theCurFirst = theCurFirst - thePeriod;
-      theFPer++;
-    }
-    if (Abs(theUpper - theCurFirst) <= theEps)
-    {
-      theFPer++;
-      theCurFirst = theLower;
-    }
-  }
-  else
-  {
-    while (theCurFirst < theLower)
-    {
-      theCurFirst = theCurFirst + thePeriod;
-      if ((Abs(theLower - theCurFirst)) > theEps)
-      {
-        theFPer--;
-      }
-    }
-
-    if (Abs(theUpper - theCurFirst) <= theEps)
-    {
-      theCurFirst = theLower;
-    }
-  }
-}
-
-//=======================================================================
-//function : DefinLPeriod
-//purpose  :
-//=======================================================================
-
-void DefinLPeriod(const Standard_Real theLower,
-  const Standard_Real theUpper,
-  const Standard_Real theEps,
-  const Standard_Real thePeriod,
-  Standard_Real &theCurLast,
-  Standard_Integer &theLPer)
-{
-  if (theCurLast >= theLower)
-  {
-    if ((theCurLast >= theUpper) && (Abs(theCurLast - theUpper) <= theEps))
-    {
-      theCurLast = theUpper;
-    }
-    else
-    {
-      while (theCurLast >= theUpper)
-      {
-        theCurLast = theCurLast - thePeriod;
-        theLPer++;
-      }
-      if (Abs(theUpper - theCurLast) <= theEps)
-      {
-        theCurLast = theLower;
-      }
-    }
-  }
-  else
-  {
-    while (theCurLast < theLower)
-    {
-      theCurLast = theCurLast + thePeriod;
-      if (Abs(theLower - theCurLast) > theEps)
-      {
-        theLPer--;
-      }
-    }
-    if ((theUpper - theCurLast) <= theEps)
-    {
-      theCurLast = theLower;
-    }
-  }
-}
-
-//=======================================================================
-//function : LocalNbIntervals
-//purpose  :
-//=======================================================================
-
-Standard_Integer LocalNbIntervals(const TColStd_Array1OfReal& theTK,
-  const TColStd_Array1OfInteger& theTM,
-  const TColStd_Array1OfInteger& theInter,
-  const Standard_Integer theCurDegree,
-  const Standard_Integer theNb,
-  const Standard_Integer theNbInt,
-  const Standard_Real theFirst,
-  const Standard_Real theLast,
-  const Standard_Real theEps,
-  const Standard_Boolean thePeriodicCur,
-  Standard_Integer theNbIntervals,
-  Standard_Real theLower,
-  Standard_Real thePeriod,
-  Standard_Integer theIndex1,
-  Standard_Integer theIndex2)
-{
-  Standard_Real aNewFirst = theFirst;
-  Standard_Real aNewLast = theLast;
-  if (theIndex1 == 0)
-  {
-    BSplCLib::LocateParameter(theCurDegree, theTK, theTM, theFirst,
-      thePeriodicCur, 1, theNb, theIndex1, aNewFirst);
-  }
-  if (theIndex2 == 0)
-  {
-    BSplCLib::LocateParameter(theCurDegree, theTK, theTM, theLast,
-      thePeriodicCur, 1, theNb, theIndex2, aNewLast);
-  }
-  // Protection against theFirst = UFirst - eps, which located as ULast - eps
-  if (thePeriodicCur && ((aNewLast - aNewFirst) < Precision::PConfusion()))
-  {
-    if (Abs(aNewLast - theLower) < Precision::PConfusion())
-    {
-      aNewLast += thePeriod;
-    }
-    else
-    {
-      aNewFirst -= thePeriod;
-    }
-  }
-
-  if (Abs(aNewFirst - theTK(theIndex1 + 1)) < theEps)
-  {
-    theIndex1++;
-  }
-  if ((aNewLast - theTK(theIndex2)) > theEps)
-  {
-    theIndex2++;
-  }
-  for (Standard_Integer i = 1; i <= theNbInt; i++)
-  {
-    if (theInter(i) > theIndex1 && theInter(i) < theIndex2) theNbIntervals++;
-  }
-  return theNbIntervals;
-}
-
-
 //=======================================================================
 //function : NbIntervals
 //purpose  : 
@@ -470,207 +258,61 @@ Standard_Integer LocalNbIntervals(const TColStd_Array1OfReal& theTK,
 
 Standard_Integer GeomAdaptor_Curve::NbIntervals(const GeomAbs_Shape S) const
 {
-  Standard_Integer myNbIntervals = 1;
-  Standard_Integer NbSplit;
-  if (myTypeCurve == GeomAbs_BSplineCurve) {
-    Standard_Integer FirstIndex = myBSplineCurve->FirstUKnotIndex();
-    Standard_Integer LastIndex = myBSplineCurve->LastUKnotIndex();
-    TColStd_Array1OfInteger Inter(1, LastIndex - FirstIndex + 1);
-    Standard_Boolean aContPer = (S >= Continuity()) && myBSplineCurve->IsPeriodic();
-    Standard_Boolean aContNotPer = (S > Continuity()) && !myBSplineCurve->IsPeriodic();
-
-    if(aContPer || aContNotPer) {
-      Standard_Integer Cont;
-      switch (S) {
-      case GeomAbs_G1:
-      case GeomAbs_G2:
-        throw Standard_DomainError("GeomAdaptor_Curve::NbIntervals");
-        break;
-      case GeomAbs_C0:
-        myNbIntervals = 1;
-        break;
-      case GeomAbs_C1:
-      case GeomAbs_C2:
-      case GeomAbs_C3:
-      case GeomAbs_CN:
-      {
-        if (S == GeomAbs_C1) Cont = 1;
-        else if (S == GeomAbs_C2) Cont = 2;
-        else if (S == GeomAbs_C3) Cont = 3;
-        else                       Cont = myBSplineCurve->Degree();
-        Standard_Integer Degree = myBSplineCurve->Degree();
-        Standard_Integer NbKnots = myBSplineCurve->NbKnots();
-        TColStd_Array1OfInteger Mults(1, NbKnots);
-        myBSplineCurve->Multiplicities(Mults);
-        NbSplit = 1;
-        Standard_Integer Index = FirstIndex;
-        Inter(NbSplit) = Index;
-        Index++;
-        NbSplit++;
-        while (Index < LastIndex)
-        {
-          if (Degree - Mults(Index) < Cont)
-          {
-            Inter(NbSplit) = Index;
-            NbSplit++;
-          }
-          Index++;
-        }
-        Inter(NbSplit) = Index;
-
-        Standard_Integer NbInt = NbSplit - 1;
-
-        Standard_Integer Nb = myBSplineCurve->NbKnots();
-        Standard_Integer Index1 = 0;
-        Standard_Integer Index2 = 0;
-        const TColStd_Array1OfReal& TK = myBSplineCurve->Knots();
-        const TColStd_Array1OfInteger& TM = myBSplineCurve->Multiplicities();
-        Standard_Real Eps = Min(Resolution(Precision::Confusion()),
-          Precision::PConfusion());
-
-        myNbIntervals = 1;
-
-        if (!myBSplineCurve->IsPeriodic())
-        {
-          myNbIntervals = LocalNbIntervals(TK, TM, Inter, Degree, Nb, NbInt,
-            myFirst, myLast, Eps, Standard_False, myNbIntervals);
-        }
-        else
-        {
-          Standard_Real aCurFirst = myFirst;
-          Standard_Real aCurLast = myLast;
-          Standard_Real aLower = myBSplineCurve->FirstParameter();
-          Standard_Real anUpper = myBSplineCurve->LastParameter();
-
-          if ((Abs(aCurFirst - aLower) < Eps) && (aCurFirst < aLower))
-          {
-            aCurFirst = aLower;
-          }
-          if ((Abs(aCurLast - anUpper) < Eps) && (aCurLast < anUpper))
-          {
-            aCurLast = anUpper;
-          }
-
-          Standard_Real aPeriod = myBSplineCurve->Period();
-          Standard_Integer aLPer = 1; Standard_Integer aFPer = 1;
-          if ((Abs(aLower - myFirst) < Eps) && (aCurFirst < aLower))
-          {
-            aCurFirst = aLower;
-          }
-          else
-          {
-            DefinFPeriod(aLower, anUpper,
-              Eps, aPeriod, aCurFirst, aFPer);
-          }
-          DefinLPeriod(aLower, anUpper,
-            Eps, aPeriod, aCurLast, aLPer);
-
-          Standard_Real aNewFirst;
-          Standard_Real aNewLast;
-          BSplCLib::LocateParameter(myBSplineCurve->Degree(), TK, TM, myFirst,
-            Standard_True, 1, Nb, Index1, aNewFirst);
-          BSplCLib::LocateParameter(myBSplineCurve->Degree(), TK, TM, myLast,
-            Standard_True, 1, Nb, Index2, aNewLast);
-          if ((aNewFirst == myFirst && aNewLast == myLast) && (aFPer != aLPer))
-          {
-            myNbIntervals = LocalNbIntervals(TK, TM, Inter, Degree, Nb, NbInt,
-              myFirst, myLast, Eps, Standard_True, myNbIntervals, aLower, aPeriod);
-          }
-          else
-          {
-            Standard_Integer aSumPer = Abs(aLPer - aFPer);
-            
-            Standard_Real aFirst = 0;
-            if (aLower < 0 && anUpper == 0)
-            {
-              if (Abs(aCurLast) < Eps)
-              {
-                aCurLast = 0;
-              }
-              aFirst = aLower;
-            }
-
-            if (aSumPer <= 1)
-            {
-              if ((Abs(myFirst - TK(Nb) - aPeriod * (aFPer - 1)) <= Eps) && (myLast < (TK(Nb) + aPeriod * (aLPer - 1))))
-              {
-                myNbIntervals = LocalNbIntervals(TK, TM, Inter, Degree, Nb, NbInt,
-                  myFirst, myLast, Eps, Standard_True, myNbIntervals, aLower, aPeriod);
-                return myNbIntervals;
-              }
-              if ((Abs(myFirst - aLower) < Eps) && (Abs(myLast - anUpper) < Eps))
-              {
-                myNbIntervals = LocalNbIntervals(TK, TM, Inter, Degree, Nb, NbInt,
-                  myFirst, myLast, Eps, Standard_True, myNbIntervals, aLower, aPeriod);
-                return myNbIntervals;
-              }
-            }
-
-            if (aSumPer != 0)
-            {
-              Standard_Integer aFInt = 0;
-              Standard_Integer aLInt = 0;
-              Standard_Integer aPInt = NbInt;
-
-              if ((aCurFirst != aPeriod) || ((aCurFirst != anUpper) && (Abs(myFirst) < Eps)))
-              {
-                aFInt = 1;
-              }
-              if ((aCurLast != aLower) && (aCurLast != anUpper))
-              {
-                aLInt = 1;
-              }
-
-              aFInt = LocalNbIntervals(TK, TM, Inter, Degree, Nb, NbInt,
-                aCurFirst, anUpper, Eps, Standard_True, aFInt, aLower, aPeriod);
-
-              if (aCurLast == anUpper)
-              {
-                aLInt = NbInt;
-              }
-              else
-              {
-                if (Abs(aCurLast - aFirst) > Eps)
-                {
-                  aLInt = LocalNbIntervals(TK, TM, Inter, Degree, Nb, NbInt,
-                    aFirst, aCurLast, Eps, Standard_True, aLInt, aLower, aPeriod, 1);
-                }
-                else
-                {
-                  aLInt = LocalNbIntervals(TK, TM, Inter, Degree, Nb, NbInt,
-                    aFirst, aCurLast, Eps, Standard_True, aLInt, aLower, aPeriod);
-                }
-              }
-
-              myNbIntervals = aFInt + aLInt + aPInt * (aSumPer - 1);
-            }
-            else
-            {
-              myNbIntervals = LocalNbIntervals(TK, TM, Inter, Degree, Nb, NbInt,
-                aCurFirst, aCurLast, Eps, Standard_True, myNbIntervals, aLower, aPeriod);
-            }
-          }
-        }
-      }
-      break;
-      }
+  if (myTypeCurve == GeomAbs_BSplineCurve)
+  {
+    if ((!myBSplineCurve->IsPeriodic() && S <= Continuity()) || S == GeomAbs_C0)
+    {
+      return 1;
     }
+
+    Standard_Integer aDegree = myBSplineCurve->Degree();
+    Standard_Integer aCont;
+
+    switch (S)
+    {
+      case GeomAbs_C1:
+        aCont = 1;
+        break;
+      case GeomAbs_C2:
+        aCont = 2;
+        break;
+      case GeomAbs_C3:
+        aCont = 3;
+        break;
+      case GeomAbs_CN:
+        aCont = aDegree;
+        break;
+      default:
+        throw Standard_DomainError ("GeomAdaptor_Curve::NbIntervals()");
+    }
+
+    Standard_Real anEps = Min(Resolution(Precision::Confusion()), Precision::PConfusion());
+
+    return BSplCLib::Intervals(myBSplineCurve->Knots(),
+                               myBSplineCurve->Multiplicities(),
+                               aDegree,
+                               myBSplineCurve->IsPeriodic(),
+                               aCont,
+                               myFirst,
+                               myLast,
+                               anEps,
+                               nullptr);
   }
   
   else if (myTypeCurve == GeomAbs_OffsetCurve) {
+    Standard_Integer myNbIntervals = 1;
     GeomAbs_Shape BaseS=GeomAbs_C0;
     switch(S){
-    case GeomAbs_G1:
-    case GeomAbs_G2:
-      throw Standard_DomainError("GeomAdaptor_Curve::NbIntervals");
-      break;
-    case GeomAbs_C0: BaseS = GeomAbs_C1; break;
-    case GeomAbs_C1: BaseS = GeomAbs_C2; break;
-    case GeomAbs_C2: BaseS = GeomAbs_C3; break;
-    default: BaseS = GeomAbs_CN;
+      case GeomAbs_G1:
+        case GeomAbs_G2:
+          throw Standard_DomainError("GeomAdaptor_Curve::NbIntervals");
+          break;
+          case GeomAbs_C0: BaseS = GeomAbs_C1; break;
+          case GeomAbs_C1: BaseS = GeomAbs_C2; break;
+          case GeomAbs_C2: BaseS = GeomAbs_C3; break;
+          default: BaseS = GeomAbs_CN;
     }
-    GeomAdaptor_Curve C
-      (Handle(Geom_OffsetCurve)::DownCast (myCurve)->BasisCurve());
+    GeomAdaptor_Curve C (Handle(Geom_OffsetCurve)::DownCast (myCurve)->BasisCurve(), myFirst, myLast);
     // akm 05/04/02 (OCC278)  If our curve is trimmed we must recalculate 
     //                    the number of intervals obtained from the basis to
     //              vvv   reflect parameter bounds
@@ -680,211 +322,16 @@ Standard_Integer GeomAdaptor_Curve::NbIntervals(const GeomAbs_Shape S) const
       TColStd_Array1OfReal rdfInter(1,1+iNbBasisInt);
       C.Intervals(rdfInter,BaseS);
       for (iInt=1; iInt<=iNbBasisInt; iInt++)
-	if (rdfInter(iInt)>myFirst && rdfInter(iInt)<myLast)
-	  myNbIntervals++;
+        if (rdfInter(iInt)>myFirst && rdfInter(iInt)<myLast)
+          myNbIntervals++;
     }
     // akm 05/04/02 ^^^
+    return myNbIntervals;
   }
-  return myNbIntervals;
-}
 
-//=======================================================================
-//function : WriteIntervals
-//purpose  :
-//=======================================================================
-
-static void WriteIntervals(const TColStd_Array1OfReal &theTK,
-  const TColStd_Array1OfInteger &theInter,
-  const Standard_Integer theNbInt,
-  const Standard_Integer theIndex1,
-  const Standard_Integer theIndex2,
-  const Standard_Real theCurPeriod,
-  const Standard_Boolean theFlagForFirst,
-  TColStd_Array1OfReal &theT,
-  TColStd_Array1OfInteger &theFinalIntervals,
-  Standard_Integer &theNbIntervals,
-  Standard_Integer &theCurInt)
-{
-  if (theFlagForFirst)
-  {
-    for (Standard_Integer anId = 1; anId <= theNbInt; anId++)
-    {
-      if (theInter(anId) > theIndex1 && theInter(anId) <= theIndex2)
-      {
-        theNbIntervals++;
-        theFinalIntervals(theNbIntervals) = theInter(anId);
-      }
-    }
-  }
   else
   {
-    for (Standard_Integer anId = 1; anId <= theNbInt; anId++)
-    {
-      if (theInter(anId) > theIndex1 && theInter(anId) < theIndex2)
-      {
-        theNbIntervals++;
-        theFinalIntervals(theNbIntervals) = theInter(anId);
-      }
-    }
-  }
- 
-  theFinalIntervals(theNbIntervals + 1) = theIndex2;
-
-  for (Standard_Integer anId = theCurInt; anId <= theNbIntervals + 1; anId++)
-  {
-    theT(anId) = theTK(theFinalIntervals(anId)) + theCurPeriod;
-    theCurInt++;
-  }
-}
-
-//=======================================================================
-//function : SpreadInt
-//purpose  :
-//=======================================================================
-
-void SpreadInt(const TColStd_Array1OfReal &theTK,
-  const TColStd_Array1OfInteger &theTM,
-  const TColStd_Array1OfInteger &theInter,
-  const Standard_Integer theCurDegree,
-  const Standard_Integer theNb,
-  const Standard_Integer theFPer,
-  const Standard_Integer theLPer,
-  const Standard_Integer theNbInt,
-  const Standard_Real theLower,
-  const Standard_Real theFirst,
-  const Standard_Real theLast,
-  const Standard_Real thePeriod,
-  const Standard_Real theLastParam,
-  const Standard_Real theEps,
-  TColStd_Array1OfReal &theT,
-  Standard_Integer &theNbIntervals)
-{
-  Standard_Integer anIndex1 = 0;
-  Standard_Integer anIndex2 = 0;
-  Standard_Real aNewFirst, aNewLast;
-  Standard_Integer anUpper;
-  BSplCLib::LocateParameter(theCurDegree, theTK, theTM, theFirst,
-    Standard_True, 1, theNb, anIndex1, aNewFirst);
-  BSplCLib::LocateParameter(theCurDegree, theTK, theTM, theLastParam,
-    Standard_True, 1, theNb, anIndex2, aNewLast);
-
-  if (Abs(aNewFirst - theTK(anIndex1 + 1)) < theEps)
-  {
-    anIndex1++;
-  }
-  if ((aNewLast - theTK(anIndex2)) > theEps)
-  {
-    anIndex2++;
-  }
-  theNbIntervals = 1;
-
-  if (anIndex1 == theNb)
-  {
-    anIndex1 = 1;
-  }
-
-  // Count the max number of boundaries of intervals
-  if (Abs(theLPer - theFPer) > 1)
-  {
-    anUpper = theNb - anIndex1 + anIndex2 + (theLPer - theFPer - 1) * theNb + 1;
-  }
-  else
-  {
-    anUpper = theNb - anIndex1 + anIndex2 + 1;
-  }
-
-  if (theLPer == theFPer)
-  {
-    anUpper = theInter.Upper();
-  }
-  TColStd_Array1OfInteger aFinalIntervals(1, anUpper);
-  aFinalIntervals(1) = anIndex1;
-
-  // If first and last are in the same period
-  if ((Abs(theLPer - theFPer) == 0))
-  {
-    Standard_Integer aCurInt = 1;
-    Standard_Real aCurPeriod = theFPer * thePeriod;
-
-    if (theFirst == aNewFirst && theLast == aNewLast)
-    {
-      aCurPeriod = 0;
-    }
-    WriteIntervals(theTK, theInter, theNbInt, anIndex1,
-      anIndex2, aCurPeriod, Standard_False, theT, aFinalIntervals, theNbIntervals, aCurInt);
-    return;
-  }
-
-  // If the first and the last are in neighboring periods
-  if (Abs(theLPer - theFPer) == 1)
-  {
-    Standard_Integer aCurInt = 1;
-
-    if (Abs(theLastParam - theLower) < theEps)
-    {
-      WriteIntervals(theTK, theInter, theNbInt, anIndex1,
-        theNb, theFPer * thePeriod, Standard_True, theT, aFinalIntervals, theNbIntervals, aCurInt);
-      return;
-    }
-    else
-    {
-      // For period with first
-      WriteIntervals(theTK, theInter, theNbInt, anIndex1,
-        theNb, theFPer * thePeriod, Standard_True, theT, aFinalIntervals, theNbIntervals, aCurInt);
-      // For period with last
-      theNbIntervals++;
-      WriteIntervals(theTK, theInter, theNbInt, 1,
-        anIndex2, theLPer * thePeriod, Standard_False, theT, aFinalIntervals, theNbIntervals, aCurInt);
-      return;
-    }
-  }
-  // If the first and the last are far apart
-  if (Abs(theLPer - theFPer) > 1)
-  {
-    Standard_Integer aCurInt = 1;
-
-    if (Abs(theLastParam - theLower) < theEps)
-    {
-      WriteIntervals(theTK, theInter, theNbInt, anIndex1,
-        theNb, theFPer * thePeriod, Standard_True, theT, aFinalIntervals, theNbIntervals, aCurInt);
-
-      Standard_Integer aNbPer = Abs(theLPer - theFPer);
-      Standard_Integer aCurPer = theFPer + 1;
-
-      while (aNbPer > 1)
-      {
-        theNbIntervals++;
-        WriteIntervals(theTK, theInter, theNbInt, 1,
-          theNb, aCurPer * thePeriod, Standard_True, theT, aFinalIntervals, theNbIntervals, aCurInt);
-        
-        aNbPer--;
-        aCurPer++;
-      }
-      return;
-    }
-    else
-    {
-      // For period with first
-      WriteIntervals(theTK, theInter, theNbInt, anIndex1,
-        theNb, theFPer * thePeriod, Standard_True, theT, aFinalIntervals, theNbIntervals, aCurInt);
-      
-      Standard_Integer aNbPer = Abs(theLPer - theFPer);
-      Standard_Integer aCurPer = theFPer + 1;
-      while (aNbPer > 1)
-      {
-        theNbIntervals++;
-        WriteIntervals(theTK, theInter, theNbInt, 1,
-          theNb, aCurPer * thePeriod, Standard_True, theT, aFinalIntervals, theNbIntervals, aCurInt);
-
-        aNbPer--;
-        aCurPer++;
-      }
-      // For period with last
-      theNbIntervals++;
-      WriteIntervals(theTK, theInter, theNbInt, 1,
-        anIndex2, theLPer * thePeriod, Standard_False, theT, aFinalIntervals, theNbIntervals, aCurInt);
-      return;
-    }
+    return 1;
   }
 }
 
@@ -893,175 +340,53 @@ void SpreadInt(const TColStd_Array1OfReal &theTK,
 //purpose  : 
 //=======================================================================
 
-void GeomAdaptor_Curve::Intervals(TColStd_Array1OfReal& T,
-                                  const GeomAbs_Shape S   ) const
+void GeomAdaptor_Curve::Intervals (TColStd_Array1OfReal& T, const GeomAbs_Shape S) const
 {
-  Standard_Integer myNbIntervals = 1;
-  Standard_Integer NbSplit;
-  Standard_Real FirstParam = myFirst, LastParam = myLast;
-
   if (myTypeCurve == GeomAbs_BSplineCurve)
   {
-    Standard_Integer FirstIndex = myBSplineCurve->FirstUKnotIndex();
-    Standard_Integer LastIndex = myBSplineCurve->LastUKnotIndex();
-    TColStd_Array1OfInteger Inter(1, LastIndex - FirstIndex + 1);
-    Standard_Boolean aContPer = (S >= Continuity()) && myBSplineCurve->IsPeriodic();
-    Standard_Boolean aContNotPer = (S > Continuity()) && !myBSplineCurve->IsPeriodic();
-
-    if (aContPer || aContNotPer) {
-      Standard_Integer Cont;
-      switch (S) {
-      case GeomAbs_G1:
-      case GeomAbs_G2:
-        throw Standard_DomainError("Geom2dAdaptor_Curve::NbIntervals");
-        break;
-      case GeomAbs_C0:
-        myNbIntervals = 1;
-        break;
-      case GeomAbs_C1:
-      case GeomAbs_C2:
-      case GeomAbs_C3:
-      case GeomAbs_CN:
-      {
-        if (S == GeomAbs_C1) Cont = 1;
-        else if (S == GeomAbs_C2) Cont = 2;
-        else if (S == GeomAbs_C3) Cont = 3;
-        else                       Cont = myBSplineCurve->Degree();
-        Standard_Integer Degree = myBSplineCurve->Degree();
-        Standard_Integer NbKnots = myBSplineCurve->NbKnots();
-        TColStd_Array1OfInteger Mults(1, NbKnots);
-        myBSplineCurve->Multiplicities(Mults);
-        NbSplit = 1;
-        Standard_Integer Index = FirstIndex;
-        Inter(NbSplit) = Index;
-        Index++;
-        NbSplit++;
-        while (Index < LastIndex)
-        {
-          if (Degree - Mults(Index) < Cont)
-          {
-            Inter(NbSplit) = Index;
-            NbSplit++;
-          }
-          Index++;
-        }
-        Inter(NbSplit) = Index;
-        Standard_Integer NbInt = NbSplit - 1;
-        //        GeomConvert_BSplineCurveKnotSplitting Convector(myBspl, Cont);
-        //        Standard_Integer NbInt = Convector.NbSplits()-1;
-        //        TColStd_Array1OfInteger Inter(1,NbInt+1);
-        //        Convector.Splitting( Inter);
-
-        Standard_Integer Nb = myBSplineCurve->NbKnots();
-        Standard_Integer Index1 = 0;
-        Standard_Integer Index2 = 0;
-        Standard_Real newFirst, newLast;
-        const TColStd_Array1OfReal& TK = myBSplineCurve->Knots();
-        const TColStd_Array1OfInteger& TM = myBSplineCurve->Multiplicities();
-        Standard_Real Eps = Min(Resolution(Precision::Confusion()),
-          Precision::PConfusion());
-
-        if (!myBSplineCurve->IsPeriodic() || ((Abs(myFirst - myBSplineCurve->FirstParameter()) < Eps) &&
-          (Abs(myLast - myBSplineCurve->LastParameter()) < Eps)))
-        {
-          BSplCLib::LocateParameter(myBSplineCurve->Degree(), TK, TM, myFirst,
-            myBSplineCurve->IsPeriodic(),
-            1, Nb, Index1, newFirst);
-          BSplCLib::LocateParameter(myBSplineCurve->Degree(), TK, TM, myLast,
-            myBSplineCurve->IsPeriodic(),
-            1, Nb, Index2, newLast);
-          FirstParam = newFirst;
-          LastParam = newLast;
-          // Protection against myFirst = UFirst - eps, which located as ULast - eps
-          if (myBSplineCurve->IsPeriodic() && (LastParam - FirstParam) < Precision::PConfusion())
-          {
-            if (Abs(LastParam - myBSplineCurve->FirstParameter()) < Precision::PConfusion())
-              LastParam += myBSplineCurve->Period();
-            else
-              FirstParam -= myBSplineCurve->Period();
-          }
-          // On decale eventuellement les indices  
-          // On utilise une "petite" tolerance, la resolution ne doit 
-          // servir que pour les tres longue courbes....(PRO9248)
-
-          if (Abs(FirstParam - TK(Index1 + 1)) < Eps) Index1++;
-          if (LastParam - TK(Index2) > Eps) Index2++;
-
-          myNbIntervals = 1;
-
-          TColStd_Array1OfInteger aFinalIntervals(1, Inter.Upper());
-          aFinalIntervals(1) = Index1;
-          for (Standard_Integer i = 1; i <= NbInt; i++) {
-            if (Inter(i) > Index1 && Inter(i) < Index2) {
-              myNbIntervals++;
-              aFinalIntervals(myNbIntervals) = Inter(i);
-            }
-          }
-          aFinalIntervals(myNbIntervals + 1) = Index2;
-
-          for (Standard_Integer I = 1; I <= myNbIntervals + 1; I++) {
-            T(I) = TK(aFinalIntervals(I));
-          }
-        }
-        else
-        {
-          Standard_Real aFirst = myFirst;
-          Standard_Real aLast = myLast;
-
-          Standard_Real aCurFirst = aFirst;
-          Standard_Real aCurLast = aLast;
-
-          Standard_Real aPeriod = myBSplineCurve->Period();
-          Standard_Real aLower = myBSplineCurve->FirstParameter();
-          Standard_Real anUpper = myBSplineCurve->LastParameter();
-
-          Standard_Integer aLPer = 0; Standard_Integer aFPer = 0;
-
-          if (Abs(myFirst - aLower) <= Eps)
-          {
-            aCurFirst = aLower;
-            aFirst = aCurFirst;
-          }
-
-          if (Abs(myLast - anUpper) <= Eps)
-          {
-            aCurLast = anUpper;
-            aLast = aCurLast;
-          }
-
-          if ((Abs(aLower - myFirst) < Eps) && (aCurFirst < aLower))
-          {
-            aCurFirst = aLower;
-          }
-          else
-          {
-            DefinFPeriod(aLower, anUpper,
-              Eps, aPeriod, aCurFirst, aFPer);
-          }
-          DefinLPeriod(aLower, anUpper,
-            Eps, aPeriod, aCurLast, aLPer);
-
-          if (myFirst == aLower)
-          {
-            aFPer = 0;
-          }
-
-          SpreadInt(TK, TM, Inter, myBSplineCurve->Degree(), Nb, aFPer, aLPer, NbInt, aLower, myFirst, myLast, aPeriod,
-            aCurLast, Eps, T, myNbIntervals);
-
-          T(T.Lower()) = aFirst;
-          T(T.Lower() + myNbIntervals) = aLast;
-          return;
-        }
-      }
-      T(T.Lower()) = myFirst;
-      T(T.Lower() + myNbIntervals) = myLast;
+    if ((!myBSplineCurve->IsPeriodic() && S <= Continuity()) || S == GeomAbs_C0)
+    {
+      T( T.Lower() ) = myFirst;
+      T( T.Lower() + 1 ) = myLast;
       return;
-      }
     }
+
+    Standard_Integer aDegree = myBSplineCurve->Degree();
+    Standard_Integer aCont;
+
+    switch (S)
+    {
+      case GeomAbs_C1:
+        aCont = 1;
+        break;
+      case GeomAbs_C2:
+        aCont = 2;
+        break;
+      case GeomAbs_C3:
+        aCont = 3;
+        break;
+      case GeomAbs_CN:
+        aCont = aDegree;
+        break;
+      default:
+        throw Standard_DomainError ("GeomAdaptor_Curve::Intervals()");
+    }
+
+    Standard_Real anEps = Min(Resolution(Precision::Confusion()), Precision::PConfusion());
+
+    BSplCLib::Intervals(myBSplineCurve->Knots(),
+                        myBSplineCurve->Multiplicities(),
+                        aDegree,
+                        myBSplineCurve->IsPeriodic(),
+                        aCont,
+                        myFirst,
+                        myLast,
+                        anEps,
+                        &T);
   }
 
   else if (myTypeCurve == GeomAbs_OffsetCurve){
+    Standard_Integer myNbIntervals = 1;
     GeomAbs_Shape BaseS=GeomAbs_C0;
     switch(S){
     case GeomAbs_G1:
@@ -1073,8 +398,7 @@ void GeomAdaptor_Curve::Intervals(TColStd_Array1OfReal& T,
     case GeomAbs_C2: BaseS = GeomAbs_C3; break;
     default: BaseS = GeomAbs_CN;
     }
-    GeomAdaptor_Curve C
-      (Handle(Geom_OffsetCurve)::DownCast (myCurve)->BasisCurve());
+    GeomAdaptor_Curve C (Handle(Geom_OffsetCurve)::DownCast (myCurve)->BasisCurve(), myFirst, myLast);
     // akm 05/04/02 (OCC278)  If our curve is trimmed we must recalculate 
     //                    the array of intervals obtained from the basis to
     //              vvv   reflect parameter bounds
@@ -1090,10 +414,15 @@ void GeomAdaptor_Curve::Intervals(TColStd_Array1OfReal& T,
     // old - myNbIntervals = C.NbIntervals(BaseS);
     // old - C.Intervals(T, BaseS);
     // akm 05/04/02 ^^^
+    T( T.Lower() ) = myFirst;
+    T( T.Lower() + myNbIntervals ) = myLast;
   }
   
-  T( T.Lower() ) = FirstParam;
-  T( T.Lower() + myNbIntervals ) = LastParam;
+  else
+  {
+    T( T.Lower() ) = myFirst;
+    T( T.Lower() + 1 ) = myLast;
+  }
 }
 
 //=======================================================================

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/GeomFill/GeomFill_SectionPlacement.cxx

@@ -276,6 +276,8 @@ GeomFill_SectionPlacement(const Handle(GeomFill_LocationLaw)& L,
 	      
 	      Standard_Integer NbLocalPnts = 10;
 	      Standard_Integer NbPnts = (NbKnots-1) * NbLocalPnts;
+	      if (NbPnts < 0)
+	        NbPnts = 0;
 	      if (I1 != I2)
 		NbPnts += NbLocalPnts;
 	      if (I3 != I4 && first < BC->Knot(I3))

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/GeomLib/GeomLib_IsPlanarSurface.cxx

@@ -30,18 +30,6 @@
 #include <TColgp_Array1OfPnt.hxx>
 #include <TColgp_HArray1OfPnt.hxx>
 
-static Standard_Boolean Controle(const TColgp_Array1OfPnt& P,
-			  const gp_Pln& Plan,
-			  const Standard_Real Tol) 
-{
-  Standard_Integer ii;
-  Standard_Boolean B=Standard_True;
-
-  for (ii=1; ii<=P.Length() && B; ii++)  
-      B = (Plan.Distance(P(ii)) < Tol);
-    
-  return B;
-}
 
 static Standard_Boolean Controle(const TColgp_Array1OfPnt& Poles,
 				 const Standard_Real Tol,
@@ -49,51 +37,36 @@ static Standard_Boolean Controle(const TColgp_Array1OfPnt& Poles,
 				 gp_Pln& Plan) 
 {
   Standard_Boolean IsPlan = Standard_False;
-  Standard_Boolean Essai = Standard_True;
   Standard_Real gx,gy,gz;
-  Standard_Integer Nb = Poles.Length();
-    gp_Pnt Bary;
+  gp_Pnt Bary;
   gp_Dir DX, DY;
+  Standard_Real aTolSingular = Precision::Confusion();
 
-  
-  if (Nb > 10) {
-    // Test allege (pour une rejection rapide)
-    TColgp_Array1OfPnt Aux(1,5);
-    Aux(1) = Poles(1);
-    Aux(2) = Poles(Nb/3);
-    Aux(3) = Poles(Nb/2);
-    Aux(4) = Poles(Nb/2+Nb/3);
-    Aux(5) =  Poles(Nb);
-    GeomLib::Inertia(Aux, Bary, DX, DY, gx, gy, gz);
-    Essai = (gz<Tol);
-  }
-  
-  if (Essai) { // Test Grandeur nature...
-    GeomLib::Inertia(Poles, Bary, DX, DY, gx, gy, gz);
-    if (gz<Tol && gy>Tol) {
-      gp_Pnt P;
-      gp_Vec DU, DV;
-      Standard_Real umin, umax, vmin, vmax;
-      S->Bounds(umin, umax, vmin, vmax);
-      S->D1( (umin+umax)/2, (vmin+vmax)/2, P, DU, DV);
-      // On prend DX le plus proche possible de DU
-      gp_Dir du(DU);
-      Standard_Real Angle1 = du.Angle(DX);
-      Standard_Real Angle2 = du.Angle(DY);
-      if (Angle1 > M_PI/2) Angle1 = M_PI-Angle1;
-      if (Angle2 > M_PI/2) Angle2 = M_PI-Angle2;
-      if (Angle2 < Angle1) {
-	du = DY; DY = DX; DX = du;
-      }
-      if (DX.Angle(DU) > M_PI/2) DX.Reverse();
-      if (DY.Angle(DV) > M_PI/2) DY.Reverse();      
-
-      gp_Ax3 axe(Bary, DX^DY, DX);
-      Plan.SetPosition(axe);
-      Plan.SetLocation(Bary);
-      IsPlan = Standard_True;
+    
+  GeomLib::Inertia(Poles, Bary, DX, DY, gx, gy, gz);
+  if (gz < Tol && gy > aTolSingular) {
+    gp_Pnt P;
+    gp_Vec DU, DV;
+    Standard_Real umin, umax, vmin, vmax;
+    S->Bounds(umin, umax, vmin, vmax);
+    S->D1((umin + umax) / 2, (vmin + vmax) / 2, P, DU, DV);
+    // On prend DX le plus proche possible de DU
+    gp_Dir du(DU);
+    Standard_Real Angle1 = du.Angle(DX);
+    Standard_Real Angle2 = du.Angle(DY);
+    if (Angle1 > M_PI / 2) Angle1 = M_PI - Angle1;
+    if (Angle2 > M_PI / 2) Angle2 = M_PI - Angle2;
+    if (Angle2 < Angle1) {
+      du = DY; DY = DX; DX = du;
     }
-  }   
+    if (DX.Angle(DU) > M_PI / 2) DX.Reverse();
+    if (DY.Angle(DV) > M_PI / 2) DY.Reverse();
+
+    gp_Ax3 axe(Bary, DX^DY, DX);
+    Plan.SetPosition(axe);
+    Plan.SetLocation(Bary);
+    IsPlan = Standard_True;
+  }
   return IsPlan;
 }
 
@@ -106,8 +79,6 @@ static Standard_Boolean Controle(const Handle(Geom_Curve)& C,
   GeomAbs_CurveType Type;
   GeomAdaptor_Curve AC(C);
   Type = AC.GetType();
-  Handle(TColgp_HArray1OfPnt) TabP;
-  TabP.Nullify();
 
   switch (Type) {
   case GeomAbs_Line :
@@ -131,40 +102,27 @@ static Standard_Boolean Controle(const Handle(Geom_Curve)& C,
   case GeomAbs_BezierCurve:
     {
       Nb =  AC.NbPoles();
-      Handle (Geom_BezierCurve) BZ = AC.Bezier();
-      TabP = new (TColgp_HArray1OfPnt) (1, AC.NbPoles());
-      for (ii=1; ii<=Nb; ii++) 
-	TabP->SetValue(ii, BZ->Pole(ii));
       break; 
     }
   case GeomAbs_BSplineCurve:
     {
       Nb =  AC.NbPoles();
-      Handle (Geom_BSplineCurve) BZ = AC.BSpline();
-      TabP = new (TColgp_HArray1OfPnt) (1, AC.NbPoles());
-      for (ii=1; ii<=Nb; ii++) 
-	TabP->SetValue(ii, BZ->Pole(ii));
       break; 
     }
-    default :
-      {
-	Nb = 8 + 3*AC.NbIntervals(GeomAbs_CN);
-      }
-  }
- 
-  if (TabP.IsNull()) {
-    Standard_Real u, du, f, l, d;
-    f = AC.FirstParameter();
-    l = AC.LastParameter();
-    du = (l-f)/(Nb-1);
-    for (ii=1; ii<=Nb && B ; ii++) {
-      u = (ii-1)*du + f;
-      d = Plan.Distance(C->Value(u));
-      B = (d < Tol); 
+  default :
+    {
+	 Nb = 8 + 3*AC.NbIntervals(GeomAbs_CN);
     }
   }
-  else {
-    B = Controle(TabP->Array1(), Plan, Tol);
+ 
+  Standard_Real u, du, f, l, d;
+  f = AC.FirstParameter();
+  l = AC.LastParameter();
+  du = (l - f) / (Nb - 1);
+  for (ii = 1; ii <= Nb && B; ii++) {
+    u = (ii - 1)*du + f;
+    d = Plan.Distance(C->Value(u));
+    B = d < Tol;
   }
 
   return B;
@@ -196,30 +154,6 @@ GeomLib_IsPlanarSurface::GeomLib_IsPlanarSurface(const Handle(Geom_Surface)& S,
      IsPlan = Standard_False;
      break;
     }
-  case GeomAbs_BezierSurface :
-  case GeomAbs_BSplineSurface :
-    {
-      Standard_Integer ii, jj, kk,
-      NbU = AS.NbUPoles(), NbV = AS.NbVPoles(); 
-      TColgp_Array1OfPnt Poles(1, NbU*NbV);
-      if (Type == GeomAbs_BezierSurface) {
-	Handle(Geom_BezierSurface) BZ;
-	BZ = AS.Bezier();
-	for(ii=1, kk=1; ii<=NbU; ii++)
-	  for(jj=1; jj<=NbV; jj++,kk++)
-	    Poles(kk) = BZ->Pole(ii,jj);
-      }
-      else {
-	Handle(Geom_BSplineSurface) BS;
-	BS = AS.BSpline();
-	for(ii=1, kk=1; ii<=NbU; ii++)
-	  for(jj=1; jj<=NbV; jj++,kk++)
-	    Poles(kk) = BS->Pole(ii,jj);
-      }
-
-      IsPlan =  Controle(Poles, Tol, S, myPlan);
-      break;      
-    }
 
   case GeomAbs_SurfaceOfRevolution :
     {
@@ -299,7 +233,7 @@ GeomLib_IsPlanarSurface::GeomLib_IsPlanarSurface(const Handle(Geom_Surface)& S,
       break;
     }
 
-    default :
+  default :
       {
 	Standard_Integer NbU,NbV, ii, jj, kk; 
 	NbU = 8 + 3*AS.NbUIntervals(GeomAbs_CN);