0025039: Improvement of code structure of general and supporting tools implemented...
authoroan <oan@opencascade.com>
Thu, 10 Jul 2014 10:51:15 +0000 (14:51 +0400)
committerapn <apn@opencascade.com>
Thu, 10 Jul 2014 10:51:50 +0000 (14:51 +0400)
Removed CDL declarations; Data collections are replaced by NCollections; Small code refactoring.
Remove definition of BRepMesh class. Code refactoring of BRepMesh_IncrementalMesh.
Function BRepMesh_Write storing BRepMesh_DataStructureOfDelaun to BRep file is added for debug needs.
Static method BRepMesh_GeomTool::IntLinLin has been added to eliminate code duplications in BRepMesh_Dealun and BRepMesh_CircleTool.
BRepMesh_CircleTool simplified method to find circumcircle.

Fix merging conflicts
Remove redundant function
Fix compilation warning on MacOS
Revert changes occurred during rebase
Resolved merging conflicts
Use parallel flag with BRepMesh_FastDiscret

Test cases for issue CR25039_2

109 files changed:
dox/dev_guides/debug/debug.md
src/BRepMesh/BRepMesh.cdl
src/BRepMesh/BRepMesh.cxx [deleted file]
src/BRepMesh/BRepMesh_CellFilter.hxx [deleted file]
src/BRepMesh/BRepMesh_Circ.cdl [deleted file]
src/BRepMesh/BRepMesh_Circ.cxx [deleted file]
src/BRepMesh/BRepMesh_Circ.lxx [deleted file]
src/BRepMesh/BRepMesh_Circle.hxx [new file with mode: 0644]
src/BRepMesh/BRepMesh_CircleInspector.hxx
src/BRepMesh/BRepMesh_CircleTool.cdl [deleted file]
src/BRepMesh/BRepMesh_CircleTool.cxx
src/BRepMesh/BRepMesh_CircleTool.hxx [new file with mode: 0644]
src/BRepMesh/BRepMesh_Collections.hxx [new file with mode: 0644]
src/BRepMesh/BRepMesh_ComparatorOfIndexedVertexOfDelaun.cdl [deleted file]
src/BRepMesh/BRepMesh_ComparatorOfIndexedVertexOfDelaun.cxx [deleted file]
src/BRepMesh/BRepMesh_ComparatorOfVertexOfDelaun.cdl [deleted file]
src/BRepMesh/BRepMesh_ComparatorOfVertexOfDelaun.cxx [deleted file]
src/BRepMesh/BRepMesh_DataStructureOfDelaun.cdl [deleted file]
src/BRepMesh/BRepMesh_DataStructureOfDelaun.cxx
src/BRepMesh/BRepMesh_DataStructureOfDelaun.hxx [new file with mode: 0644]
src/BRepMesh/BRepMesh_DegreeOfFreedom.hxx [moved from src/BRepMesh/BRepMesh_ClassifierPtr.hxx with 65% similarity]
src/BRepMesh/BRepMesh_Delaun.cxx
src/BRepMesh/BRepMesh_Delaun.hxx
src/BRepMesh/BRepMesh_DiscretFactory.cdl [deleted file]
src/BRepMesh/BRepMesh_DiscretFactory.cxx
src/BRepMesh/BRepMesh_DiscretFactory.hxx [new file with mode: 0644]
src/BRepMesh/BRepMesh_DiscretRoot.cdl [deleted file]
src/BRepMesh/BRepMesh_DiscretRoot.cxx
src/BRepMesh/BRepMesh_DiscretRoot.hxx [new file with mode: 0644]
src/BRepMesh/BRepMesh_Edge.cdl [deleted file]
src/BRepMesh/BRepMesh_Edge.cxx [deleted file]
src/BRepMesh/BRepMesh_Edge.hxx [new file with mode: 0644]
src/BRepMesh/BRepMesh_Edge.lxx [deleted file]
src/BRepMesh/BRepMesh_FaceAttribute.cdl [deleted file]
src/BRepMesh/BRepMesh_FaceAttribute.cxx
src/BRepMesh/BRepMesh_FaceAttribute.hxx [new file with mode: 0644]
src/BRepMesh/BRepMesh_FaceAttribute.lxx [deleted file]
src/BRepMesh/BRepMesh_FaceChecker.hxx
src/BRepMesh/BRepMesh_FactoryError.hxx [moved from src/BRepMesh/BRepMesh_BaseAllocator.hxx with 68% similarity]
src/BRepMesh/BRepMesh_FastDiscret.cdl [deleted file]
src/BRepMesh/BRepMesh_FastDiscret.cxx
src/BRepMesh/BRepMesh_FastDiscret.hxx [new file with mode: 0644]
src/BRepMesh/BRepMesh_FastDiscret.lxx [deleted file]
src/BRepMesh/BRepMesh_FastDiscretFace.cdl [deleted file]
src/BRepMesh/BRepMesh_FastDiscretFace.cxx
src/BRepMesh/BRepMesh_FastDiscretFace.hxx [new file with mode: 0644]
src/BRepMesh/BRepMesh_GeomTool.cdl [deleted file]
src/BRepMesh/BRepMesh_GeomTool.cxx
src/BRepMesh/BRepMesh_GeomTool.hxx [new file with mode: 0644]
src/BRepMesh/BRepMesh_IncrementalMesh.cxx
src/BRepMesh/BRepMesh_IncrementalMesh.hxx
src/BRepMesh/BRepMesh_ListOfInteger.hxx [deleted file]
src/BRepMesh/BRepMesh_MapOfInteger.hxx [deleted file]
src/BRepMesh/BRepMesh_MapOfIntegerInteger.hxx [deleted file]
src/BRepMesh/BRepMesh_PairOfIndex.hxx
src/BRepMesh/BRepMesh_PairOfPolygon.cdl [deleted file]
src/BRepMesh/BRepMesh_PairOfPolygon.cxx [deleted file]
src/BRepMesh/BRepMesh_PairOfPolygon.hxx [new file with mode: 0644]
src/BRepMesh/BRepMesh_PairOfPolygon.lxx [deleted file]
src/BRepMesh/BRepMesh_PluginEntryType.hxx
src/BRepMesh/BRepMesh_PluginMacro.hxx
src/BRepMesh/BRepMesh_SelectorOfDataStructureOfDelaun.cdl [deleted file]
src/BRepMesh/BRepMesh_SelectorOfDataStructureOfDelaun.cxx
src/BRepMesh/BRepMesh_SelectorOfDataStructureOfDelaun.hxx [new file with mode: 0644]
src/BRepMesh/BRepMesh_ShapeTool.cdl [deleted file]
src/BRepMesh/BRepMesh_ShapeTool.cxx
src/BRepMesh/BRepMesh_ShapeTool.hxx [new file with mode: 0644]
src/BRepMesh/BRepMesh_ShapeTool.lxx [deleted file]
src/BRepMesh/BRepMesh_Triangle.cxx [deleted file]
src/BRepMesh/BRepMesh_Triangle.hxx
src/BRepMesh/BRepMesh_VectorOfVertex.hxx [deleted file]
src/BRepMesh/BRepMesh_Vertex.cdl [deleted file]
src/BRepMesh/BRepMesh_Vertex.cxx [deleted file]
src/BRepMesh/BRepMesh_Vertex.hxx [new file with mode: 0644]
src/BRepMesh/BRepMesh_Vertex.lxx [deleted file]
src/BRepMesh/BRepMesh_VertexCellFilter.hxx [deleted file]
src/BRepMesh/BRepMesh_VertexInspector.cxx [deleted file]
src/BRepMesh/BRepMesh_VertexInspector.hxx
src/BRepMesh/BRepMesh_VertexTool.cdl [deleted file]
src/BRepMesh/BRepMesh_VertexTool.cxx
src/BRepMesh/BRepMesh_VertexTool.hxx [new file with mode: 0644]
src/BRepMesh/BRepMesh_WireChecker.cxx
src/BRepMesh/BRepMesh_WireChecker.hxx
src/BRepMesh/BRepMesh_WireInterferenceChecker.cxx
src/BRepMesh/BRepMesh_WireInterferenceChecker.hxx
src/BRepMesh/FILES
src/DBRep/DBRep_DrawableShape.cxx
src/MeshTest/FILES
src/MeshTest/MeshTest.cdl
src/MeshTest/MeshTest.cxx
src/MeshTest/MeshTest_DrawableMesh.cdl [deleted file]
src/MeshTest/MeshTest_DrawableMesh.cxx
src/MeshTest/MeshTest_DrawableMesh.hxx [new file with mode: 0644]
src/QABugs/QABugs_11.cxx
src/StdPrs/FILES
src/StdPrs/StdPrs.cdl
src/StdPrs/StdPrs_HLRPolyShape.cxx
src/StdPrs/StdPrs_ShadedShape.cxx
src/StdPrs/StdPrs_ToolShadedShape.cdl [deleted file]
src/StdPrs/StdPrs_ToolShadedShape.cxx
src/StdPrs/StdPrs_ToolShadedShape.hxx [new file with mode: 0644]
src/StdSelect/StdSelect_BRepSelectionTool.cxx
src/StlTransfer/StlTransfer.cxx
src/Voxel/Voxel_FastConverter.cxx
src/VrmlConverter/VrmlConverter_ShadedShape.cxx
src/VrmlData/VrmlData_ShapeConvert.cxx
src/XDEDRAW/XDEDRAW_Props.cxx
src/XSDRAWSTLVRML/XSDRAWSTLVRML_ToVRML.cxx
tests/mesh/data/standard/V4

index de84bfb..4a1d423 100644 (file)
@@ -80,6 +80,16 @@ const char* BRepTools_DumpLoc (void* theShapePtr)
 Dumps shape or its location to cout.
 - *theShapePtr* - a pointer to *TopoDS_Shape* variable.
 
+The following function is provided by *TKMesh* toolkit:
+
+~~~~~
+const char* BRepMesh_Dump (void* theMeshHandlePtr, const char* theFileNameStr)
+~~~~~
+
+Stores mesh produced in parametric space to BREP file.
+- *theMeshHandlePtr* - a pointer to *Handle(BRepMesh_DataStructureOfDelaun)* variable.
+- *theFileNameStr* - name of file the mesh sould be stored to.
+
 The following additional function is provided by *TKGeomBase* toolkit:
 
 ~~~~~
@@ -119,6 +129,7 @@ For convenience it is possible to define aliases to commands in this window, for
 >alias saveshape  ? ({,,TKBRep}BRepTools_Write)
 >alias dumpshape  ? ({,,TKBRep}BRepTools_Dump)
 >alias dumploc    ? ({,,TKBRep}BRepTools_DumpLoc)
+>alias dumpmesh   ? ({,,TKMesh}BRepMesh_Dump)
 >alias dumpgeom   ? ({,,TKGeomBase}GeomTools_Dump)
 ~~~~~ 
 
index 7c55409..e53dbc9 100644 (file)
@@ -44,147 +44,43 @@ uses    Standard,
         SortTools,
         Plugin
 
-
-is    enumeration DegreeOfFreedom is 
-        Free,
-        InVolume,
-        OnSurface,
-        OnCurve,
-        Fixed,
-        Frontier,
-        Deleted;
-
+is
+      imported DegreeOfFreedom from BRepMesh;
       imported Status from BRepMesh;
-       
-      enumeration FactoryError is 
-        FE_NOERROR,  
-        FE_LIBRARYNOTFOUND,
-        FE_FUNCTIONNOTFOUND,
-        FE_CANNOTCREATEALGO
-      end FactoryError;   
-      
-      class Vertex;
-
-      class Edge;
-
-         imported Triangle from BRepMesh;
-         
-      class ShapeTool;
-
-      class Circ;
-
-      deferred class DiscretRoot; 
-      class DiscretFactory;
+      imported FactoryError from BRepMesh;
+      imported Vertex from BRepMesh;
+      imported Edge from BRepMesh;
+      imported Triangle from BRepMesh;
+      imported Circle from BRepMesh;
+      imported DiscretRoot from BRepMesh; 
+      imported DiscretFactory from BRepMesh;
       --
       pointer PDiscretRoot to DiscretRoot from BRepMesh;
-      --
+      
+      imported ShapeTool from BRepMesh;
+      imported Collections from BRepMesh;
       imported Delaun from BRepMesh;
-      imported MapOfIntegerInteger from BRepMesh;
-      imported MapOfInteger from BRepMesh;
-      imported ListOfInteger from BRepMesh;
-      imported BaseAllocator from BRepMesh;
       imported PairOfIndex from BRepMesh;
       imported CircleInspector from BRepMesh;
-      imported CellFilter from BRepMesh;
       imported VertexInspector from BRepMesh;
-      imported VertexCellFilter from BRepMesh;
-      imported VectorOfVertex from BRepMesh;
       imported WireInterferenceChecker from BRepMesh;
       imported EdgeChecker from BRepMesh;
       imported FaceChecker from BRepMesh;
 
       primitive PluginEntryType;
 
-      class ComparatorOfVertexOfDelaun;
-      class ComparatorOfIndexedVertexOfDelaun;
-      class SelectorOfDataStructureOfDelaun;
-      class DataStructureOfDelaun;
-      class CircleTool;
-      class VertexTool;
-    
-      class Array1OfVertexOfDelaun instantiates Array1 from TCollection
-        (Vertex from BRepMesh);
-
-      class HArray1OfVertexOfDelaun instantiates HArray1 from TCollection
-        (Vertex from BRepMesh, Array1OfVertexOfDelaun);
-
-      class HeapSortVertexOfDelaun instantiates  HeapSort from SortTools
-        (Vertex from BRepMesh, Array1OfVertexOfDelaun,
-        ComparatorOfVertexOfDelaun from BRepMesh);
-
-      class HeapSortIndexedVertexOfDelaun instantiates  HeapSort from SortTools
-        (Integer, Array1OfInteger from TColStd,
-        ComparatorOfIndexedVertexOfDelaun from BRepMesh);
-
-      class LinkHasherOfDataStructureOfDelaun instantiates MapHasher from TCollection
-        (Edge from BRepMesh);
-      class ElemHasherOfDataStructureOfDelaun instantiates MapHasher from TCollection
-        (Triangle from BRepMesh);
-
-      class DataMapOfIntegerListOfInteger     instantiates DataMap from TCollection
-        (Integer from Standard, ListOfInteger from BRepMesh, MapIntegerHasher from TColStd);
-
-      class IDMapOfLinkOfDataStructureOfDelaun  instantiates IndexedDataMap from TCollection
-        (Edge from BRepMesh,
-        PairOfIndex from BRepMesh,
-        LinkHasherOfDataStructureOfDelaun);
-
-      class IMapOfElementOfDataStructureOfDelaun instantiates IndexedMap from TCollection
-        (Triangle from BRepMesh,
-        ElemHasherOfDataStructureOfDelaun);
-
-      class DataMapOfVertexInteger instantiates DataMap from TCollection
-          (Vertex from TopoDS, Integer from Standard, ShapeMapHasher from TopTools);
-
-      class ListOfVertex instantiates List from TCollection 
-          (Vertex from  BRepMesh);
-          
-      class ListOfXY instantiates List from TCollection (XY from gp);
-
-      class DataMapOfIntegerListOfXY  instantiates DataMap from TCollection
-          (Integer from Standard, ListOfXY from BRepMesh, MapIntegerHasher from TColStd);
-
-
-      class  VertexHasher  instantiates   MapHasher  from  TCollection(Vertex  from  BRepMesh);
-
-      class IndexedMapOfVertex instantiates IndexedMap from TCollection 
-          (Vertex from  BRepMesh,  VertexHasher from  BRepMesh);
-
-      private class FastDiscretFace;
-      
-      class FastDiscret;
-      
-      class FaceAttribute;
-  
-      class DataMapOfFaceAttribute instantiates DataMap from TCollection
-                                            (Face           from TopoDS,
-                                             FaceAttribute  from BRepMesh,
-                                             ShapeMapHasher from TopTools);
-              
+      imported SelectorOfDataStructureOfDelaun from BRepMesh;
+      imported DataStructureOfDelaun from BRepMesh;
+      imported CircleTool from BRepMesh;
+      imported VertexTool from BRepMesh;
+      imported BiPoint from BRepMesh;
+      imported FastDiscretFace from BRepMesh;
+      imported FastDiscret from BRepMesh;
+      imported FaceAttribute from BRepMesh;
       imported Classifier from BRepMesh;
-      imported ClassifierPtr; -- smart pointer on Classifier
       imported WireChecker from BRepMesh;
-
       imported IncrementalMesh from BRepMesh;
+      imported GeomTool from BRepMesh;
+      imported PairOfPolygon from BRepMesh;
 
-
-         ---- classes moved from MeshShape
-      class GeomTool;
-
-      class DataMapOfIntegerPnt instantiates
-          DataMap from TCollection   (Integer          from Standard,
-                                      Pnt              from gp,
-                                      MapIntegerHasher from TColStd);
-
-      class PairOfPolygon;
-
-      class DataMapOfShapePairOfPolygon instantiates 
-      DataMap from TCollection(Shape          from TopoDS,
-                               PairOfPolygon  from BRepMesh,
-                               ShapeMapHasher from TopTools);
-
-      Mesh(S: Shape from TopoDS; d: Real from Standard);
-      ---Purpose: call to incremental mesh.
-
-  
 end BRepMesh;
diff --git a/src/BRepMesh/BRepMesh.cxx b/src/BRepMesh/BRepMesh.cxx
deleted file mode 100644 (file)
index 3013a41..0000000
+++ /dev/null
@@ -1,27 +0,0 @@
-// Created on: 1996-08-07
-// Created by: Laurent PAINNOT
-// Copyright (c) 1996-1999 Matra Datavision
-// Copyright (c) 1999-2014 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 <BRepMesh.ixx>
-#include <BRepMesh_IncrementalMesh.hxx>
-#include <TopoDS_Shape.hxx>
-
-
-void BRepMesh::Mesh(const TopoDS_Shape& S,
-                   const Standard_Real d)
-{
-  BRepMesh_IncrementalMesh M(S, d);
-
-}
diff --git a/src/BRepMesh/BRepMesh_CellFilter.hxx b/src/BRepMesh/BRepMesh_CellFilter.hxx
deleted file mode 100644 (file)
index 82f1211..0000000
+++ /dev/null
@@ -1,21 +0,0 @@
-// Created on: 2008-05-26
-// Created by: Ekaterina SMIRNOVA
-// Copyright (c) 2008-2014 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 <gp_XYZ.hxx>
-#include <gp_XY.hxx>
-#include <NCollection_CellFilter.hxx>
-#include <BRepMesh_CircleInspector.hxx>
-
-typedef NCollection_CellFilter<BRepMesh_CircleInspector> BRepMesh_CellFilter;
diff --git a/src/BRepMesh/BRepMesh_Circ.cdl b/src/BRepMesh/BRepMesh_Circ.cdl
deleted file mode 100644 (file)
index fb48225..0000000
+++ /dev/null
@@ -1,54 +0,0 @@
--- Created on: 1993-08-09
--- Created by: Didier PIFFAULT
--- Copyright (c) 1993-1999 Matra Datavision
--- Copyright (c) 1999-2014 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.
-
-class Circ from BRepMesh 
-
-  ---Purpose: Describes  a  2d circle  with  a   size of  only 3
-  --          Standard Real  numbers instead  of gp who  needs 7
-  --          Standard Real numbers.
-
-  uses    Real from Standard,
-          XY from gp
-
-
-  is      Create returns Circ from BRepMesh;
-
-          Create (loc : XY from gp; rad : Real from Standard)
-          returns Circ from BRepMesh;
-
-          SetLocation(me : in out; loc : XY from gp)
-          is static;
-
-          SetRadius  (me : in out; rad : Real from Standard)
-          is static;
-
-          Location   (me)
-          ---C++: return const &
-          ---C++: inline
-          returns XY from gp
-          is static;
-
-          Radius     (me)
-          ---C++: return const &
-          ---C++: inline
-          returns Real from Standard
-          is static;
-
-
-fields  location : XY from gp;
-        radius   : Real from Standard;
-
-end Circ;
diff --git a/src/BRepMesh/BRepMesh_Circ.cxx b/src/BRepMesh/BRepMesh_Circ.cxx
deleted file mode 100644 (file)
index 96a185b..0000000
+++ /dev/null
@@ -1,34 +0,0 @@
-// Created on: 1993-08-09
-// Created by: Didier PIFFAULT
-// Copyright (c) 1993-1999 Matra Datavision
-// Copyright (c) 1999-2014 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 <BRepMesh_Circ.hxx>
-
-BRepMesh_Circ::BRepMesh_Circ()
-{}
-
-BRepMesh_Circ::BRepMesh_Circ(const gp_XY& loc, const Standard_Real rad)
-: location(loc), radius(rad)
-{}
-
-void BRepMesh_Circ::SetLocation(const gp_XY& loc)
-{
-  location=loc;
-}
-
-void BRepMesh_Circ::SetRadius(const Standard_Real rad)
-{
-  radius=rad;
-}
diff --git a/src/BRepMesh/BRepMesh_Circ.lxx b/src/BRepMesh/BRepMesh_Circ.lxx
deleted file mode 100644 (file)
index 07cab56..0000000
+++ /dev/null
@@ -1,21 +0,0 @@
-// Created on: 1993-08-09
-// Created by: Didier PIFFAULT
-// Copyright (c) 1993-1999 Matra Datavision
-// Copyright (c) 1999-2014 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.
-
-inline const gp_XY& BRepMesh_Circ::Location() const
-{ return location;}
-
-inline const Standard_Real& BRepMesh_Circ::Radius() const
-{ return radius;}
diff --git a/src/BRepMesh/BRepMesh_Circle.hxx b/src/BRepMesh/BRepMesh_Circle.hxx
new file mode 100644 (file)
index 0000000..3f8f419
--- /dev/null
@@ -0,0 +1,77 @@
+// Copyright (c) 2013 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 _BRepMesh_Circle_HeaderFile
+#define _BRepMesh_Circle_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Macro.hxx>
+#include <gp_XY.hxx>
+
+//! Describes a 2d circle with a size of only 3 Standard_Real 
+//! numbers instead of gp who needs 7 Standard_Real numbers.
+class BRepMesh_Circle
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+
+  //! Default constructor.
+  Standard_EXPORT BRepMesh_Circle()
+  {
+  }
+  
+  //! Constructor.
+  //! \param theLocation location of a circle.
+  //! \param theRadius radius of a circle.
+  Standard_EXPORT BRepMesh_Circle(const gp_XY&        theLocation,
+                                  const Standard_Real theRadius)
+    : myLocation(theLocation),
+      myRadius  (theRadius)
+  {
+  }
+  
+  //! Sets location of a circle.
+  //! \param theLocation location of a circle.
+  inline void SetLocation(const gp_XY& theLocation)
+  {
+    myLocation = theLocation;
+  }
+  
+  //! Sets radius of a circle.
+  //! \param theRadius radius of a circle.
+  inline void SetRadius(const Standard_Real theRadius)
+  {
+    myRadius = theRadius;
+  }
+  
+  //! Returns location of a circle.
+  inline const gp_XY& Location() const
+  {
+    return myLocation;
+  }
+
+  //! Returns radius of a circle.
+  inline const Standard_Real& Radius() const
+  {
+    return myRadius;
+  }
+
+private:
+
+  gp_XY         myLocation;
+  Standard_Real myRadius;
+};
+
+#endif
index 5ae64ad..311dfe7 100644 (file)
 #ifndef BRepMesh_CircleInspector_Header
 #define BRepMesh_CircleInspector_Header
 
-#include <BRepMesh_Circ.hxx>
-
-#include <BRepMesh_ListOfInteger.hxx>
+#include <BRepMesh_Collections.hxx>
+#include <BRepMesh_Circle.hxx>
 #include <Precision.hxx>
 #include <gp_XY.hxx>
 #include <gp_XYZ.hxx>
-
 #include <NCollection_CellFilter.hxx>
-#include <NCollection_Vector.hxx>
-
-typedef NCollection_Vector<BRepMesh_Circ> CircVector;
-
-//=======================================================================
-//! The class to find in the coincidence points 
-//=======================================================================
 
+//! Auxilary class to find circles shot by the given point.
 class BRepMesh_CircleInspector : public NCollection_CellFilter_InspectorXY
 {
 public:
   typedef Standard_Integer Target;
-  //! Constructor; remembers tolerance and collector data structure.
-  //! All the found points are put in the map and excluded from further
-  //! consideration.
-  BRepMesh_CircleInspector (Standard_Real theTol,
-    Standard_Integer nbComp,
-    const BRepMesh_BaseAllocator& theAlloc);
 
-  void Add(Standard_Integer theInd,const BRepMesh_Circ& theCircle)
+  //! Constructor.
+  //! \param theTolerance tolerance to be used for identification of shot circles.
+  //! \param theReservedSize size to be reserved for vector of circles.
+  //! \param theAllocator memory allocator to be used by internal collections.
+  Standard_EXPORT BRepMesh_CircleInspector(
+    const Standard_Real           theTolerance,
+    const Standard_Integer        theReservedSize,
+    const BRepMeshCol::Allocator& theAllocator)
+  : myTolerance(theTolerance*theTolerance),
+    myResIndices(theAllocator),
+    myCircles(theReservedSize)
   {
-    myInitCircle.SetValue(theInd, theCircle);
   }
 
-  void ClerResList()
+  //! Adds the circle to vector of circles at the given position.
+  //! \param theIndex position of circle in the vector.
+  //! \param theCircle circle to be added.
+  inline void Bind(const Standard_Integer theIndex,
+                   const BRepMesh_Circle& theCircle)
   {
-    myResInd.Clear();
+    myCircles.SetValue(theIndex, theCircle);
   }
 
-  CircVector& MapOfCirc()
+  //! Resutns vector of registered circles.
+  inline BRepMeshCol::VectorOfCircle& Circles()
   {
-    return myInitCircle; 
+    return myCircles; 
   }
 
-  BRepMesh_Circ& GetCirc(Standard_Integer theInd)
+  //! Returns circle with the given index.
+  //! \param theIndex index of circle.
+  //! \return circle with the given index.
+  inline BRepMesh_Circle& Circle(const Standard_Integer theIndex)
   {
-    return myInitCircle(theInd);
+    return myCircles(theIndex);
   }
 
-  //! Set current node to be checked
-  void SetCurrent (const gp_XY& theCurCircle) 
-  { 
-    myCurrent = theCurCircle;
+  //! Set reference point to be checked.
+  //! \param thePoint bullet point.
+  inline void SetPoint(const gp_XY& thePoint)
+  {
+    myResIndices.Clear();
+    myPoint = thePoint;
   }
 
-  //!Get result index of node
-  BRepMesh_ListOfInteger& GetCoincidentInd()
+  //! Returns list of circles shot by the reference point.
+  inline BRepMeshCol::ListOfInteger& GetShotCircles()
   {
-    return myResInd;
+    return myResIndices;
   }
 
-  //! Implementation of inspection method
-  NCollection_CellFilter_Action Inspect (const Standard_Integer theTarget); 
+  //! Performs inspection of a circle with the given index.
+  //! \param theTargetIndex index of a circle to be checked.
+  //! \return status of the check.
+  Standard_EXPORT NCollection_CellFilter_Action Inspect(
+    const Standard_Integer theTargetIndex);
 
-  static Standard_Boolean IsEqual (Standard_Integer theIdx, const Standard_Integer theTarget)
+  //! Checks indices for equlity.
+  Standard_EXPORT static Standard_Boolean IsEqual(
+    const Standard_Integer theIndex,
+    const Standard_Integer theTargetIndex)
   {
-    return (theIdx == theTarget);
+    return (theIndex == theTargetIndex);
   }
 
 private:
-  Standard_Real                        myTol;
-  BRepMesh_ListOfInteger               myResInd;
-  CircVector                           myInitCircle;
-  gp_XY                                myCurrent;
+  Standard_Real               myTolerance;
+  BRepMeshCol::ListOfInteger  myResIndices;
+  BRepMeshCol::VectorOfCircle myCircles;
+  gp_XY                       myPoint;
 };
 
 #endif
diff --git a/src/BRepMesh/BRepMesh_CircleTool.cdl b/src/BRepMesh/BRepMesh_CircleTool.cdl
deleted file mode 100644 (file)
index 27b25e9..0000000
+++ /dev/null
@@ -1,102 +0,0 @@
--- Created on: 1993-05-12
--- Created by: Didier PIFFAULT
--- Copyright (c) 1993-1999 Matra Datavision
--- Copyright (c) 1999-2014 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.
-
-class CircleTool from BRepMesh 
-
-  ---Purpose: Create sort   and  destroy the  circles    used in
-  --          triangulation.
-
-  uses    Boolean from Standard,
-          Integer from Standard,
-          Real from Standard,
-          XY from gp,
-          Circ2d from gp,
-          ListOfInteger from BRepMesh,
-          CellFilter from BRepMesh,
-          CircleInspector from BRepMesh,
-          BaseAllocator from BRepMesh
-
-  is      Create (theAlloc : in BaseAllocator from BRepMesh)
-          returns CircleTool from BRepMesh;
-
-
-          Create     (numberOfComponents : in Integer from Standard;
-                      theAlloc : in BaseAllocator from BRepMesh)
-             ---Purpose: Constructs a CircleTool with the maximal dimension
-             --          of  the occuped  space and  an  evaluation of  the
-             --          number of circles.
-             returns CircleTool from BRepMesh;
-
-           Initialize (me                 : in out;
-                        numberOfComponents : in Integer from Standard)
-                       ---Purpose: Constructs a CircleTool with the maximal dimension
-                       --          of  the occuped  space and  an  evaluation of  the
-                       --          number of circles.
-              is static;
-
-           SetCellSize(me                 : in out;
-                       theSize            : in Real from Standard)
-             ---Purpose: Sets new size for cellfilter
-             is static;
-
-           SetCellSize(me                 : in out;
-                        theXSize            : in Real from Standard;
-                        theYSize            : in Real from Standard)
-              ---Purpose: Sets new size for cellfilter
-              is static;
-
-            SetMinMaxSize(me                 : in out;
-                          theMin             : in XY from gp;
-                          theMax             : in XY from gp)
-             ---Purpose: Sets min and max size for circle
-             is static;
-
-           Add      (me       : in out;
-                      theCirc  : in Circ2d from gp;
-                      theIndex : in Integer from Standard)
-             ---Purpose: Adds and binds circle to the tool.
-             is static;
-
-
-           Add      (me          : in out;
-                      p1, p2, p3  : in XY from gp;
-                      theIndex    : in Integer from Standard)
-                ---Purpose: Computes adds and binds circle to the tool.
-                returns Boolean from Standard is static;
-
-            MocAdd   (me          : in out;
-                      theIndex    : in Integer from Standard);
-            ---Purpose: Adds implicit zero circle
-
-
-            Delete   (me : in out; theIndex : Integer from Standard) 
-            ---Purpose: Deletes a circle from the tool.
-            is static;
-
-
-            Select   (me : in out; thePnt : XY from gp)
-              ---Purpose: Select the circles which contains thePnt.
-              ---C++: return &
-              returns ListOfInteger from BRepMesh is static;
-
-              fields  Tolerance    : Real from Standard;
-                      Allocator    : BaseAllocator from BRepMesh;
-                      CellFilter   : CellFilter from BRepMesh;
-                      Selector     : CircleInspector from BRepMesh;
-                      FaceMax      : XY from gp;
-                      FaceMin      : XY from gp;
-
-end CircleTool;
index cf2c15a..3b10697 100644 (file)
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
-#include <BRepMesh_CircleTool.ixx>
-#include <gp_XY.hxx>
+#include <BRepMesh_CircleTool.hxx>
+#include <BRepMesh_GeomTool.hxx>
+#include <gp_Circ2d.hxx>
 #include <Precision.hxx>
-#include <BRepMesh_Circ.hxx>
+#include <BRepMesh_Circle.hxx>
 #include <BRepMesh_CircleInspector.hxx>
-#include <BRepMesh_BaseAllocator.hxx>
-
-
-//=======================================================================
-//function : BRepMesh_CircleInspector
-//purpose  : Constructor
-//=======================================================================
-
-BRepMesh_CircleInspector::BRepMesh_CircleInspector (Standard_Real theTol,
-                                                    Standard_Integer nbComp,
-                                                    const BRepMesh_BaseAllocator& theAlloc)
-                                                    : myTol(theTol*theTol),
-                                                    myResInd(theAlloc),
-                                                    myInitCircle(nbComp)
-{
-  //  myTol = theTol*theTol;
-}
 
 //=======================================================================
 //function : Inspect
 //purpose  : 
-//
 //=======================================================================
-NCollection_CellFilter_Action BRepMesh_CircleInspector::Inspect (const Standard_Integer theTarget)
+NCollection_CellFilter_Action BRepMesh_CircleInspector::Inspect(
+  const Standard_Integer theTargetIndex)
 {
-  const BRepMesh_Circ& Circ = myInitCircle(theTarget);
-  Standard_Real R = Circ.Radius();
-  if(R < 0)
+  const BRepMesh_Circle& aCircle = myCircles(theTargetIndex);
+  Standard_Real aRadius = aCircle.Radius();
+  if(aRadius < 0.)
     return CellFilter_Purge;
-  Standard_Real dx,dy;
-  const gp_XY& aLoc=Circ.Location();
-  dx=myCurrent.X()-aLoc.X();
-  dy=myCurrent.Y()-aLoc.Y();
-  if ((dx*dx+dy*dy)-(R*R) <= myTol)
-    myResInd.Append(theTarget);
+
+  const gp_XY& aLoc = aCircle.Location();
+
+  if ((myPoint - aLoc).SquareModulus() - (aRadius * aRadius) <= myTolerance)
+    myResIndices.Append(theTargetIndex);
+
   return CellFilter_Keep;
 }
 
@@ -62,188 +46,106 @@ NCollection_CellFilter_Action BRepMesh_CircleInspector::Inspect (const Standard_
 //function : BRepMesh_CircleTool
 //purpose  : 
 //=======================================================================
-BRepMesh_CircleTool::BRepMesh_CircleTool(const BRepMesh_BaseAllocator& theAlloc)
-: Tolerance(Precision::PConfusion()),
-Allocator(theAlloc),
-CellFilter(10, theAlloc),
-Selector(Tolerance,64,theAlloc)
+BRepMesh_CircleTool::BRepMesh_CircleTool(
+  const BRepMeshCol::Allocator& theAllocator)
+: myTolerance (Precision::PConfusion() * Precision::PConfusion()),
+  myAllocator (theAllocator),
+  myCellFilter(10, theAllocator),
+  mySelector  (myTolerance, 64, theAllocator)
 {
-  Tolerance=Tolerance*Tolerance;
 }
 
 //=======================================================================
 //function : BRepMesh_CircleTool
 //purpose  : 
 //=======================================================================
-BRepMesh_CircleTool::BRepMesh_CircleTool(const Standard_Integer nbComp,
-                                         const BRepMesh_BaseAllocator& theAlloc)
-                                         : Tolerance(Precision::PConfusion()),
-                                         Allocator(theAlloc),
-                                         CellFilter(10, theAlloc),
-                                         Selector(Tolerance,Max(nbComp,64),theAlloc)
+BRepMesh_CircleTool::BRepMesh_CircleTool(
+  const Standard_Integer        theReservedSize,
+  const BRepMeshCol::Allocator& theAllocator)
+: myTolerance (Precision::PConfusion() * Precision::PConfusion()),
+  myAllocator (theAllocator),
+  myCellFilter(10, theAllocator),
+  mySelector  (myTolerance, Max(theReservedSize, 64), theAllocator)
 {
-  Tolerance=Tolerance*Tolerance;
 }
 
-
 //=======================================================================
-//function : Initialize
+//function : bind
 //purpose  : 
 //=======================================================================
-void BRepMesh_CircleTool::Initialize(const Standard_Integer /*nbComp*/)
-{
-  Tolerance=Precision::PConfusion();
-  Tolerance=Tolerance*Tolerance;
-}
-
-void BRepMesh_CircleTool::SetCellSize(const Standard_Real theSize)
-{
-  CellFilter.Reset(theSize, Allocator);
-}
-
-void BRepMesh_CircleTool::SetCellSize(const Standard_Real theXSize, 
-                                      const Standard_Real theYSize)
+void BRepMesh_CircleTool::bind(const Standard_Integer theIndex,
+                               const gp_XY&           theLocation,
+                               const Standard_Real    theRadius)
 {
-  Standard_Real aCellSize[2];
-  aCellSize[0] = theXSize;
-  aCellSize[1] = theYSize;
+  BRepMesh_Circle aCirle(theLocation, theRadius);
 
-  CellFilter.Reset(aCellSize, Allocator);
-}
+  //compute coords
+  Standard_Real aMaxX = Min(theLocation.X() + theRadius, myFaceMax.X());
+  Standard_Real aMinX = Max(theLocation.X() - theRadius, myFaceMin.X());
+  Standard_Real aMaxY = Min(theLocation.Y() + theRadius, myFaceMax.Y());
+  Standard_Real aMinY = Max(theLocation.Y() - theRadius, myFaceMin.Y());
 
+  gp_XY aMinPnt(aMinX, aMinY);
+  gp_XY aMaxPnt(aMaxX, aMaxY);
 
-void BRepMesh_CircleTool::SetMinMaxSize(const gp_XY& theMin,
-                                        const gp_XY& theMax)
-{
-  FaceMin = theMin;
-  FaceMax = theMax;
+  myCellFilter.Add(theIndex, aMinPnt, aMaxPnt);
+  mySelector.Bind(theIndex, aCirle);
 }
 
 //=======================================================================
-//function : Add
+//function : Bind
 //purpose  : 
 //=======================================================================
-void  BRepMesh_CircleTool::Add(const gp_Circ2d& theCirc,
-                               const Standard_Integer theIndex)
+void BRepMesh_CircleTool::Bind(const Standard_Integer theIndex,
+                               const gp_Circ2d&       theCircle)
 {
-  gp_XY aCoord(theCirc.Location().Coord());
-  Standard_Real R = theCirc.Radius();
-  BRepMesh_Circ aCir(aCoord, R);
-
-  //compute coords
-  Standard_Real xMax=Min(aCoord.X()+R,FaceMax.X());
-  Standard_Real xMin=Max(aCoord.X()-R,FaceMin.X());
-  Standard_Real yMax=Min(aCoord.Y()+R,FaceMax.Y());
-  Standard_Real yMin=Max(aCoord.Y()-R,FaceMin.Y());
-
-  gp_XY MinPnt(xMin,yMin);
-  gp_XY MaxPnt(xMax,yMax);
-
-  CellFilter.Add(theIndex, MinPnt, MaxPnt);
-  Selector.Add(theIndex, aCir);
+  gp_XY         aCoord  = theCircle.Location().Coord();
+  Standard_Real aRadius = theCircle.Radius();
+  bind(theIndex, aCoord, aRadius);
 }
 
 //=======================================================================
-//function : Add
+//function : Bind
 //purpose  : 
 //=======================================================================
-Standard_Boolean BRepMesh_CircleTool::Add(const gp_XY& p1,
-                                          const gp_XY& p2,
-                                          const gp_XY& p3,
-                                          const Standard_Integer theIndex)
+Standard_Boolean BRepMesh_CircleTool::Bind(const Standard_Integer theIndex,
+                                           const gp_XY&           thePoint1,
+                                           const gp_XY&           thePoint2,
+                                           const gp_XY&           thePoint3)
 {
-  gp_XY m1((p1.X()+p2.X())/2., (p1.Y()+p2.Y())/2.);
-  gp_XY m2((p2.X()+p3.X())/2., (p2.Y()+p3.Y())/2.);
-  gp_XY m3((p3.X()+p1.X())/2., (p3.Y()+p1.Y())/2.);
-  Standard_Real dx=m1.X()-m2.X();
-  Standard_Real dy=m1.Y()-m2.Y();
-  Standard_Real d12=(dx*dx)+(dy*dy);
-  dx=m2.X()-m3.X();
-  dy=m2.Y()-m3.Y();
-  Standard_Real d23=(dx*dx)+(dy*dy);
-  dx=m3.X()-m1.X();
-  dy=m3.Y()-m1.Y();
-  Standard_Real d31=(dx*dx)+(dy*dy);
-  gp_XY pl11, pl12, pl21, pl22;
+  const Standard_Real aPrecision   = Precision::PConfusion();
+  const Standard_Real aSqPrecision = aPrecision * aPrecision;
 
-  if (d12>d23 && d12>d31) {
-    dy=p2.Y()-p1.Y();
-    dx=p1.X()-p2.X();
-    if (dy!=0. || dx!=0.) {
-      pl11 = m1;
-      pl12 = gp_XY(dy, dx);
-    }
-    else return Standard_False;
-
-    dy=p3.Y()-p2.Y();
-    dx=p2.X()-p3.X();
-    if (dy!=0. || dx!=0.) {
-      pl21 = m2;
-      pl22 = gp_XY(dy, dx);
-    }
-    else return Standard_False;
-  }
-  else {
-    if (d23>d31) {
-      dy=p3.Y()-p2.Y();
-      dx=p2.X()-p3.X();
-      if (dy!=0. || dx!=0.) {
-        pl11 = m2;
-        pl12 = gp_XY(dy, dx);
-      }
-      else return Standard_False;
+  const gp_XY aPoints[3] = { thePoint1, thePoint2, thePoint3 };
 
-      dy=p1.Y()-p3.Y();
-      dx=p3.X()-p1.X();
-      if (dy!=0. || dx!=0.) {
-        pl21 = m3;
-        pl22 = gp_XY(dy, dx);
-      }
-      else return Standard_False;
-    }
-    else {
-      dy=p1.Y()-p3.Y();
-      dx=p3.X()-p1.X();
-      if (dy!=0. || dx!=0.) {
-        pl11 = m3;
-        pl12 = gp_XY(dy, dx);
-      }
-      else return Standard_False;
+  gp_XY aNorm[3];
+  gp_XY aMidPnt[3];
+  for (Standard_Integer i = 0; i < 3; ++i)
+  {
+    const gp_XY& aPnt1 = aPoints[i];
+    const gp_XY& aPnt2 = aPoints[(i + 1) % 3];
 
-      dy=p2.Y()-p1.Y();
-      dx=p1.X()-p2.X();
-      if (dy!=0. || dx!=0.) {
-        pl21 = m1;
-        pl22 = gp_XY(dy, dx);
-      }
-      else return Standard_False;
-    }
-  }
+    aMidPnt[i] = (aPnt1 + aPnt2) / 2.;
 
-  gp_XY aVecO1O2 = pl21 - pl11;
-  Standard_Real aCrossD1D2 = pl12 ^ pl22;
-  Standard_Real theSinAngle = Abs(aCrossD1D2);
-  if (theSinAngle < gp::Resolution())
-    return Standard_False;
-  Standard_Real theParam1 = (aVecO1O2 ^ pl22) / aCrossD1D2;
-  gp_XY pInt = pl11+pl12*theParam1;
-  dx=p1.X()-pInt.X();
-  dy=p1.Y()-pInt.Y();
-  Standard_Real R = Sqrt(dx*dx+dy*dy);
-  BRepMesh_Circ aCir(pInt, R);
+    gp_XY aLink(aPnt2 - aPnt1);
+    if (aLink.SquareModulus() < aSqPrecision)
+      return Standard_False;
 
-  //compute coords
-  Standard_Real xMax=Min(pInt.X()+R,FaceMax.X());
-  Standard_Real xMin=Max(pInt.X()-R,FaceMin.X());
-  Standard_Real yMax=Min(pInt.Y()+R,FaceMax.Y());
-  Standard_Real yMin=Max(pInt.Y()-R,FaceMin.Y());
+    aNorm[i] = gp_XY(aLink.Y(), -aLink.X());
+    aNorm[i].Add(aMidPnt[i]);
+  }
 
-  gp_XY MinPnt(xMin,yMin);
-  gp_XY MaxPnt(xMax,yMax);    
+  gp_XY aIntPnt;
+  Standard_Real aParam[2];
+  BRepMesh_GeomTool::IntFlag aIntFlag = 
+    BRepMesh_GeomTool::IntLinLin(aMidPnt[0], aNorm[0],
+      aMidPnt[1], aNorm[1], aIntPnt, aParam);
 
-  CellFilter.Add(theIndex, MinPnt, MaxPnt);
+  if (aIntFlag != BRepMesh_GeomTool::Cross)
+    return Standard_False;
 
-  Selector.Add(theIndex, aCir);
+  Standard_Real aRadius = (aPoints[0] - aIntPnt).Modulus();
+  bind(theIndex, aIntPnt, aRadius);
   return Standard_True;
 }
 
@@ -251,29 +153,30 @@ Standard_Boolean BRepMesh_CircleTool::Add(const gp_XY& p1,
 //function : Delete
 //purpose  : 
 //=======================================================================
-void  BRepMesh_CircleTool::Delete(const Standard_Integer theIndex)
+void BRepMesh_CircleTool::Delete(const Standard_Integer theIndex)
 {
-  BRepMesh_Circ& Circ = Selector.GetCirc(theIndex);
-  if(Circ.Radius() > 0.) {
-    Circ.SetRadius(-1);
-  }
+  BRepMesh_Circle& aCircle = mySelector.Circle(theIndex);
+  if(aCircle.Radius() > 0.)
+    aCircle.SetRadius(-1);
 }
 
 //=======================================================================
 //function : Select
 //purpose  : 
 //=======================================================================
-BRepMesh_ListOfInteger&  BRepMesh_CircleTool::Select(const gp_XY& thePnt)
+BRepMeshCol::ListOfInteger& BRepMesh_CircleTool::Select(const gp_XY& thePoint)
 {
-  Selector.ClerResList();
-  Selector.SetCurrent(thePnt);
-  CellFilter.Inspect (thePnt, Selector);
-  return Selector.GetCoincidentInd();
+  mySelector.SetPoint(thePoint);
+  myCellFilter.Inspect(thePoint, mySelector);
+  return mySelector.GetShotCircles();
 }
 
-void BRepMesh_CircleTool::MocAdd(const Standard_Integer theIndex)
+//=======================================================================
+//function : MocBind
+//purpose  : 
+//=======================================================================
+void BRepMesh_CircleTool::MocBind(const Standard_Integer theIndex)
 {
-  gp_XY nullPnt(0.,0.);
-  BRepMesh_Circ theNullCir(nullPnt, -1.);
-  Selector.Add(theIndex, theNullCir);
+  BRepMesh_Circle aNullCir(gp::Origin2d().Coord(), -1.);
+  mySelector.Bind(theIndex, aNullCir);
 }
diff --git a/src/BRepMesh/BRepMesh_CircleTool.hxx b/src/BRepMesh/BRepMesh_CircleTool.hxx
new file mode 100644 (file)
index 0000000..11433d1
--- /dev/null
@@ -0,0 +1,132 @@
+// Copyright (c) 2013 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 _BRepMesh_CircleTool_HeaderFile
+#define _BRepMesh_CircleTool_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Macro.hxx>
+
+#include <Standard_Real.hxx>
+#include <BRepMesh_CircleInspector.hxx>
+#include <gp_XY.hxx>
+#include <gp_XYZ.hxx>
+#include <Standard_Integer.hxx>
+#include <Standard_Boolean.hxx>
+#include <BRepMesh_Collections.hxx>
+
+class gp_Circ2d;
+
+//! Create sort and destroy the circles used in triangulation. <br>
+class BRepMesh_CircleTool
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+  
+  //! Constructor.
+  //! \param theAllocator memory allocator to be used by internal structures.
+  Standard_EXPORT BRepMesh_CircleTool(const BRepMeshCol::Allocator& theAllocator);
+
+  //! Constructor.
+  //! \param theReservedSize size to be reserved for vector of circles.
+  //! \param theAllocator memory allocator to be used by internal structures.
+  Standard_EXPORT BRepMesh_CircleTool(const Standard_Integer        theReservedSize,
+                                      const BRepMeshCol::Allocator& theAllocator);
+
+  //! Initializes the tool.
+  //! \param theReservedSize size to be reserved for vector of circles.
+  inline void Init(const Standard_Integer /*theReservedSize*/)
+  {
+    myTolerance = Precision::PConfusion() * Precision::PConfusion();
+  }
+
+  //! Sets new size for cell filter.
+  //! \param theSize cell size to be set for X and Y dimensions.
+  inline void SetCellSize(const Standard_Real theSize)
+  {
+    myCellFilter.Reset(theSize, myAllocator);
+  }
+
+  //! Sets new size for cell filter.
+  //! \param theSizeX cell size to be set for X dimension.
+  //! \param theSizeY cell size to be set for Y dimension.
+  inline void SetCellSize(const Standard_Real theSizeX,
+                          const Standard_Real theSizeY)
+  {
+    Standard_Real aCellSize[2] = { theSizeX, theSizeY };
+    myCellFilter.Reset(aCellSize, myAllocator);
+  }
+
+  //! Sets limits of inspection area.
+  //! \param theMin bottom left corner of inspection area.
+  //! \param theMax top right corner of inspection area.
+  inline void SetMinMaxSize(const gp_XY& theMin,
+                            const gp_XY& theMax)
+  {
+    myFaceMin = theMin;
+    myFaceMax = theMax;
+  }
+
+  //! Binds the circle to the tool.
+  //! \param theIndex index a circle should be bound with.
+  //! \param theCircle circle to be bound.
+  Standard_EXPORT void Bind(const Standard_Integer theIndex,
+                            const gp_Circ2d&       theCircle);
+
+  //! Computes circle on three points and bind it to the tool.
+  //! \param theIndex index a circle should be bound with.
+  //! \param thePoint1 first point.
+  //! \param thePoint2 second point.
+  //! \param thePoint3 third point.
+  //! \return FALSE in case of impossibility to build a circle 
+  //! on the given points, TRUE elsewhere.
+  Standard_EXPORT Standard_Boolean Bind(const Standard_Integer theIndex,
+                                        const gp_XY&           thePoint1,
+                                        const gp_XY&           thePoint2,
+                                        const gp_XY&           thePoint3);
+
+  //! Binds implicit zero circle.
+  //! \param theIndex index a zero circle should be bound with.
+  Standard_EXPORT void MocBind(const Standard_Integer theIndex);
+
+  //! Deletes a circle from the tool.
+  //! \param theIndex index of a circle to be removed.
+  Standard_EXPORT void Delete(const Standard_Integer theIndex);
+
+  //! Select the circles shot by the given point.
+  //! \param thePoint bullet point.
+  Standard_EXPORT BRepMeshCol::ListOfInteger& Select(const gp_XY& thePoint);
+
+private:
+
+  //! Creates circle with the given parameters and binds it to the tool.
+  //! \param theIndex index a circle should be bound with.
+  //! \param theLocation location of a circle.
+  //! \param theRadius radius of a circle.
+  void bind(const Standard_Integer theIndex,
+            const gp_XY&           theLocation,
+            const Standard_Real    theRadius);
+
+private:
+
+  Standard_Real                 myTolerance;
+  BRepMeshCol::Allocator        myAllocator;
+  BRepMeshCol::CircleCellFilter myCellFilter;
+  BRepMesh_CircleInspector      mySelector;
+  gp_XY                         myFaceMax;
+  gp_XY                         myFaceMin;
+};
+
+#endif
diff --git a/src/BRepMesh/BRepMesh_Collections.hxx b/src/BRepMesh/BRepMesh_Collections.hxx
new file mode 100644 (file)
index 0000000..eb613ca
--- /dev/null
@@ -0,0 +1,144 @@
+// Copyright (c) 1999-2014 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 _BRepMesh_Collections_HeaderFile
+#define _BRepMesh_Collections_HeaderFile
+
+#include <gp_Pnt.hxx>
+#include <gp_XYZ.hxx>
+#include <gp_XY.hxx>
+#include <Bnd_B2d.hxx>
+#include <Bnd_Box2d.hxx>
+#include <Standard.hxx>
+#include <NCollection_List.hxx>
+#include <NCollection_Map.hxx>
+#include <NCollection_Vector.hxx>
+#include <NCollection_Handle.hxx>
+#include <NCollection_DataMap.hxx>
+#include <NCollection_IndexedMap.hxx>
+#include <NCollection_IndexedDataMap.hxx>
+#include <NCollection_Array1.hxx>
+#include <NCollection_Sequence.hxx>
+#include <NCollection_CellFilter.hxx>
+#include <NCollection_IncAllocator.hxx>
+#include <NCollection_EBTree.hxx>
+#include <NCollection_UBTreeFiller.hxx>
+#include <BRepMesh_Edge.hxx>
+#include <BRepMesh_Triangle.hxx>
+#include <BRepMesh_PairOfPolygon.hxx>
+#include <BRepMesh_PairOfIndex.hxx>
+#include <BRepMesh_Circle.hxx>
+#include <TopTools_ShapeMapHasher.hxx>
+#include <Handle_Poly_Triangulation.hxx>
+
+#include <vector>
+
+class BRepMesh_Vertex;
+class TopoDS_Shape;
+class TopoDS_Face;
+class TopoDS_Edge;
+class TopoDS_Vertex;
+class BRepMesh_FaceAttribute;
+class Handle_BRepMesh_FaceAttribute;
+class BRepMesh_VertexInspector;
+class BRepMesh_CircleInspector;
+class BRepMesh_Classifier;
+class Poly_Triangulation;
+
+//! Short names for collections
+#define N_SEQUENCE    NCollection_Sequence
+#define N_VECTOR      NCollection_Vector
+#define N_ARRAY1      NCollection_Array1
+#define N_LIST        NCollection_List
+#define N_MAP         NCollection_Map
+#define N_HANDLE      NCollection_Handle
+#define N_DATAMAP     NCollection_DataMap
+#define N_IMAP        NCollection_IndexedMap
+#define N_IDMAP       NCollection_IndexedDataMap
+#define N_CELLFILTER  NCollection_CellFilter
+
+namespace BRepMeshCol
+{
+  //! Structure keeping parameters of segment.
+  struct Segment
+  {
+    gp_XY StartPnt;
+    gp_XY EndPnt;
+  };
+
+  //! Memory allocators
+  typedef Handle(NCollection_IncAllocator)                                      Allocator;
+
+  //! Short names for hashers
+  typedef TopTools_ShapeMapHasher                                               ShapeMapHasher;
+
+  //! Sequences
+  typedef N_SEQUENCE<Bnd_B2d>                                                   SequenceOfBndB2d;
+  typedef N_SEQUENCE<Standard_Integer>                                          SequenceOfInteger;
+  typedef N_SEQUENCE<Standard_Real>                                             SequenceOfReal;
+
+  //! Vectors
+  typedef N_VECTOR<BRepMesh_Vertex>                                             VectorOfVertex;
+  typedef N_VECTOR<Standard_Integer>                                            VectorOfInteger;
+  typedef N_VECTOR<BRepMesh_Circle>                                             VectorOfCircle;
+
+  //! Trees
+  typedef NCollection_EBTree<Standard_Integer, Bnd_Box2d>                       BndBox2dTree;
+  typedef NCollection_UBTreeFiller<Standard_Integer, Bnd_Box2d>                 BndBox2dTreeFiller;
+
+  //! Arrays
+  typedef N_ARRAY1<BRepMesh_Vertex>                                             Array1OfVertexOfDelaun;
+  typedef N_ARRAY1<Standard_Integer>                                            Array1OfInteger;
+  typedef N_ARRAY1<Standard_Real>                                               Array1OfReal;
+  typedef std::vector<Segment>                                                  Array1OfSegments;
+
+  //! Lists
+  typedef N_LIST<gp_XY>                                                         ListOfXY;
+  typedef N_LIST<BRepMesh_Vertex>                                               ListOfVertex;
+  typedef N_LIST<Standard_Integer>                                              ListOfInteger;
+
+  //! Maps
+  typedef N_MAP<Standard_Integer>                                               MapOfInteger;
+  typedef N_MAP<Handle(Poly_Triangulation)>                                     MapOfTriangulation;
+  typedef N_MAP<TopoDS_Shape, ShapeMapHasher>                                   MapOfShape;
+
+  typedef N_DATAMAP<Standard_Integer, Standard_Integer>                         MapOfIntegerInteger;
+  typedef N_DATAMAP<TopoDS_Vertex, Standard_Integer, ShapeMapHasher>            DMapOfVertexInteger;
+  typedef N_DATAMAP<TopoDS_Face, Handle_BRepMesh_FaceAttribute, ShapeMapHasher> DMapOfFaceAttribute;
+  typedef N_DATAMAP<TopoDS_Shape, BRepMesh_PairOfPolygon, ShapeMapHasher>       DMapOfShapePairOfPolygon;
+  typedef N_DATAMAP<Standard_Integer, gp_Pnt>                                   DMapOfIntegerPnt;
+  typedef N_DATAMAP<Standard_Integer, ListOfXY>                                 DMapOfIntegerListOfXY;
+  typedef N_DATAMAP<Standard_Integer, ListOfInteger>                            DMapOfIntegerListOfInteger;
+  typedef N_DATAMAP<TopoDS_Edge, MapOfTriangulation, ShapeMapHasher>            DMapOfEdgeListOfTriangulation;
+
+  typedef N_IMAP<Standard_Integer>                                              IMapOfInteger;
+  typedef N_IMAP<Standard_Real>                                                 IMapOfReal;
+  typedef N_IMAP<BRepMesh_Triangle>                                             IMapOfElement;
+  typedef N_IDMAP<BRepMesh_Edge, BRepMesh_PairOfIndex>                          IDMapOfLink;
+
+  //! CellFilters
+  typedef N_CELLFILTER<BRepMesh_CircleInspector>                                CircleCellFilter;
+  typedef N_CELLFILTER<BRepMesh_VertexInspector>                                VertexCellFilter;
+
+  //! Handles
+  typedef N_HANDLE<MapOfInteger>                                                HMapOfInteger;
+  typedef N_HANDLE<BRepMesh_Classifier>                                         HClassifier;
+  typedef N_HANDLE<BndBox2dTree>                                                HBndBox2dTree;
+  typedef N_HANDLE<Array1OfSegments>                                            HArray1OfSegments;
+
+  //! Other data structures
+  typedef std::pair<HArray1OfSegments, HBndBox2dTree>                           SegmentsTree;
+  typedef std::vector<SegmentsTree>                                             Array1OfSegmentsTree;
+};
+
+#endif
diff --git a/src/BRepMesh/BRepMesh_ComparatorOfIndexedVertexOfDelaun.cdl b/src/BRepMesh/BRepMesh_ComparatorOfIndexedVertexOfDelaun.cdl
deleted file mode 100644 (file)
index 8dc46a0..0000000
+++ /dev/null
@@ -1,49 +0,0 @@
--- Created on: 1994-04-05
--- Created by: Didier PIFFAULT
--- Copyright (c) 1994-1999 Matra Datavision
--- Copyright (c) 1999-2014 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.
-
-class ComparatorOfIndexedVertexOfDelaun from BRepMesh
-
-  ---Purpose: Sort two point in a given direction.
-
-
-  uses  Boolean from Standard,
-        XY from gp,
-        DataStructureOfDelaun from BRepMesh
-
-  is      Create (theDir : XY from gp; 
-                  TheTol : Real from Standard;
-                  HDS    : DataStructureOfDelaun from BRepMesh) 
-           returns ComparatorOfIndexedVertexOfDelaun;
-
-
-         IsLower (me; Left, Right: Integer)
-           ---Purpose: returns True if <Left> is lower than <Right>
-           returns Boolean from Standard;
-
-         IsGreater (me; Left, Right: Integer)
-           ---Purpose: returns True if <Left> is greater than <Right>
-           returns Boolean from Standard;
-
-         IsEqual(me; Left, Right: Integer)
-           ---Purpose: returns True when <Right> and <Left> are equal.
-           returns Boolean from Standard;
-
-
-         fields  IndexedStructure : DataStructureOfDelaun from BRepMesh;
-                 DirectionOfSort  : XY from gp;
-                 Tolerance        : Real from Standard;
-
-end ComparatorOfIndexedVertexOfDelaun;
diff --git a/src/BRepMesh/BRepMesh_ComparatorOfIndexedVertexOfDelaun.cxx b/src/BRepMesh/BRepMesh_ComparatorOfIndexedVertexOfDelaun.cxx
deleted file mode 100644 (file)
index 4c0f05d..0000000
+++ /dev/null
@@ -1,67 +0,0 @@
-// Created on: 1994-04-05
-// Created by: Didier PIFFAULT
-// Copyright (c) 1994-1999 Matra Datavision
-// Copyright (c) 1999-2014 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 <BRepMesh_ComparatorOfIndexedVertexOfDelaun.ixx>
-#include <BRepMesh_Vertex.hxx>
-
-//=======================================================================
-//function : BRepMesh_ComparatorOfIndexedVertexOfDelaun
-//purpose  : 
-//=======================================================================
-
-BRepMesh_ComparatorOfIndexedVertexOfDelaun::BRepMesh_ComparatorOfIndexedVertexOfDelaun
-(const gp_XY& theDir,
- const Standard_Real theTol,
- const Handle(BRepMesh_DataStructureOfDelaun)& HDS)
- :  IndexedStructure(HDS),DirectionOfSort(theDir), Tolerance(theTol)
-{}
-
-//=======================================================================
-//function : IsLower
-//purpose  : 
-//=======================================================================
-
-Standard_Boolean BRepMesh_ComparatorOfIndexedVertexOfDelaun::IsLower
-(const Standard_Integer Left, const Standard_Integer Right) const
-{
-  return ((IndexedStructure->GetNode(Left).Coord()*DirectionOfSort) <
-    (IndexedStructure->GetNode(Right).Coord()*DirectionOfSort));
-}
-
-//=======================================================================
-//function : IsGreater
-//purpose  : 
-//=======================================================================
-
-Standard_Boolean BRepMesh_ComparatorOfIndexedVertexOfDelaun::IsGreater
-(const Standard_Integer Left, const Standard_Integer Right) const
-{
-  return ((IndexedStructure->GetNode(Left).Coord()*DirectionOfSort) >
-    (IndexedStructure->GetNode(Right).Coord()*DirectionOfSort));
-}
-
-//=======================================================================
-//function : IsEqual
-//purpose  : 
-//=======================================================================
-
-Standard_Boolean BRepMesh_ComparatorOfIndexedVertexOfDelaun::IsEqual
-(const Standard_Integer Left, const Standard_Integer Right) const
-{
-  return (IndexedStructure->GetNode(Left).Coord().IsEqual
-    (IndexedStructure->GetNode(Right).Coord(), Tolerance));
-}
-
diff --git a/src/BRepMesh/BRepMesh_ComparatorOfVertexOfDelaun.cdl b/src/BRepMesh/BRepMesh_ComparatorOfVertexOfDelaun.cdl
deleted file mode 100644 (file)
index 0df083f..0000000
+++ /dev/null
@@ -1,46 +0,0 @@
--- Created on: 1993-06-18
--- Created by: Didier PIFFAULT
--- Copyright (c) 1993-1999 Matra Datavision
--- Copyright (c) 1999-2014 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.
-
-class ComparatorOfVertexOfDelaun from BRepMesh
-
-  ---Purpose: Sort two point in a given direction.
-
-
-  uses  Boolean from Standard,
-        Vertex from BRepMesh,
-        XY from gp
-
-
-  is      Create (theDir : XY from gp) 
-            returns ComparatorOfVertexOfDelaun;
-
-
-          IsLower (me; Left, Right: Vertex from BRepMesh)
-          ---Purpose: returns True if <Left> is lower than <Right>
-          returns Boolean from Standard;
-
-          IsGreater (me; Left, Right: Vertex from BRepMesh)
-          ---Purpose: returns True if <Left> is greater than <Right>
-          returns Boolean from Standard;
-
-          IsEqual(me; Left, Right: Vertex from BRepMesh)
-          ---Purpose: returns True when <Right> and <Left> are equal.
-          returns Boolean from Standard;
-
-
-fields  DirectionOfSort : XY from gp;
-
-end ComparatorOfVertexOfDelaun;
diff --git a/src/BRepMesh/BRepMesh_ComparatorOfVertexOfDelaun.cxx b/src/BRepMesh/BRepMesh_ComparatorOfVertexOfDelaun.cxx
deleted file mode 100644 (file)
index 022af7d..0000000
+++ /dev/null
@@ -1,62 +0,0 @@
-// Created on: 1993-06-18
-// Created by: Didier PIFFAULT
-// Copyright (c) 1993-1999 Matra Datavision
-// Copyright (c) 1999-2014 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 <BRepMesh_ComparatorOfVertexOfDelaun.ixx>
-
-//=======================================================================
-//function : BRepMesh_ComparatorOfVertexOfDelaun
-//purpose  : 
-//=======================================================================
-
-BRepMesh_ComparatorOfVertexOfDelaun::BRepMesh_ComparatorOfVertexOfDelaun(const gp_XY& theDir)
-                                                                         : DirectionOfSort(theDir)
-{}
-
-//=======================================================================
-//function : IsLower
-//purpose  : 
-//=======================================================================
-
-Standard_Boolean BRepMesh_ComparatorOfVertexOfDelaun::IsLower(const BRepMesh_Vertex& Left,
-                                                              const BRepMesh_Vertex& Right) const
-{
-  return (Left.Coord()*DirectionOfSort) <
-    (Right.Coord()*DirectionOfSort);
-}
-
-//=======================================================================
-//function : IsGreater
-//purpose  : 
-//=======================================================================
-
-Standard_Boolean BRepMesh_ComparatorOfVertexOfDelaun::IsGreater(const BRepMesh_Vertex& Left,
-                                                                const BRepMesh_Vertex& Right) const
-{
-  return (Left.Coord()*DirectionOfSort) >
-    (Right.Coord()*DirectionOfSort);
-}
-
-//=======================================================================
-//function : IsEqual
-//purpose  : 
-//=======================================================================
-
-Standard_Boolean BRepMesh_ComparatorOfVertexOfDelaun::IsEqual(const BRepMesh_Vertex& Left,
-                                                              const BRepMesh_Vertex& Right) const
-{
-  return Left.IsEqual(Right);
-}
-
diff --git a/src/BRepMesh/BRepMesh_DataStructureOfDelaun.cdl b/src/BRepMesh/BRepMesh_DataStructureOfDelaun.cdl
deleted file mode 100644 (file)
index 75edd90..0000000
+++ /dev/null
@@ -1,265 +0,0 @@
--- Created on: 1993-03-17
--- Created by: Didier PIFFAULT
--- Copyright (c) 1993-1999 Matra Datavision
--- Copyright (c) 1999-2014 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.
-
-class DataStructureOfDelaun from BRepMesh inherits TShared from MMgt
-
-  ---Purpose: Describes  the data structure  necessary  for  the
-  --          mesh  algorithms  in  two  dimensions  plane or on
-  --          surface by meshing in UV space.
-
-
-  uses        Integer from Standard,
-              ListOfInteger from BRepMesh,
-              MapOfInteger from BRepMesh,
-              PairOfIndex from BRepMesh,
-              Box from Bnd,
-              BoundSortBox from Bnd,
-              BaseAllocator from BRepMesh,
-              VertexTool from BRepMesh,
-              IDMapOfLinkOfDataStructureOfDelaun from BRepMesh,
-              IMapOfElementOfDataStructureOfDelaun from BRepMesh,
-              SelectorOfDataStructureOfDelaun from BRepMesh,
-              Vertex from BRepMesh,
-              Edge from BRepMesh,
-              Triangle from BRepMesh
-
-  is          Create     (theAllocator: BaseAllocator from BRepMesh;
-                          NodeNumber : Integer from Standard = 100)
-                ---Purpose: <NodeNumber>   is just  an   evaluation of the
-                --          presumed  number of nodes  in this mesh.   The
-                --          Mesh   data  structure will   be automatically
-                --          redimensioned if necessary.
-                returns DataStructureOfDelaun from BRepMesh ;
-
-              AddNode    (me      : mutable ;
-                          theNode : Vertex from BRepMesh) 
-                returns Integer from Standard
-                ---Purpose: Adds a node to the  mesh  if  the node is  not
-                --          already in the Mesh.  Returns the index of the
-                --          node in the structure.
-                is static;
-
-              GetNode    (me      : mutable; 
-                          Index   : Integer from Standard)
-                returns Vertex from BRepMesh 
-                ---Purpose: Get the value of node <Index>.
-                ---C++:  return const &
-                ---C++:  alias operator ()
-                is static;
-
-              GetNodeList    (me      : mutable; 
-                              Index   : Integer from Standard)
-                returns ListOfInteger from BRepMesh
-                ---Purpose: Get the list of node <Index>.
-                ---C++:  return const &
-                is static;
-
-              ForceRemoveNode (me    : mutable;
-                                Index : Integer from Standard) 
-              ---Purpose: Removes the node of index <index> from the mesh.
-              is static;
-
-              ForceRemoveLink (me    : mutable;
-                                Index : Integer from Standard) 
-                ---Purpose: Removes the link of index <index> from the mesh.
-                is static;
-
-              ReplaceNodes (me       : mutable;
-                            NewNodes : VertexTool from BRepMesh) 
-                ---Purpose: Removes the all nodes and sets new map of 
-                -- nodes from the mesh.
-                -- For internal use only.
-                is static;
-
-              RemoveNode (me      : mutable;
-                          Index   : Integer from Standard) 
-                ---Purpose: Removes the node of index <index> from the mesh.
-                is static;
-
-              MoveNode   (me      : mutable ;
-                          Index   : Integer from Standard;
-                          newNode : Vertex from BRepMesh) 
-                ---Purpose: Changes the UV  value of node of index <Index>  by
-                --          <newNode>. Returns false if <newnode> is already in
-                --          the structure.
-                returns Boolean from Standard is static;
-
-              NbNodes        (me)
-                returns Integer from Standard
-                ---Purpose: Gives the number of nodes in this mesh.
-                is static;
-
-
-              AddLink    (me      : mutable;
-                          theLink : Edge from BRepMesh) 
-                returns Integer from Standard
-                ---Purpose: Adds a Link  to the  mesh if  the Link is  not
-                --          already in the structure. Returns the index of
-                --          the link in the structure.
-                is static;
-
-              GetLink    (me    : mutable; 
-                          Index : Integer from Standard)
-              returns Edge from BRepMesh 
-                ---Purpose: Get the value of Link <Index>.
-                ---C++: return const &
-              is static;
-
-              RemoveLink (me      : mutable;
-                          Index   : Integer from Standard) 
-                ---Purpose: Removes the Link of  index  <Index> from the
-                --          mesh.
-                is static;
-
-              SubstituteLink (me      : mutable ;
-                              Index   : Integer from Standard;
-                              newLink : Edge from BRepMesh) 
-                ---Purpose: Substitutes  the  Link  of  index  <Index>  by
-                --          <newLink> clear the connectivity.
-                returns Boolean from Standard is static;
-
-              NbLinks        (me)
-                returns Integer from Standard
-                ---Purpose: Gives the number of elements in this mesh.
-                is static;
-
-
-              AddElement     (me         : mutable;
-                              theElement : Triangle from BRepMesh) 
-                returns Integer from Standard
-                ---Purpose: Adds an element  to  the mesh  if it    is not
-                --          already in the  Mesh. Returns the index of the
-                --          element in the structure.
-                is static;
-
-               GetElement     (me    : mutable; 
-                              Index : Integer from Standard)
-                returns Triangle from BRepMesh
-                ---Purpose: Get the value of Element <Index>.
-                ---C++: return const &
-                is static;
-
-              RemoveElement  (me      : mutable;
-                              Index   : Integer from Standard) 
-                ---Purpose: Removes the element of index <Index> in the mesh.
-                is static;
-
-              SubstituteElement  (me         : mutable ;
-                                  Index      : Integer from Standard;
-                                  newElement : Triangle from BRepMesh) 
-                ---Purpose: Substitutes  the  element   of  index  <Index>  by
-                --          <newElement>. The links connectivity is updated.
-                returns Boolean from Standard is static;
-
-              NbElements     (me)
-                returns Integer from Standard
-                ---Purpose: Gives the number of elements in this mesh.
-                is static;
-
-              ClearDomain    (me         : mutable) 
-                ---Purpose:  Removes all elements
-                is static;
-
-
-              IndexOf        (me: mutable;
-                              aNode : Vertex from BRepMesh)
-                ---Purpose: Finds the index of the node.  Returns 0 if the
-                --          node is not in the mesh.
-                     returns Integer from Standard;
-
-              IndexOf        (me;
-                              aLink : Edge from BRepMesh)
-                ---Purpose: Finds the index of the Link.  Returns 0 if the
-                --          Link is not in the mesh.
-                returns Integer from Standard;
-
-              IndexOf        (me;
-                              anElement : Triangle from BRepMesh)
-                ---Purpose: Finds the index  of the Element.  Returns 0 if
-                --          the Element is not in the mesh.
-                returns Integer from Standard;
-
-              LinkNeighboursOf (me;
-                                theNode         : in Integer from Standard)
-                returns ListOfInteger from BRepMesh
-                ---C++: return const &
-                ---Purpose: Gives the list of  Link's indices handling the
-                --          node <theNode>.
-                is static;
-
-
-              ElemConnectedTo (me;
-                               theLink     : in Integer from Standard)
-                returns PairOfIndex from BRepMesh
-                ---C++: return const &
-                ---Purpose: Gives the element's indices conected
-                --          to <theLink>.
-                is static;
-
-              ElemOfDomain     (me)
-                returns MapOfInteger from BRepMesh
-                ---C++: return const &
-                ---Purpose: Gives  the  list  of element's indices
-                is static;
-
-
-              LinkOfDomain     (me)
-                returns MapOfInteger from BRepMesh
-                ---C++: return const &
-                ---Purpose: Gives  the  list  of link's indices
-                is static;
-
-
-              ClearDeleted     (me : mutable)
-                ---Purpose: This method  substitute the deleted  items  by
-                --          the last in  Indexed Data  Maps  to  have only
-                --          non-deleted  elements, links  or  nodes in the
-                --          structure.
-                is static;
-
-
-              -- Internal methods :
-
-              ClearElement   (me      : mutable;
-                              Index   : Integer from Standard;
-                              theElem : Triangle from BRepMesh) 
-                ---Purpose: Deletes  the element of  index <Index> in
-                --          the mesh. Used by RemoveElement.
-                is static private;
-
-              Statistics     (me;
-                              flot  : in out OStream from Standard) 
-                ---Purpose: Give informations on map.
-                is static;
-
-              Allocator (me) returns BaseAllocator from BRepMesh;
-                ---C++: return const&
-              
-              Data (me: mutable) returns VertexTool from BRepMesh;
-                ---Purpose: Give the data structure for cell size and
-                --          tolerance initialization.
-                ---C++: return &
-
-
-  fields      myNodes        : VertexTool from BRepMesh;
-              myLinks        : IDMapOfLinkOfDataStructureOfDelaun from BRepMesh;
-              myDelLinks     : ListOfInteger from BRepMesh;
-              myElements     : IMapOfElementOfDataStructureOfDelaun from BRepMesh;
-                      --myDelElements  : ListOfInteger from BRepMesh;
-              myElemOfDomain : MapOfInteger  from BRepMesh;
-              myLinkOfDomain : MapOfInteger  from BRepMesh;
-              myAllocator    : BaseAllocator from BRepMesh;
-end DataStructureOfDelaun;
index 0f7aa71..e34e47c 100644 (file)
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
-#include <BRepMesh_DataStructureOfDelaun.ixx>
+#include <BRepMesh_DataStructureOfDelaun.hxx>
+#include <BRepMesh_PairOfIndex.hxx>
+#include <BRepBuilderAPI_MakeEdge.hxx>
+
+#include <TopoDS_Compound.hxx>
+#include <BRep_Builder.hxx>
+#include <BRepTools.hxx>
+#include <Standard_ErrorHandler.hxx>
+
+IMPLEMENT_STANDARD_HANDLE (BRepMesh_DataStructureOfDelaun, Standard_Transient)
+IMPLEMENT_STANDARD_RTTIEXT(BRepMesh_DataStructureOfDelaun, Standard_Transient)
 
 //=======================================================================
 //function : BRepMesh_DataStructureOfDelaun
 //purpose  : 
 //=======================================================================
-BRepMesh_DataStructureOfDelaun::BRepMesh_DataStructureOfDelaun(const BRepMesh_BaseAllocator& theAlloc,
-                                                               const Standard_Integer NodeNumber)
-                                                               : myNodes(NodeNumber, theAlloc),
-                                                               myLinks(NodeNumber*3),
-                                                               myDelLinks(theAlloc),
-                                                               myElements(NodeNumber*2),
-                                                               // Not_Debuged_Yet myDelElements(theAlloc),
-                                                               myElemOfDomain(NodeNumber*2,theAlloc),
-                                                               myLinkOfDomain(NodeNumber*2,theAlloc)
+BRepMesh_DataStructureOfDelaun::BRepMesh_DataStructureOfDelaun(
+  const BRepMeshCol::Allocator& theAllocator,
+  const Standard_Integer        theReservedNodeSize)
+  : myNodes           (theReservedNodeSize, theAllocator),
+    myLinks           (theReservedNodeSize * 3),
+    myDelLinks        (theAllocator),
+    myElements        (theReservedNodeSize * 2),
+    myElementsOfDomain(theReservedNodeSize * 2, theAllocator),
+    myLinksOfDomain   (theReservedNodeSize * 2, theAllocator),
+    myAllocator       (theAllocator)
 {
-  myAllocator = theAlloc;
 }
 
 //=======================================================================
-//function : AddNode
+//function : SubstituteNode
 //purpose  : 
 //=======================================================================
-Standard_Integer  BRepMesh_DataStructureOfDelaun::AddNode(const BRepMesh_Vertex& theNode)
+Standard_Boolean BRepMesh_DataStructureOfDelaun::SubstituteNode(
+  const Standard_Integer theIndex, 
+  const BRepMesh_Vertex& theNewNode)
 {
-  return myNodes.Add(theNode);
-}
+  if (myNodes.FindIndex(theNewNode) != 0)
+    return Standard_False;
 
-//=======================================================================
-//function : GetNode
-//purpose  : 
-//=======================================================================
-const BRepMesh_Vertex&  BRepMesh_DataStructureOfDelaun::GetNode(const Standard_Integer Index)
-{
-  return myNodes.FindKey(Index);
+  const BRepMeshCol::ListOfInteger& aLinks = myNodes(theIndex);
+  myNodes.Substitute(theIndex, theNewNode, aLinks);
+  return Standard_True;
 }
 
 //=======================================================================
-//function : GetNodeList
+//function : AddLink
 //purpose  : 
 //=======================================================================
-const BRepMesh_ListOfInteger& BRepMesh_DataStructureOfDelaun::GetNodeList(const Standard_Integer Index)
+Standard_Integer BRepMesh_DataStructureOfDelaun::AddLink(
+  const BRepMesh_Edge& theLink)
 {
-  return myNodes.FindFromIndex(Index);
-}
+  Standard_Integer aLinkIndex = IndexOf(theLink);
+  if (aLinkIndex > 0)
+  {
+    return theLink.IsSameOrientation(GetLink(aLinkIndex)) ?
+       aLinkIndex : -aLinkIndex;
+  }
 
-//=======================================================================
-//function : ForceRemoveNode
-//purpose  : 
-//=======================================================================
-void  BRepMesh_DataStructureOfDelaun::ForceRemoveNode(const Standard_Integer Index)
-{
-  if ( myNodes.FindFromIndex(Index).Extent()==0) {
-    myNodes.Delete(Index);
+  BRepMesh_PairOfIndex aPair;
+  if (!myDelLinks.IsEmpty())
+  {
+    aLinkIndex = myDelLinks.First();
+    myLinks.Substitute(aLinkIndex, theLink, aPair);
+    myDelLinks.RemoveFirst();
   }
-}
+  else
+    aLinkIndex = myLinks.Add(theLink, aPair);
 
-//=======================================================================
-//function : ReplaceNodes
-//purpose  : 
-//=======================================================================
-void  BRepMesh_DataStructureOfDelaun::ReplaceNodes(const BRepMesh_VertexTool& NewNodes)
-{
-  if ( NewNodes.IsEmpty() )
-    return;
+  const Standard_Integer aLinkId = Abs(aLinkIndex);
+  myNodes(theLink.FirstNode()).Append(aLinkId);
+  myNodes(theLink.LastNode() ).Append(aLinkId);
+  myLinksOfDomain.Add(aLinkIndex);
 
-  myNodes = NewNodes;
+  return aLinkIndex;
 }
 
 //=======================================================================
-//function : ForceRemoveLink
+//function : SubstituteLink
 //purpose  : 
 //=======================================================================
-void  BRepMesh_DataStructureOfDelaun::ForceRemoveLink(const Standard_Integer Index)
+Standard_Boolean BRepMesh_DataStructureOfDelaun::SubstituteLink(
+  const Standard_Integer theIndex,
+  const BRepMesh_Edge&   theNewLink)
 {
-  //Warning, the static cast from const& to & is called for
-  //performance reasons. This is applicable only in case if later
-  //modification of element (field movability) does not influent on
-  //has calculation.
-  BRepMesh_Edge& lref=(BRepMesh_Edge&)myLinks.FindKey(Index);
-  if (lref.Movability()!=BRepMesh_Deleted) {
-    if (myLinks.FindFromIndex(Index).Extent()==0) {
-      BRepMesh_ListOfInteger::Iterator tit;
-      BRepMesh_ListOfInteger& aList1 = myNodes(lref.FirstNode());
-      for(tit.Init(aList1); tit.More(); tit.Next()){
-        if (tit.Value()==Index) {
-          aList1.Remove(tit);
-          break;
-        }
-      }
-
-      BRepMesh_ListOfInteger& aList2 = myNodes(lref.LastNode());
-      for(tit.Init(aList2); tit.More(); tit.Next()){
-        if (tit.Value()==Index) {
-          aList2.Remove(tit);
-          break;
-        }
-      }
-      myLinkOfDomain.Remove(Index);
-      lref.SetMovability(BRepMesh_Deleted);
-      myDelLinks.Append(Index);
-    }
+  BRepMesh_PairOfIndex aPair;
+  BRepMesh_Edge aLink = GetLink(theIndex);
+  if (aLink.Movability() == BRepMesh_Deleted)
+  {
+    myLinks.Substitute(theIndex, theNewLink, aPair);
+    return Standard_True;
   }
-}
 
-//=======================================================================
-//function : RemoveNode
-//purpose  : 
-//=======================================================================
-void  BRepMesh_DataStructureOfDelaun::RemoveNode(const Standard_Integer Index)
-{
-  if (myNodes.FindKey(Index).Movability() == BRepMesh_Free &&
-      myNodes.FindFromIndex(Index).Extent() == 0) {
-      myNodes.Delete(Index);
-  }
-}
+  if (IndexOf(theNewLink) != 0) 
+    return Standard_False;
 
-//=======================================================================
-//function : MoveNode
-//purpose  : 
-//=======================================================================
-Standard_Boolean BRepMesh_DataStructureOfDelaun::MoveNode(const Standard_Integer Index, 
-                                                          const BRepMesh_Vertex& newNode)
-{
-  if (myNodes.FindIndex(newNode) == 0) {
-    const BRepMesh_ListOfInteger& refLink = myNodes(Index);
-    myNodes.Substitute(Index, newNode, refLink);
-    return Standard_True;
-  }
-  return Standard_False;
-}
+  aLink.SetMovability(BRepMesh_Deleted);
+  myLinks.Substitute(theIndex, aLink, aPair);
+  cleanLink(theIndex, aLink);
 
-//=======================================================================
-//function : NbNodes
-//purpose  : 
-//=======================================================================
-Standard_Integer  BRepMesh_DataStructureOfDelaun::NbNodes()const
-{
-  return myNodes.Extent();
+  const Standard_Integer aLinkId = Abs(theIndex);
+  myNodes(theNewLink.FirstNode()).Append(aLinkId);
+  myNodes(theNewLink.LastNode() ).Append(aLinkId);
+  myLinks.Substitute(theIndex, theNewLink, aPair);
+
+  return Standard_True;
 }
 
 //=======================================================================
-//function : AddLink
+//function : ForceRemoveLink
 //purpose  : 
 //=======================================================================
-Standard_Integer  BRepMesh_DataStructureOfDelaun::AddLink(const BRepMesh_Edge& theLink)
+void BRepMesh_DataStructureOfDelaun::RemoveLink(
+  const Standard_Integer theIndex,
+  const Standard_Boolean isForce)
 {
-  Standard_Integer LinkIndex=myLinks.FindIndex(theLink);
-  if (LinkIndex<=0) {
-    BRepMesh_PairOfIndex aPair;
-    if (!myDelLinks.IsEmpty()) {
-      LinkIndex=myDelLinks.First();
-      myLinks.Substitute(LinkIndex, theLink, aPair);
-      myDelLinks.RemoveFirst();
-    }
-    else {
-      LinkIndex=myLinks.Add(theLink, aPair);
-    }
-    myNodes(theLink.FirstNode()).Append(Abs(LinkIndex));
-    myNodes(theLink.LastNode()).Append(Abs(LinkIndex));
-    myLinkOfDomain.Add(LinkIndex);
+  BRepMesh_Edge& aLink = (BRepMesh_Edge&)GetLink(theIndex);
+  if (aLink.Movability() == BRepMesh_Deleted            ||
+      (!isForce && aLink.Movability() != BRepMesh_Free) ||
+      ElementsConnectedTo(theIndex).Extent() != 0)
+  {
+    return;
   }
-  else if (!theLink.SameOrientation(myLinks.FindKey(LinkIndex))) 
-    LinkIndex=-LinkIndex;
 
-  return LinkIndex;
-}
+  cleanLink(theIndex, aLink);
+  aLink.SetMovability(BRepMesh_Deleted);
 
-//=======================================================================
-//function : GetLink
-//purpose  : 
-//=======================================================================
-const BRepMesh_Edge&  BRepMesh_DataStructureOfDelaun::GetLink(const Standard_Integer Index)
-{
-  return myLinks.FindKey(Index);
+  myLinksOfDomain.Remove(theIndex);
+  myDelLinks.Append     (theIndex);
 }
 
 //=======================================================================
-//function : RemoveLink
+//function : cleanLink
 //purpose  : 
 //=======================================================================
-void  BRepMesh_DataStructureOfDelaun::RemoveLink(const Standard_Integer Index)
+void BRepMesh_DataStructureOfDelaun::cleanLink(
+  const Standard_Integer theIndex,
+  const BRepMesh_Edge&   theLink)
 {
-  //Warning, the static cast from const& to & is called for
-  //performance reasons. This is applicable only in case if later
-  //modification of element (field movability) does not influent on
-  //has calculation.
-  BRepMesh_Edge& lref=(BRepMesh_Edge&)myLinks.FindKey(Index);
-  if (lref.Movability()!=BRepMesh_Deleted) {
-    if (lref.Movability()==BRepMesh_Free && 
-      myLinks.FindFromIndex(Index).Extent()==0) {
-        BRepMesh_ListOfInteger::Iterator tit;
-        BRepMesh_ListOfInteger& aList1 = myNodes(lref.FirstNode());
-        for(tit.Init(aList1); tit.More(); tit.Next()){
-          if (tit.Value()==Index) {
-            aList1.Remove(tit);
-            break;
-          }
-        }
-        BRepMesh_ListOfInteger& aList2 = myNodes(lref.LastNode());
-        for(tit.Init(aList2); tit.More(); tit.Next()){
-          if (tit.Value()==Index) {
-            aList2.Remove(tit);
-            break;
-          }
-        }
-        myLinkOfDomain.Remove(Index);
-        lref.SetMovability(BRepMesh_Deleted);
-        myDelLinks.Append(Index);
-    }
-  }
-}
+  for (Standard_Integer i = 0; i < 2; ++i)
+  {
+    const Standard_Integer aNodeId = (i == 0) ?
+      theLink.FirstNode() : theLink.LastNode();
 
-//=======================================================================
-//function : SubstituteLink
-//purpose  : 
-//=======================================================================
-Standard_Boolean  BRepMesh_DataStructureOfDelaun::SubstituteLink(const Standard_Integer Index,
-                                                                 const BRepMesh_Edge& newLink)
-{
-  //BRepMesh_ListOfInteger thelist(myAllocator);
-  BRepMesh_PairOfIndex aPair;
-  BRepMesh_Edge lref=myLinks.FindKey(Index);
-  if (lref.Movability()==BRepMesh_Deleted) 
-    myLinks.Substitute(Index, newLink, aPair);
-  else {
-    if (myLinks.FindIndex(newLink)!=0) 
-      return Standard_False;
-
-    lref.SetMovability(BRepMesh_Deleted);
-    myLinks.Substitute(Index, lref, aPair);
-
-    BRepMesh_ListOfInteger::Iterator tit;
-    for(tit.Init(myNodes(lref.FirstNode())); tit.More(); tit.Next()){
-      if (tit.Value()==Index) {
-        myNodes(lref.FirstNode()).Remove(tit);
+    BRepMeshCol::ListOfInteger& aLinkList = myNodes(aNodeId);
+    BRepMeshCol::ListOfInteger::Iterator aLinkIt(aLinkList);
+    for(; aLinkIt.More(); aLinkIt.Next())
+    {
+      if (aLinkIt.Value() == theIndex)
+      {
+        aLinkList.Remove(aLinkIt);
         break;
       }
     }
-    for(tit.Init(myNodes(lref.LastNode())); tit.More(); tit.Next()){
-      if (tit.Value()==Index) {
-        myNodes(lref.LastNode()).Remove(tit);
-        break;
-      }
-    }
-    myLinks.Substitute(Index, newLink, aPair);
-    myNodes(newLink.FirstNode()).Append(Abs(Index));
-    myNodes(newLink.LastNode()).Append(Abs(Index));
   }
-  return Standard_True;
-}
-
-//=======================================================================
-//function : NbLinks
-//purpose  : 
-//=======================================================================
-Standard_Integer  BRepMesh_DataStructureOfDelaun::NbLinks()const
-{
-  return myLinks.Extent();
 }
 
 //=======================================================================
 //function : AddElement
 //purpose  : 
 //=======================================================================
-Standard_Integer  BRepMesh_DataStructureOfDelaun::AddElement(const BRepMesh_Triangle& theElement)
+Standard_Integer BRepMesh_DataStructureOfDelaun::AddElement(
+  const BRepMesh_Triangle& theElement)
 {
-  Standard_Integer ElemIndex=myElements.FindIndex(theElement);
-
-  if (ElemIndex<=0) {
-    /* Not_Debuged_Yet 
-    if (!myDelElements.IsEmpty()) {
-    ElemIndex=myDelElements.First();
-    myElements.Substitute(ElemIndex, theElement);
-    myDelElements.RemoveFirst();
-    }
-    else */
-    ElemIndex=myElements.Add(theElement);
+  Standard_Integer aElementIndex = IndexOf(theElement);
+  if (aElementIndex > 0)
+    return aElementIndex;
 
-    myElemOfDomain.Add(ElemIndex);
+  aElementIndex = myElements.Add(theElement);
+  myElementsOfDomain.Add(aElementIndex);
 
-    Standard_Integer ed1, ed2, ed3;
-    Standard_Boolean or1, or2, or3;
-    theElement.Edges(ed1, ed2, ed3, or1, or2, or3);
-    myLinks(ed1).Append(ElemIndex);
-    myLinks(ed2).Append(ElemIndex);
-    myLinks(ed3).Append(ElemIndex);
-  }
+  Standard_Integer e[3];
+  Standard_Boolean o[3];
+  theElement.Edges(e, o);
+  for (Standard_Integer i = 0; i < 3; ++i)
+    myLinks(e[i]).Append(aElementIndex);
 
-  return ElemIndex;
+  return aElementIndex;
 }
 
 //=======================================================================
-//function : GetElement
+//function : RemoveElement
 //purpose  : 
 //=======================================================================
-const BRepMesh_Triangle&  BRepMesh_DataStructureOfDelaun::GetElement(const Standard_Integer Index)
+void BRepMesh_DataStructureOfDelaun::RemoveElement(
+  const Standard_Integer theIndex)
 {
-  return myElements.FindKey(Index);
+  BRepMesh_Triangle& aElement = (BRepMesh_Triangle&)GetElement(theIndex);
+  if (aElement.Movability() == BRepMesh_Deleted)
+    return;
+
+  cleanElement(theIndex, aElement);
+  aElement.SetMovability(BRepMesh_Deleted);
+  myElementsOfDomain.Remove(theIndex);
 }
 
 //=======================================================================
-//function : RemoveElement
+//function : cleanElement
 //purpose  : 
 //=======================================================================
-void  BRepMesh_DataStructureOfDelaun::RemoveElement(const Standard_Integer Index)
+void BRepMesh_DataStructureOfDelaun::cleanElement(
+  const Standard_Integer   theIndex,
+  const BRepMesh_Triangle& theElement)
 {
-  //Warning, the static cast from const& to & is called for
-  //performance reasons. This is applicable only in case if later
-  //modification of element (field movability) does not influent on
-  //has calculation.
-  BRepMesh_Triangle& lelem=(BRepMesh_Triangle&)myElements.FindKey(Index);
-  if (lelem.Movability()!=BRepMesh_Deleted) {
-    ClearElement(Index, lelem);
-    lelem.SetMovability(BRepMesh_Deleted);
-    // Not_Debuged_Yet myDelElements.Append(Index);
-    myElemOfDomain.Remove(Index);
-  }
-}
+  if (theElement.Movability() != BRepMesh_Free)
+    return;
 
-static void removeElementIndex(BRepMesh_PairOfIndex& thePair,
-                               const Standard_Integer Index)
-{
-  for(Standard_Integer i = 1, n = thePair.Extent(); i <= n; i++) {
-    if (thePair.Index(i)==Index) {
-      thePair.RemoveIndex(i);
-      break;
-    }
-  }
-}
+  Standard_Integer e[3];
+  Standard_Boolean o[3];
+  theElement.Edges(e, o);
 
-void  BRepMesh_DataStructureOfDelaun::ClearElement(const Standard_Integer Index,
-                                                   const BRepMesh_Triangle& theElem)
-{
-  if (theElem.Movability()==BRepMesh_Free) {
-    Standard_Integer ed1, ed2, ed3;
-    Standard_Boolean or1, or2, or3;
-    theElem.Edges(ed1, ed2, ed3, or1, or2, or3);
-    removeElementIndex(myLinks(ed1),Index);
-    removeElementIndex(myLinks(ed2),Index);
-    removeElementIndex(myLinks(ed3),Index);
-  }
+  for (Standard_Integer i = 0; i < 3; ++i)
+    removeElementIndex(theIndex, myLinks(e[i]));
 }
 
 //=======================================================================
-//function : SubstituteElement
+//function : removeElementIndex
 //purpose  : 
 //=======================================================================
-Standard_Boolean  BRepMesh_DataStructureOfDelaun::SubstituteElement
-(const Standard_Integer Index, const BRepMesh_Triangle& newElement)
+void BRepMesh_DataStructureOfDelaun::removeElementIndex(
+  const Standard_Integer theIndex,
+  BRepMesh_PairOfIndex&  thePair)
 {
-  const BRepMesh_Triangle& lelem=myElements.FindKey(Index);
-  if (lelem.Movability()==BRepMesh_Deleted) 
-    myElements.Substitute(Index, newElement);
-  else {
-    if (myElements.FindIndex(newElement)==0) {
-      ClearElement(Index, lelem);
-      // Warning: here new element and old element should have different Hash code
-      myElements.Substitute(Index, newElement);
-
-      Standard_Integer ed1, ed2, ed3;
-      Standard_Boolean or1, or2, or3;
-      newElement.Edges(ed1, ed2, ed3, or1, or2, or3);
-      myLinks(ed1).Append(Index);
-      myLinks(ed2).Append(Index);
-      myLinks(ed3).Append(Index);
+  for (Standard_Integer i = 1, n = thePair.Extent(); i <= n; ++i)
+  {
+    if (thePair.Index(i) == theIndex)
+    {
+      thePair.RemoveIndex(i);
+      return;
     }
-    else return Standard_False;
   }
-  return Standard_True;
 }
 
 //=======================================================================
-//function : ClearDomain
+//function : SubstituteElement
 //purpose  : 
 //=======================================================================
-void BRepMesh_DataStructureOfDelaun::ClearDomain()
+Standard_Boolean BRepMesh_DataStructureOfDelaun::SubstituteElement(
+  const Standard_Integer   theIndex,
+  const BRepMesh_Triangle& theNewElement)
 {
-  BRepMesh_MapOfInteger freeEdges;
-  Standard_Integer ed1, ed2, ed3;
-  Standard_Boolean or1, or2, or3;
-  BRepMesh_MapOfInteger::Iterator itDom(myElemOfDomain);
-  //Warning, the static cast from const& to & is called for
-  //performance reasons. This is applicable only in case if later
-  //modification of element (field movability) does not influent on
-  //has calculation.
-  for (;itDom.More(); itDom.Next()) {
-    BRepMesh_Triangle& lelem=(BRepMesh_Triangle&)myElements.FindKey(itDom.Key());
-    lelem.Edges(ed1, ed2, ed3, or1, or2, or3);
-    freeEdges.Add(ed1);
-    freeEdges.Add(ed2);
-    freeEdges.Add(ed3);
-    ClearElement(itDom.Key(), lelem);
-    lelem.SetMovability(BRepMesh_Deleted);
-    // Not_Debuged_Yet myDelElements.Append(itDom.Key());
+  const BRepMesh_Triangle& aElement = GetElement(theIndex);
+  if (aElement.Movability() == BRepMesh_Deleted) 
+  {
+    myElements.Substitute(theIndex, theNewElement);
+    return Standard_True;
   }
-  myElemOfDomain.Clear();
-  BRepMesh_MapOfInteger::Iterator edgeIt(freeEdges);
-  for (; edgeIt.More(); edgeIt.Next())
-    RemoveLink(edgeIt.Key());
-}
 
-//=======================================================================
-//function : NbElements
-//purpose  : 
-//=======================================================================
-Standard_Integer  BRepMesh_DataStructureOfDelaun::NbElements()const 
-{
-  return myElements.Extent();
-}
+  if (IndexOf(theNewElement) != 0)
+    return Standard_False;
 
-//=======================================================================
-//function : IndexOf
-//purpose  : 
-//=======================================================================
-Standard_Integer BRepMesh_DataStructureOfDelaun::IndexOf(const BRepMesh_Vertex& aNode)
-{
-  return myNodes.FindIndex(aNode);
-}
+  cleanElement(theIndex, aElement);
+  // Warning: here new element and old element should have different Hash code
+  myElements.Substitute(theIndex, theNewElement);
 
-//=======================================================================
-//function : IndexOf
-//purpose  : 
-//=======================================================================
-Standard_Integer BRepMesh_DataStructureOfDelaun::IndexOf(const BRepMesh_Edge& aLink)const
-{
-  return myLinks.FindIndex(aLink);
-}
+  Standard_Integer e[3];
+  Standard_Boolean o[3];
+  theNewElement.Edges(e, o);
+  for (Standard_Integer i = 0; i < 3; ++i)
+    myLinks(e[i]).Append(theIndex);
 
-//=======================================================================
-//function : IndexOf
-//purpose  : 
-//=======================================================================
-Standard_Integer BRepMesh_DataStructureOfDelaun::IndexOf(const BRepMesh_Triangle& anElement)const
-{
-  return myElements.FindIndex(anElement);
+  return Standard_True;
 }
 
 //=======================================================================
-//function : LinkNeighboursOf
-//purpose  : 
+//function : ElementNodes
+//purpose  :
 //=======================================================================
-const BRepMesh_ListOfInteger&  BRepMesh_DataStructureOfDelaun::LinkNeighboursOf
-(const Standard_Integer theNode)const 
+void BRepMesh_DataStructureOfDelaun::ElementNodes(
+    const BRepMesh_Triangle& theElement,
+    Standard_Integer         (&theNodes)[3])
 {
-  return myNodes.FindFromIndex(theNode);
-}
+  Standard_Integer e[3];
+  Standard_Boolean o[3];
+  theElement.Edges(e, o);
 
-//=======================================================================
-//function : ElemConnectedTo
-//purpose  : 
-//=======================================================================
-const BRepMesh_PairOfIndex&  BRepMesh_DataStructureOfDelaun::ElemConnectedTo 
-(const Standard_Integer theLink)const 
-{
-  return myLinks.FindFromIndex(theLink);
+  const BRepMesh_Edge& aLink1 = GetLink(e[0]);
+  if (o[0])
+  {
+    theNodes[0] = aLink1.FirstNode();
+    theNodes[1] = aLink1.LastNode();
+  }
+  else
+  {
+    theNodes[1] = aLink1.FirstNode();
+    theNodes[0] = aLink1.LastNode();
+  }
+  
+  const BRepMesh_Edge& aLink2 = GetLink(e[2]);
+  if (o[2])
+    theNodes[2] = aLink2.FirstNode();
+  else
+    theNodes[2] = aLink2.LastNode();
 }
 
 //=======================================================================
-//function : ElemOfDomain
+//function : ClearDomain
 //purpose  : 
 //=======================================================================
-const BRepMesh_MapOfInteger&  BRepMesh_DataStructureOfDelaun::ElemOfDomain () const
+void BRepMesh_DataStructureOfDelaun::ClearDomain()
 {
-  return myElemOfDomain;
-}
+  BRepMeshCol::MapOfInteger aFreeEdges;
+  BRepMeshCol::MapOfInteger::Iterator aElementIt(myElementsOfDomain);
+  for (; aElementIt.More(); aElementIt.Next())
+  {
+    const Standard_Integer aElementId = aElementIt.Key();
+    BRepMesh_Triangle& aElement = (BRepMesh_Triangle&)GetElement(aElementId);
 
-//=======================================================================
-//function : LinkOfDomain
-//purpose  : 
-//=======================================================================
-const BRepMesh_MapOfInteger&  BRepMesh_DataStructureOfDelaun::LinkOfDomain () const
-{
-  return myLinkOfDomain;
+    Standard_Integer e[3];
+    Standard_Boolean o[3];
+    aElement.Edges(e, o);
+
+    for (Standard_Integer i = 0; i < 3; ++i)
+      aFreeEdges.Add(e[i]);
+
+    cleanElement(aElementId, aElement);
+    aElement.SetMovability(BRepMesh_Deleted);
+  }
+  myElementsOfDomain.Clear();
+
+  BRepMeshCol::MapOfInteger::Iterator aEdgeIt(aFreeEdges);
+  for (; aEdgeIt.More(); aEdgeIt.Next())
+    RemoveLink(aEdgeIt.Key());
 }
 
 //=======================================================================
-//function : ClearDeleted
+//function : clearDeletedLinks
 //purpose  : 
 //=======================================================================
-void BRepMesh_DataStructureOfDelaun::ClearDeleted()
+void BRepMesh_DataStructureOfDelaun::clearDeletedLinks()
 {
-
-  // Traitement des Elements 
-
-  Standard_Integer IndexDelItem;
-
-  Standard_Integer lastNonDelItem=myElements.Extent();
-  /* // Not_Debuged_Yet 
-  while (!myDelElements.IsEmpty()) {
-  while (lastNonDelItem>0) {
-  if (myElements.FindKey(lastNonDelItem).Movability()!=BRepMesh_Deleted)
-  break;
-  myElements.RemoveLast();
-  lastNonDelItem--;
-  }
-
-  IndexDelItem=myDelElements.First();
-  myDelElements.RemoveFirst();
-
-  if (IndexDelItem<lastNonDelItem) {
-  BRepMesh_Triangle eItem=myElements.FindKey(lastNonDelItem);
-  myElements.RemoveLast();
-  myElements.Substitute(IndexDelItem, eItem);
-  myElemOfDomain.Remove(lastNonDelItem);
-  myElemOfDomain.Add(IndexDelItem);
-  lastNonDelItem--;
-
-  Standard_Integer ed[3], ied;
-  Standard_Boolean orient[3];
-  eItem.Edges(ed[0], ed[1], ed[2], orient[0], orient[1], orient[2]);
-  BRepMesh_ListOfInteger::Iterator itList;
-  for (ied=0; ied<3; ied++) {
-  BRepMesh_PairOfIndex& aPair = myLinks(ed[ied]);
-  for(Standard_Integer j = 1, jn = aPair.Extent(); j <= jn; j++)
-  if (aPair.Index(j)==(lastNonDelItem+1)) {
-  aPair.SetIndex(j,IndexDelItem);
-  break;
-  }
-  }
-  }
-  }
-  */
-
-  // Process Links:
-  lastNonDelItem=myLinks.Extent();
-
-  while (!myDelLinks.IsEmpty()) {
-    while (lastNonDelItem>0) {
-      if (myLinks.FindKey(lastNonDelItem).Movability()!=BRepMesh_Deleted)
+  Standard_Integer aLastLiveItem = NbLinks();
+  while (!myDelLinks.IsEmpty())
+  {
+    while (aLastLiveItem > 0)
+    {
+      if (GetLink(aLastLiveItem).Movability() != BRepMesh_Deleted)
         break;
+
       myLinks.RemoveLast();
-      lastNonDelItem--;
+      --aLastLiveItem;
     }
 
-    IndexDelItem = myDelLinks.First();
+    Standard_Integer aDelItem = myDelLinks.First();
     myDelLinks.RemoveFirst();
 
-    if (IndexDelItem < lastNonDelItem) {
-      BRepMesh_Edge lItem=myLinks.FindKey(lastNonDelItem);
-      BRepMesh_PairOfIndex Data(myLinks(lastNonDelItem));
-      myLinks.RemoveLast();
-      myLinks.Substitute(IndexDelItem, lItem, Data);
-      myLinkOfDomain.Remove(lastNonDelItem);
-      myLinkOfDomain.Add(IndexDelItem);
-      lastNonDelItem--;
-
-      Standard_Integer iv[2], ivx;
-      iv[0]=lItem.FirstNode();
-      iv[1]=lItem.LastNode();
-
-      BRepMesh_ListOfInteger::Iterator itLis;
-      for (ivx=0; ivx<2; ivx++) {
-        for (itLis.Init(myNodes(iv[ivx])); 
-          itLis.More(); itLis.Next()) {
-            if (itLis.Value()==(lastNonDelItem+1)) {
-              itLis.ChangeValue()=IndexDelItem;
-              break;
-            }
+    if (aDelItem > aLastLiveItem)
+      continue;
+
+    BRepMesh_Edge aLink = GetLink(aLastLiveItem);
+    BRepMesh_PairOfIndex& aPair = myLinks(aLastLiveItem);
+
+    myLinks.RemoveLast();
+    myLinks.Substitute(aDelItem, aLink, aPair);
+
+    myLinksOfDomain.Remove(aLastLiveItem);
+    myLinksOfDomain.Add(aDelItem);
+    --aLastLiveItem;
+
+    const Standard_Integer aLastLiveItemId = aLastLiveItem + 1;
+    BRepMeshCol::ListOfInteger::Iterator aLinkIt;
+    // update link references
+    for (Standard_Integer i = 0; i < 2; ++i)
+    {
+      const Standard_Integer aCurNodeId = (i == 0) ?
+        aLink.FirstNode() : aLink.LastNode();
+
+      for (aLinkIt.Init(myNodes(aCurNodeId)); aLinkIt.More(); aLinkIt.Next())
+      {
+        Standard_Integer& aLinkId = aLinkIt.ChangeValue();
+        if (aLinkId == aLastLiveItemId)
+        {
+          aLinkId = aDelItem;
+          break;
         }
       }
-      for(Standard_Integer j = 1, jn = Data.Extent(); j <= jn; j++) {
-        const BRepMesh_Triangle& Elem=myElements.FindKey(Data.Index(j));
-
-        Standard_Integer el[3], iel;
-        Standard_Boolean orl[3];
-        Elem.Edges(el[0], el[1], el[2], orl[0], orl[1], orl[2]);
-        for (iel=0; iel<3; iel++) {
-          if (el[iel]==lastNonDelItem+1) {
-            el[iel]=IndexDelItem;
-            break;
-          }
+    }
+
+    // update elements references
+    for(Standard_Integer j = 1, jn = aPair.Extent(); j <= jn; ++j)
+    {
+      const BRepMesh_Triangle& aElement = GetElement(aPair.Index(j));
+
+      Standard_Integer e[3];
+      Standard_Boolean o[3];
+      aElement.Edges(e, o);
+      for (Standard_Integer i = 0; i < 3; ++i)
+      {
+        if (e[i] == aLastLiveItemId)
+        {
+          e[i] = aDelItem;
+          break;
         }
-        myElements.Substitute(itLis.Value(),
-          BRepMesh_Triangle(el[0], el[1], el[2],
-          orl[0], orl[1], orl[2],
-          Elem.Movability() ));
       }
+
+      myElements.Substitute(aLinkIt.Value(), 
+        BRepMesh_Triangle(e, o, aElement.Movability()));
     }
   }
+}
 
+//=======================================================================
+//function : clearDeletedNodes
+//purpose  : 
+//=======================================================================
+void BRepMesh_DataStructureOfDelaun::clearDeletedNodes()
+{
+  BRepMeshCol::ListOfInteger& aDelNodes = 
+    (BRepMeshCol::ListOfInteger&)myNodes.GetListOfDelNodes();
 
-  // Process Nodes:
-  lastNonDelItem = myNodes.Extent();
-  BRepMesh_ListOfInteger &aDelNodes = (BRepMesh_ListOfInteger &)myNodes.GetListOfDelNodes();
-
-  while (!aDelNodes.IsEmpty()) {
-    while (lastNonDelItem > 0) {
-      if (myNodes.FindKey(lastNonDelItem).Movability()!=BRepMesh_Deleted)
+  Standard_Integer aLastLiveItem = NbNodes();
+  while (!aDelNodes.IsEmpty())
+  {
+    while (aLastLiveItem > 0)
+    {
+      if (GetNode(aLastLiveItem).Movability() != BRepMesh_Deleted)
         break;
+
       myNodes.RemoveLast();
-      lastNonDelItem--;
+      --aLastLiveItem;
     }
-    IndexDelItem = aDelNodes.First();
+
+    Standard_Integer aDelItem = aDelNodes.First();
     aDelNodes.RemoveFirst();
 
-    if (IndexDelItem<lastNonDelItem) {
-      BRepMesh_Vertex nItem = myNodes.FindKey(lastNonDelItem);
-      BRepMesh_ListOfInteger Data;
-      Data.Append(myNodes(lastNonDelItem));
-      myNodes.RemoveLast();
-      lastNonDelItem--;
-      myNodes.Substitute(IndexDelItem, nItem, Data);
-
-      BRepMesh_ListOfInteger::Iterator itLi;
-      for (itLi.Init(Data); itLi.More(); itLi.Next()) {
-        const BRepMesh_Edge& li=myLinks.FindKey(itLi.Value());
-        BRepMesh_PairOfIndex conx(myLinks(itLi.Value()));
-        Standard_Integer iv1=li.FirstNode();
-        Standard_Integer iv2=li.LastNode();
-        if      (iv1==lastNonDelItem+1) iv1=IndexDelItem;
-        else if (iv2==lastNonDelItem+1) iv2=IndexDelItem;
-
-        myLinks.Substitute(itLi.Value(),
-          BRepMesh_Edge(iv1, iv2, li.Movability()), conx);
-      }
+    if (aDelItem > aLastLiveItem)
+      continue;
+
+    BRepMesh_Vertex aNode = GetNode(aLastLiveItem);
+    BRepMeshCol::ListOfInteger& aLinkList = myNodes(aLastLiveItem);
+
+    myNodes.RemoveLast();
+    --aLastLiveItem;
+
+    myNodes.Substitute(aDelItem, aNode, aLinkList);
+
+    const Standard_Integer aLastLiveItemId = aLastLiveItem + 1;
+    BRepMeshCol::ListOfInteger::Iterator aLinkIt(aLinkList);
+    for (; aLinkIt.More(); aLinkIt.Next())
+    {
+      const Standard_Integer aLinkId = aLinkIt.Value();
+      const BRepMesh_Edge& aLink = GetLink(aLinkId);
+      BRepMesh_PairOfIndex& aPair = myLinks(aLinkId);
+
+      Standard_Integer v[2] = { aLink.FirstNode(), aLink.LastNode() };
+      if (v[0] == aLastLiveItemId)
+        v[0] = aDelItem;
+      else if (v[1] == aLastLiveItemId)
+        v[1] = aDelItem;
+
+      myLinks.Substitute(aLinkId,
+        BRepMesh_Edge(v[0], v[1], aLink.Movability()), aPair);
     }
   }
 }
@@ -638,35 +474,77 @@ void BRepMesh_DataStructureOfDelaun::ClearDeleted()
 //function : Statistics
 //purpose  : 
 //=======================================================================
-void BRepMesh_DataStructureOfDelaun::Statistics(Standard_OStream& S) const
+void BRepMesh_DataStructureOfDelaun::Statistics(Standard_OStream& theStream) const
 {
-  S << " Map de nodes : \n";
-  myNodes.Statistics(S);
-  S << "\n Deleted nodes : " << myNodes.GetListOfDelNodes().Extent() << endl;
+  theStream << " Map of nodes : \n";
+  myNodes.Statistics(theStream);
+  theStream << "\n Deleted nodes : " << myNodes.GetListOfDelNodes().Extent() << endl;
 
-  S << "\n\n Map de Links : \n";
-  myLinks.Statistics(S);
-  S << "\n Deleted links : " << myDelLinks.Extent() << endl;
+  theStream << "\n\n Map of Links : \n";
+  myLinks.Statistics(theStream);
+  theStream << "\n Deleted links : " << myDelLinks.Extent() << endl;
 
-  S << "\n\n Map d elements : \n";
-  myElements.Statistics(S);
-  // Not_Debuged_Yet S << "\n Deleted elements : " << myDelElements.Extent() << endl;
+  theStream << "\n\n Map of elements : \n";
+  myElements.Statistics(theStream);
 }
 
 //=======================================================================
-//function : Allocator()
+//function : BRepMesh_Write
 //purpose  : 
+//  Global function not declared in any public header, intended for use 
+//  from debugger prompt (Command Window in Visual Studio).
+//
+//  Stores the mesh data structure to BRep file with the given name.
 //=======================================================================
-const BRepMesh_BaseAllocator& BRepMesh_DataStructureOfDelaun::Allocator() const
+Standard_CString BRepMesh_Dump(void*            theMeshHandlePtr,
+                               Standard_CString theFileNameStr)
 {
-  return myAllocator;
-}
+  if (theMeshHandlePtr == 0 || theFileNameStr == 0)
+  {
+    return "Error: file name or mesh data is null";
+  }
 
-//=======================================================================
-//function : Data
-//purpose  : 
-//=======================================================================
-BRepMesh_VertexTool& BRepMesh_DataStructureOfDelaun::Data()
-{
-  return myNodes;
+  Handle(BRepMesh_DataStructureOfDelaun) aMeshData = 
+    *(Handle(BRepMesh_DataStructureOfDelaun)*)theMeshHandlePtr;
+
+  if (aMeshData.IsNull())
+    return "Error: mesh data is empty";
+
+  TopoDS_Compound aMesh;
+  BRep_Builder aBuilder;
+  aBuilder.MakeCompound(aMesh);
+
+  try
+  {
+    OCC_CATCH_SIGNALS
+
+    BRepMeshCol::MapOfInteger::Iterator aLinksIt(aMeshData->LinksOfDomain());
+    for (; aLinksIt.More(); aLinksIt.Next())
+    {
+      const BRepMesh_Edge& aLink = aMeshData->GetLink(aLinksIt.Value());
+      gp_Pnt aPnt[2];
+      for (Standard_Integer i = 0; i < 2; ++i)
+      {
+        const Standard_Integer aNodeId = 
+          (i == 0) ? aLink.FirstNode() : aLink.LastNode();
+
+        const gp_XY& aNode = aMeshData->GetNode(aNodeId).Coord();
+        aPnt[i] = gp_Pnt(aNode.X(), aNode.Y(), 0.);
+      }
+
+      if (aPnt[0].SquareDistance(aPnt[1]) < Precision::SquareConfusion())
+        continue;
+
+      aBuilder.Add(aMesh, BRepBuilderAPI_MakeEdge(aPnt[0], aPnt[1]));
+    }
+
+    if (!BRepTools::Write(aMesh, theFileNameStr))
+      return "Error: write failed";
+  }
+  catch (Standard_Failure)
+  {
+    return Standard_Failure::Caught()->GetMessageString();
+  }
+
+  return theFileNameStr;
 }
diff --git a/src/BRepMesh/BRepMesh_DataStructureOfDelaun.hxx b/src/BRepMesh/BRepMesh_DataStructureOfDelaun.hxx
new file mode 100644 (file)
index 0000000..3b80b8a
--- /dev/null
@@ -0,0 +1,319 @@
+// Copyright (c) 2013 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 _BRepMesh_DataStructureOfDelaun_HeaderFile
+#define _BRepMesh_DataStructureOfDelaun_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineHandle.hxx>
+#include <BRepMesh_VertexTool.hxx>
+#include <Standard_Transient.hxx>
+#include <BRepMesh_Triangle.hxx>
+#include <BRepMesh_PairOfIndex.hxx>
+#include <Standard_OStream.hxx>
+#include <BRepMesh_Collections.hxx>
+
+class BRepMesh_Vertex;
+class BRepMesh_VertexTool;
+class BRepMesh_Edge;
+
+//! Describes the data structure necessary for the mesh algorithms in 
+//! two dimensions plane or on surface by meshing in UV space.
+class BRepMesh_DataStructureOfDelaun : public Standard_Transient
+{
+public:
+
+  //! Constructor.
+  //! \param theAllocator memory allocator to be used by internal structures.
+  //! \param theReservedNodeSize presumed number of nodes in this mesh.
+  Standard_EXPORT BRepMesh_DataStructureOfDelaun(
+    const BRepMeshCol::Allocator& theAllocator,
+    const Standard_Integer        theReservedNodeSize = 100);
+
+
+
+public: //! \name API for accessing mesh nodes.
+
+  //! Returns number of nodes.
+  inline Standard_Integer NbNodes() const
+  {
+    return myNodes.Extent();
+  }
+
+
+  //! Adds node to the mesh if it is not already in the mesh.
+  //! \param theNode node to be added to the mesh.
+  //! \return index of the node in the structure.
+  inline Standard_Integer AddNode(const BRepMesh_Vertex& theNode)
+  {
+    return myNodes.Add(theNode);
+  }
+
+  //! Finds the index of the given node.
+  //! \param theNode node to find.
+  //! \return index of the given element of zero if node is not in the mesh.
+  Standard_EXPORT Standard_Integer IndexOf(const BRepMesh_Vertex& theNode)
+  {
+    return myNodes.FindIndex(theNode);
+  }
+
+  //! Get node by the index.
+  //! \param theIndex index of a node.
+  //! \return node with the given index.
+  inline const BRepMesh_Vertex& GetNode(const Standard_Integer theIndex)
+  {
+    return myNodes.FindKey(theIndex);
+  }
+
+  //! Alias for GetNode.
+  const BRepMesh_Vertex& operator ()(const Standard_Integer theIndex)
+  {
+    return GetNode(theIndex);
+  }
+
+  //! Replaces nodes of mesh by the given ones.
+  //! \param theNewNodes nodes to be set instead of existing ones.
+  Standard_EXPORT void ReplaceNodes(const BRepMesh_VertexTool& theNewNodes)
+  {
+    if (theNewNodes.IsEmpty())
+      return;
+
+    myNodes = theNewNodes;
+  }
+
+  //! Substitutes the node with the given index by new one.
+  //! \param theIndex index of node to be substituted.
+  //! \param theNewNode substituting node.
+  //! \return FALSE in case if new node is already in the structure, TRUE elsewhere.
+  Standard_EXPORT Standard_Boolean SubstituteNode(
+    const Standard_Integer theIndex,
+    const BRepMesh_Vertex& theNewNode);
+
+  //! Removes node from the mesh in case if it has no connected links 
+  //! and its type is Free.
+  //! \param theIndex index of node to be removed.
+  //! \param isForce if TRUE node will be removed even if movability
+  //! is not Free.
+  Standard_EXPORT void RemoveNode(const Standard_Integer theIndex,
+                                  const Standard_Boolean isForce = Standard_False)
+  {
+    if (isForce || myNodes.FindKey(theIndex).Movability() == BRepMesh_Free)
+    {
+      if (myNodes.FindFromIndex(theIndex).Extent()==0)
+        myNodes.Delete(theIndex);
+    }
+  }
+
+  //! Get list of links attached to the node with the given index.
+  //! \param theIndex index of node whose links should be retrieved.
+  //! \return list of links attached to the node.
+  inline const BRepMeshCol::ListOfInteger& LinksConnectedTo(
+    const Standard_Integer theIndex) const
+  {
+    return myNodes.FindFromIndex(theIndex);
+  }
+
+
+
+public: //! \name API for accessing mesh links.
+
+  //! Returns number of links.
+  inline Standard_Integer NbLinks() const
+  {
+    return myLinks.Extent();
+  }
+
+  //! Adds link to the mesh if it is not already in the mesh.
+  //! \param theLink link to be added to the mesh.
+  //! \return index of the link in the structure.
+  Standard_EXPORT Standard_Integer AddLink(const BRepMesh_Edge& theLink);
+
+  //! Finds the index of the given link.
+  //! \param theLink link to find.
+  //! \return index of the given element of zero if link is not in the mesh.
+  Standard_EXPORT Standard_Integer IndexOf(const BRepMesh_Edge& theLink) const
+  {
+    return myLinks.FindIndex(theLink);
+  }
+
+  //! Get link by the index.
+  //! \param theIndex index of a link.
+  //! \return link with the given index.
+  Standard_EXPORT const BRepMesh_Edge& GetLink(const Standard_Integer theIndex)
+  {
+    return myLinks.FindKey(theIndex);
+  }
+
+  //! Returns map of indices of links registered in mesh.
+  inline const BRepMeshCol::MapOfInteger& LinksOfDomain() const
+  {
+    return myLinksOfDomain;
+  }
+
+  //! Substitutes the link with the given index by new one.
+  //! \param theIndex index of link to be substituted.
+  //! \param theNewLink substituting link.
+  //! \return FALSE in case if new link is already in the structure, TRUE elsewhere.
+  Standard_EXPORT Standard_Boolean SubstituteLink(const Standard_Integer theIndex,
+                                                  const BRepMesh_Edge&   theNewLink);
+
+  //! Removes link from the mesh in case if it has no connected elements 
+  //! and its type is Free.
+  //! \param theIndex index of link to be removed.
+  //! \param isForce if TRUE link will be removed even if movability
+  //! is not Free.
+  Standard_EXPORT void RemoveLink(const Standard_Integer theIndex,
+                                  const Standard_Boolean isForce = Standard_False);
+
+  //! Returns indices of elements conected to the link with the given index.
+  //! \param theLinkIndex index of link whose data should be retrieved.
+  //! \return indices of elements conected to the link.
+  Standard_EXPORT const BRepMesh_PairOfIndex& ElementsConnectedTo(
+    const Standard_Integer theLinkIndex) const
+  {
+    return myLinks.FindFromIndex(theLinkIndex);
+  }
+
+
+
+public: //! \name API for accessing mesh elements.
+
+  //! Returns number of links.
+  inline Standard_Integer NbElements() const
+  {
+    return myElements.Extent();
+  }
+
+  //! Adds element to the mesh if it is not already in the mesh.
+  //! \param theElement element to be added to the mesh.
+  //! \return index of the element in the structure.
+  Standard_EXPORT Standard_Integer AddElement(const BRepMesh_Triangle& theElement);
+
+  //! Finds the index of the given element.
+  //! \param theElement element to find.
+  //! \return index of the given element of zero if element is not in the mesh.
+  Standard_EXPORT Standard_Integer IndexOf(const BRepMesh_Triangle& theElement) const
+  {
+    return myElements.FindIndex(theElement);
+  }
+
+  //! Get element by the index.
+  //! \param theIndex index of an element.
+  //! \return element with the given index.
+  Standard_EXPORT const BRepMesh_Triangle& GetElement(const Standard_Integer theIndex)
+  {
+    return myElements.FindKey(theIndex);
+  }
+
+  //! Returns map of indices of elements registered in mesh.
+  inline const BRepMeshCol::MapOfInteger& ElementsOfDomain() const
+  {
+    return myElementsOfDomain;
+  }
+
+  //! Substitutes the element with the given index by new one.
+  //! \param theIndex index of element to be substituted.
+  //! \param theNewLink substituting element.
+  //! \return FALSE in case if new element is already in the structure, TRUE elsewhere.
+  Standard_EXPORT Standard_Boolean SubstituteElement(const Standard_Integer   theIndex,
+                                                     const BRepMesh_Triangle& theNewElement);
+
+  //! Removes element from the mesh.
+  //! \param theIndex index of element to be removed.
+  Standard_EXPORT void RemoveElement(const Standard_Integer theIndex);
+
+  //! Returns indices of nodes forming the given element.
+  //! \param theElement element which nodes should be retrieved.
+  //! \param[out] theNodes nodes of the given element.
+  Standard_EXPORT void ElementNodes(
+    const BRepMesh_Triangle& theElement,
+    Standard_Integer         (&theNodes)[3]);
+
+
+
+public: //! \name Auxilary API
+
+  //! Dumps information about this structure.
+  //! \param theStream stream to be used for dump.
+  Standard_EXPORT void Statistics(Standard_OStream& theStream) const;
+  
+  //! Returns memory allocator used by the structure.
+  inline const BRepMeshCol::Allocator& Allocator() const
+  {
+    return myAllocator;
+  }
+
+  //! Gives the data structure for initialization of cell size and tolerance.
+  inline BRepMesh_VertexTool& Data()
+  {
+    return myNodes;
+  }
+
+  //! Removes all elements.
+  Standard_EXPORT void ClearDomain();
+
+  //! Substitutes deleted items by the last one from corresponding map 
+  //! to have only non-deleted elements, links or nodes in the structure.
+  Standard_EXPORT void ClearDeleted()
+  {
+    clearDeletedLinks();
+    clearDeletedNodes();
+  }
+
+  DEFINE_STANDARD_RTTI(BRepMesh_DataStructureOfDelaun)
+
+private: 
+
+  //! Substitutes deleted links by the last one from corresponding map 
+  //! to have only non-deleted links in the structure.
+  Standard_EXPORT void clearDeletedLinks();
+
+  //! Substitutes deleted nodes by the last one from corresponding map 
+  //! to have only non-deleted nodes in the structure.
+  Standard_EXPORT void clearDeletedNodes();
+
+  //! Cleans dependent structures from the given link.
+  //! \param theIndex index of link in the data structure.
+  //! \param theLink reference to the link to avoid double accessing 
+  //! to map of links.
+  void cleanLink(const Standard_Integer theIndex,
+                 const BRepMesh_Edge&   theLink);
+
+  //! Cleans dependent structures from the given element.
+  //! \param theIndex index of element in the data structure.
+  //! \param theElement reference to the element to avoid double accessing 
+  //! to map of elements.
+  void cleanElement(const Standard_Integer   theIndex,
+                    const BRepMesh_Triangle& theElement);
+
+  //! Removes element index from the given pair. Used by cleanElement.
+  //! \param theIndex index of element to be removed.
+  //! \param thePair pair of elements to be cleaned.
+  void removeElementIndex(const Standard_Integer theIndex,
+                          BRepMesh_PairOfIndex&  thePair);
+
+
+private:
+
+  BRepMesh_VertexTool        myNodes;
+  BRepMeshCol::IDMapOfLink   myLinks;
+  BRepMeshCol::ListOfInteger myDelLinks;
+  BRepMeshCol::IMapOfElement myElements;
+  BRepMeshCol::MapOfInteger  myElementsOfDomain;
+  BRepMeshCol::MapOfInteger  myLinksOfDomain;
+  BRepMeshCol::Allocator     myAllocator;
+};
+
+DEFINE_STANDARD_HANDLE(BRepMesh_DataStructureOfDelaun,Standard_Transient)
+
+#endif
similarity index 65%
rename from src/BRepMesh/BRepMesh_ClassifierPtr.hxx
rename to src/BRepMesh/BRepMesh_DegreeOfFreedom.hxx
index 6d8ec6f..4084459 100644 (file)
@@ -1,6 +1,4 @@
-// Created on: 2009-02-02
-// Created by: Pavel TELKOV
-// Copyright (c) 2009-2014 OPEN CASCADE SAS
+// Copyright (c) 2013 OPEN CASCADE SAS
 //
 // This file is part of Open CASCADE Technology software library.
 //
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
-#ifndef BRepMesh_ClassifierPtr_HeaderFile
-#define BRepMesh_ClassifierPtr_HeaderFile
 
-#include <NCollection_Handle.hxx>
+#ifndef _BRepMesh_DegreeOfFreedom_HeaderFile
+#define _BRepMesh_DegreeOfFreedom_HeaderFile
 
-class BRepMesh_Classifier;
-typedef NCollection_Handle<BRepMesh_Classifier> BRepMesh_ClassifierPtr;
+enum BRepMesh_DegreeOfFreedom
+{
+  BRepMesh_Free,
+  BRepMesh_InVolume,
+  BRepMesh_OnSurface,
+  BRepMesh_OnCurve,
+  BRepMesh_Fixed,
+  BRepMesh_Frontier,
+  BRepMesh_Deleted
+};
 
 #endif
index a536814..aa628f9 100644 (file)
 #include <Bnd_Box2d.hxx>
 #include <Bnd_B2d.hxx>
 
-#include <TColStd_MapOfInteger.hxx>
-#include <TColStd_MapIteratorOfMapOfInteger.hxx>
-#include <TColStd_Array1OfBoolean.hxx>
-#include <TColStd_ListIteratorOfListOfInteger.hxx>
-#include <TColStd_ListOfInteger.hxx>
-#include <TColStd_Array1OfReal.hxx>
-#include <TColStd_Array1OfInteger.hxx>
-#include <TColStd_SequenceOfInteger.hxx>
-
-#include <BRepMesh_MapOfIntegerInteger.hxx>
-#include <BRepMesh_HeapSortIndexedVertexOfDelaun.hxx>
-#include <BRepMesh_ComparatorOfIndexedVertexOfDelaun.hxx>
-#include <BRepMesh_HeapSortIndexedVertexOfDelaun.hxx>
 #include <BRepMesh_SelectorOfDataStructureOfDelaun.hxx>
-#include <BRepMesh_HeapSortVertexOfDelaun.hxx>
-#include <BRepMesh_ComparatorOfVertexOfDelaun.hxx>
-#include <BRepMesh_Array1OfVertexOfDelaun.hxx>
 
 #include <BRepMesh_Edge.hxx>
 #include <BRepMesh_Vertex.hxx>
 
 #include <NCollection_Vector.hxx>
 
-typedef TColStd_ListIteratorOfListOfInteger  IteratorOnListOfInteger;
-typedef TColStd_ListOfInteger                ListOfInteger;
+#include <algorithm>
 
 const Standard_Real AngDeviation1Deg  = M_PI/180.;
 const Standard_Real AngDeviation90Deg = 90 * AngDeviation1Deg;
 const Standard_Real Angle2PI          = 2 * M_PI;
 
-const Standard_Real Precision  = Precision::PConfusion();
-const Standard_Real Precision2 = Precision * Precision;
-const gp_XY SortingDirection(M_SQRT1_2, M_SQRT1_2);
+const Standard_Real Precision    = Precision::PConfusion();
+const Standard_Real Precision2   = Precision * Precision;
+
+namespace {
+  //! Sort two points in projection on vector (1,1)
+  struct ComparatorOfVertexOfDelaun 
+  {
+    bool operator() (const BRepMesh_Vertex& theLeft, const BRepMesh_Vertex& theRight)
+    {
+      return theLeft.Coord().X() + theLeft.Coord().Y() < theRight.Coord().X() + theRight.Coord().Y();
+    }
+  };
+
+  //! Sort two points in projection on vector (1,1)
+  struct ComparatorOfIndexedVertexOfDelaun
+  {
+  public:
+    ComparatorOfIndexedVertexOfDelaun (const Handle(BRepMesh_DataStructureOfDelaun)& theDS)
+      : myStructure(theDS) {}
+  
+    bool operator() (Standard_Integer theLeft, Standard_Integer theRight)
+    {
+      const BRepMesh_Vertex& aLeft  = myStructure->GetNode(theLeft);
+      const BRepMesh_Vertex& aRight = myStructure->GetNode(theRight);
+      return ComparatorOfVertexOfDelaun() (aLeft, aRight);
+    }
+
+  private:
+    Handle(BRepMesh_DataStructureOfDelaun) myStructure;
+  };
+} // anonymous namespace
 
 //=======================================================================
 //function : BRepMesh_Delaun
 //purpose  : Creates the triangulation with an empty Mesh data structure
 //=======================================================================
-BRepMesh_Delaun::BRepMesh_Delaun( BRepMesh_Array1OfVertexOfDelaun& theVertices,
-                                  const Standard_Boolean           isPositive )
+BRepMesh_Delaun::BRepMesh_Delaun( BRepMeshCol::Array1OfVertexOfDelaun& theVertices,
+                                  const Standard_Boolean               isPositive )
 : myIsPositiveOrientation( isPositive ),
   myCircles( theVertices.Length(), new NCollection_IncAllocator() )
 {
@@ -82,7 +93,7 @@ BRepMesh_Delaun::BRepMesh_Delaun( BRepMesh_Array1OfVertexOfDelaun& theVertices,
 //purpose  : Creates the triangulation with and existent Mesh data structure
 //=======================================================================
 BRepMesh_Delaun::BRepMesh_Delaun( const Handle( BRepMesh_DataStructureOfDelaun )& theOldMesh,
-                                  BRepMesh_Array1OfVertexOfDelaun&                theVertices,
+                                  BRepMeshCol::Array1OfVertexOfDelaun&            theVertices,
                                   const Standard_Boolean                          isPositive )
  : myIsPositiveOrientation( isPositive ),
    myCircles( theVertices.Length(), theOldMesh->Allocator() )
@@ -97,7 +108,7 @@ BRepMesh_Delaun::BRepMesh_Delaun( const Handle( BRepMesh_DataStructureOfDelaun )
 //purpose  : Creates the triangulation with and existent Mesh data structure
 //=======================================================================
 BRepMesh_Delaun::BRepMesh_Delaun( const Handle( BRepMesh_DataStructureOfDelaun )& theOldMesh, 
-                                  TColStd_Array1OfInteger&                        theVertexIndices,
+                                  BRepMeshCol::Array1OfInteger&                   theVertexIndices,
                                   const Standard_Boolean                          isPositive )
  : myIsPositiveOrientation( isPositive ),
    myCircles( theVertexIndices.Length(), theOldMesh->Allocator() )
@@ -119,12 +130,12 @@ BRepMesh_Delaun::BRepMesh_Delaun( const Handle( BRepMesh_DataStructureOfDelaun )
 //function : Init
 //purpose  : Initializes the triangulation with an Array of Vertex
 //=======================================================================
-void BRepMesh_Delaun::Init( BRepMesh_Array1OfVertexOfDelaun& theVertices )
+void BRepMesh_Delaun::Init( BRepMeshCol::Array1OfVertexOfDelaun& theVertices )
 {
   Bnd_Box2d aBox;
   Standard_Integer aLowerIdx  = theVertices.Lower();
   Standard_Integer anUpperIdx = theVertices.Upper();
-  TColStd_Array1OfInteger aVertexIndexes( aLowerIdx, anUpperIdx );
+  BRepMeshCol::Array1OfInteger aVertexIndexes( aLowerIdx, anUpperIdx );
   
   Standard_Integer anIndex = aLowerIdx;
   for ( ; anIndex <= anUpperIdx; ++anIndex )
@@ -140,15 +151,15 @@ void BRepMesh_Delaun::Init( BRepMesh_Array1OfVertexOfDelaun& theVertices )
 //function : perform
 //purpose  : Create super mesh and run triangulation procedure
 //=======================================================================
-void BRepMesh_Delaun::perform( Bnd_Box2d&               theBndBox,
-                               TColStd_Array1OfInteger& theVertexIndexes )
+void BRepMesh_Delaun::perform( Bnd_Box2d&                    theBndBox,
+                               BRepMeshCol::Array1OfInteger& theVertexIndexes )
 {
   theBndBox.Enlarge( Precision );
   superMesh( theBndBox );
 
-  BRepMesh_HeapSortIndexedVertexOfDelaun::Sort( theVertexIndexes, 
-      BRepMesh_ComparatorOfIndexedVertexOfDelaun( SortingDirection,
-        Precision, myMeshData ) );
+  ComparatorOfIndexedVertexOfDelaun aCmp(myMeshData);
+  std::make_heap(theVertexIndexes.begin(), theVertexIndexes.end(), aCmp);
+  std::sort_heap(theVertexIndexes.begin(), theVertexIndexes.end(), aCmp);
 
   compute( theVertexIndexes );
 }
@@ -196,20 +207,20 @@ void BRepMesh_Delaun::superMesh( const Bnd_Box2d& theBox )
     mySupVert[2] = aTmp;
   }
 
-  Standard_Integer anEdgeId[3];
-  
+  Standard_Integer e[3];
+  Standard_Boolean o[3];
   for (Standard_Integer aNodeId = 0; aNodeId < 3; ++aNodeId)
   {
     Standard_Integer aFirstNode = aNodeId;
     Standard_Integer aLastNode  = (aNodeId + 1) % 3;
-    anEdgeId[aNodeId] = myMeshData->AddLink( BRepMesh_Edge( 
+    Standard_Integer aLinkIndex = myMeshData->AddLink( BRepMesh_Edge( 
       mySupVert[aFirstNode], mySupVert[aLastNode], BRepMesh_Free ) );
+
+    e[aNodeId] = Abs(aLinkIndex);
+    o[aNodeId] = (aLinkIndex > 0);
   }
   
-  mySupTrian = BRepMesh_Triangle( 
-    Abs( anEdgeId[0] ),  Abs( anEdgeId[1] ),  Abs( anEdgeId[2] ), 
-    ( anEdgeId[0] > 0 ), ( anEdgeId[1] > 0 ), ( anEdgeId[2] > 0),
-    BRepMesh_Free);
+  mySupTrian = BRepMesh_Triangle(e, o, BRepMesh_Free);
 }
 
 //=======================================================================
@@ -218,15 +229,14 @@ void BRepMesh_Delaun::superMesh( const Bnd_Box2d& theBox )
 //           edges into the map.
 //           When an edge is suppressed more than one time it is destroyed.
 //=======================================================================
-void  BRepMesh_Delaun::deleteTriangle( const Standard_Integer        theIndex, 
-                                       BRepMesh_MapOfIntegerInteger& theLoopEdges )
+void BRepMesh_Delaun::deleteTriangle( const Standard_Integer        theIndex, 
+                                      BRepMeshCol::MapOfIntegerInteger& theLoopEdges )
 {
   myCircles.Delete( theIndex );
 
   Standard_Integer e[3];
   Standard_Boolean o[3];
-  GetTriangle( theIndex ).Edges( e[0], e[1], e[2],
-                                 o[0], o[1], o[2] );
+  GetTriangle( theIndex ).Edges( e, o );
   
   myMeshData->RemoveElement( theIndex );
 
@@ -245,14 +255,13 @@ void  BRepMesh_Delaun::deleteTriangle( const Standard_Integer        theIndex,
 //purpose  : Computes the triangulation and add the vertices edges and 
 //           triangles to the Mesh data structure
 //=======================================================================
-void BRepMesh_Delaun::compute( TColStd_Array1OfInteger& theVertexIndexes )
+void BRepMesh_Delaun::compute( BRepMeshCol::Array1OfInteger& theVertexIndexes )
 {
   // Insertion of edges of super triangles in the list of free edges: 
-  BRepMesh_MapOfIntegerInteger aLoopEdges( 10, myMeshData->Allocator() );
+  BRepMeshCol::MapOfIntegerInteger aLoopEdges( 10, myMeshData->Allocator() );
   Standard_Integer e[3];
   Standard_Boolean o[3];
-  mySupTrian.Edges( e[0], e[1], e[2],
-                    o[0], o[1], o[2] );
+  mySupTrian.Edges( e, o );
                     
   aLoopEdges.Bind( e[0], Standard_True );
   aLoopEdges.Bind( e[1], Standard_True );
@@ -274,16 +283,16 @@ void BRepMesh_Delaun::compute( TColStd_Array1OfInteger& theVertexIndexes )
     aSelector.NeighboursOfNode( mySupVert[aSupVertId] );
   
   aLoopEdges.Clear();
-  BRepMesh_MapOfInteger::Iterator aFreeTriangles( aSelector.Elements() );
+  BRepMeshCol::MapOfInteger::Iterator aFreeTriangles( aSelector.Elements() );
   for ( ; aFreeTriangles.More(); aFreeTriangles.Next() )
     deleteTriangle( aFreeTriangles.Key(), aLoopEdges );
 
   // All edges that remain free are removed from aLoopEdges;
   // only the boundary edges of the triangulation remain there
-  BRepMesh_MapOfIntegerInteger::Iterator aFreeEdges( aLoopEdges );
+  BRepMeshCol::MapOfIntegerInteger::Iterator aFreeEdges( aLoopEdges );
   for ( ; aFreeEdges.More(); aFreeEdges.Next() )
   {
-    if ( myMeshData->ElemConnectedTo( aFreeEdges.Key() ).IsEmpty() )
+    if ( myMeshData->ElementsConnectedTo( aFreeEdges.Key() ).IsEmpty() )
       myMeshData->RemoveLink( aFreeEdges.Key() );
   }
 
@@ -296,13 +305,13 @@ void BRepMesh_Delaun::compute( TColStd_Array1OfInteger& theVertexIndexes )
 //function : createTriangles
 //purpose  : Creates the triangles beetween the node and the polyline.
 //=======================================================================
-void BRepMesh_Delaun::createTriangles ( const Standard_Integer        theVertexIndex,  
-                                        BRepMesh_MapOfIntegerInteger& thePoly )
+void BRepMesh_Delaun::createTriangles ( const Standard_Integer            theVertexIndex,  
+                                        BRepMeshCol::MapOfIntegerInteger& thePoly )
 {
-  ListOfInteger aLoopEdges, anExternalEdges;
+  BRepMeshCol::ListOfInteger aLoopEdges, anExternalEdges;
   const gp_XY& aVertexCoord = myMeshData->GetNode( theVertexIndex ).Coord();
   
-  BRepMesh_MapOfIntegerInteger::Iterator anEdges( thePoly );
+  BRepMeshCol::MapOfIntegerInteger::Iterator anEdges( thePoly );
   for ( ; anEdges.More(); anEdges.Next() )
   {
     Standard_Integer     anEdgeId = anEdges.Key();
@@ -391,7 +400,7 @@ void BRepMesh_Delaun::createTriangles ( const Standard_Integer        theVertexI
   while ( !anExternalEdges.IsEmpty() )
   {
     const BRepMesh_PairOfIndex& aPair = 
-      myMeshData->ElemConnectedTo( Abs( anExternalEdges.First() ) );
+      myMeshData->ElementsConnectedTo( Abs( anExternalEdges.First() ) );
     
     
     if ( !aPair.IsEmpty() )
@@ -402,7 +411,7 @@ void BRepMesh_Delaun::createTriangles ( const Standard_Integer        theVertexI
 
   for ( anEdges.Initialize( thePoly ); anEdges.More(); anEdges.Next() )
   {
-    if ( myMeshData->ElemConnectedTo( anEdges.Key() ).IsEmpty() )
+    if ( myMeshData->ElementsConnectedTo( anEdges.Key() ).IsEmpty() )
       myMeshData->RemoveLink( anEdges.Key() );
   }
 
@@ -423,9 +432,9 @@ void BRepMesh_Delaun::createTriangles ( const Standard_Integer        theVertexI
 //function : createTrianglesOnNewVertices
 //purpose  : Creation of triangles from the new nodes
 //=======================================================================
-void BRepMesh_Delaun::createTrianglesOnNewVertices( TColStd_Array1OfInteger& theVertexIndexes )
+void BRepMesh_Delaun::createTrianglesOnNewVertices( BRepMeshCol::Array1OfInteger& theVertexIndexes )
 {
-  BRepMesh_MapOfIntegerInteger aLoopEdges( 10, myMeshData->Allocator() );
+  BRepMeshCol::MapOfIntegerInteger aLoopEdges( 10, myMeshData->Allocator() );
 
   // Insertion of nodes :
   Standard_Boolean isModify = Standard_True;
@@ -440,10 +449,10 @@ void BRepMesh_Delaun::createTrianglesOnNewVertices( TColStd_Array1OfInteger& the
     const BRepMesh_Vertex& aVertex = GetVertex( aVertexIdx );
 
     // Iterator in the list of indexes of circles containing the node
-    BRepMesh_ListOfInteger& aCirclesList = myCircles.Select( aVertex.Coord() );
+    BRepMeshCol::ListOfInteger& aCirclesList = myCircles.Select( aVertex.Coord() );
     
     Standard_Integer onEgdeId = 0, aTriangleId = 0;
-    BRepMesh_ListOfInteger::Iterator aCircleIt( aCirclesList );
+    BRepMeshCol::ListOfInteger::Iterator aCircleIt( aCirclesList );
     for ( ; aCircleIt.More(); aCircleIt.Next() )
     {
       // To add a node in the mesh it is necessary to check conditions: 
@@ -474,13 +483,12 @@ void BRepMesh_Delaun::createTrianglesOnNewVertices( TColStd_Array1OfInteger& the
       while ( isModify && !aCirclesList.IsEmpty() )
       {
         isModify = Standard_False;
-        BRepMesh_ListOfInteger::Iterator aCircleIt1( aCirclesList );
+        BRepMeshCol::ListOfInteger::Iterator aCircleIt1( aCirclesList );
         for ( ; aCircleIt1.More(); aCircleIt1.Next() )
         {
           Standard_Integer e[3];
           Standard_Boolean o[3];
-          GetTriangle( aCircleIt1.Value() ).Edges( e[0], e[1], e[2],
-                                                   o[0], o[1], o[2] );
+          GetTriangle( aCircleIt1.Value() ).Edges( e, o );
                                                    
           if ( aLoopEdges.IsBound( e[0] ) || 
                aLoopEdges.IsBound( e[1] ) || 
@@ -500,15 +508,15 @@ void BRepMesh_Delaun::createTrianglesOnNewVertices( TColStd_Array1OfInteger& the
     }
   }
   // Check that internal edges are not crossed by triangles
-  Handle(BRepMesh_MapOfInteger) anInternalEdges = InternalEdges();
+  BRepMeshCol::HMapOfInteger anInternalEdges = InternalEdges();
 
   // Destruction of triancles intersecting internal edges 
   // and their replacement by makeshift triangles
-  BRepMesh_MapOfInteger::Iterator anInernalEdgesIt( *anInternalEdges );
+  BRepMeshCol::MapOfInteger::Iterator anInernalEdgesIt( *anInternalEdges );
   for ( ; anInernalEdgesIt.More(); anInernalEdgesIt.Next() )
   {
     Standard_Integer aNbC;
-    aNbC = myMeshData->ElemConnectedTo( anInernalEdgesIt.Key() ).Extent();
+    aNbC = myMeshData->ElementsConnectedTo( anInernalEdgesIt.Key() ).Extent();
     if ( aNbC == 0 )
     {
       meshLeftPolygonOf( anInernalEdgesIt.Key(), Standard_True  ); 
@@ -535,7 +543,7 @@ Standard_Boolean BRepMesh_Delaun::isBoundToFrontier(
   const Standard_Integer thePrevElementId)
 {
   const BRepMesh_PairOfIndex& aPair = 
-    myMeshData->ElemConnectedTo( theRefLinkId );
+    myMeshData->ElementsConnectedTo( theRefLinkId );
   if ( aPair.IsEmpty() )
     return Standard_False;
 
@@ -548,8 +556,7 @@ Standard_Boolean BRepMesh_Delaun::isBoundToFrontier(
 
     Standard_Integer anEdges[3];
     Standard_Boolean anEdgesOri[3];
-    GetTriangle( aTriId ).Edges( anEdges[0], anEdges[1], anEdges[2],
-      anEdgesOri[0], anEdgesOri[1], anEdgesOri[2] );
+    GetTriangle( aTriId ).Edges( anEdges, anEdgesOri );
 
     for ( Standard_Integer anEdgeIt = 0; anEdgeIt < 3; ++anEdgeIt )
     {
@@ -585,11 +592,11 @@ void BRepMesh_Delaun::cleanupMesh()
 {
   for(;;)
   {
-    BRepMesh_MapOfIntegerInteger aLoopEdges( 10, myMeshData->Allocator() );
-    NCollection_Map<Standard_Integer> aDelTriangles;
+    BRepMeshCol::MapOfIntegerInteger aLoopEdges( 10, myMeshData->Allocator() );
+    BRepMeshCol::MapOfInteger aDelTriangles;
 
-    Handle(BRepMesh_MapOfInteger) aFreeEdges = FreeEdges();
-    BRepMesh_MapOfInteger::Iterator aFreeEdgesIt( *aFreeEdges );
+    BRepMeshCol::HMapOfInteger aFreeEdges = FreeEdges();
+    BRepMeshCol::MapOfInteger::Iterator aFreeEdgesIt( *aFreeEdges );
     for ( ; aFreeEdgesIt.More(); aFreeEdgesIt.Next() )
     {
       const Standard_Integer& aFreeEdgeId = aFreeEdgesIt.Key();
@@ -598,7 +605,7 @@ void BRepMesh_Delaun::cleanupMesh()
         continue;
 
       const BRepMesh_PairOfIndex& aPair = 
-        myMeshData->ElemConnectedTo( aFreeEdgeId );
+        myMeshData->ElementsConnectedTo( aFreeEdgeId );
       if ( aPair.IsEmpty() )
       {
         aLoopEdges.Bind( aFreeEdgeId, Standard_True );
@@ -610,8 +617,7 @@ void BRepMesh_Delaun::cleanupMesh()
       // Check that the connected triangle is not surrounded by another triangles
       Standard_Integer anEdges[3];
       Standard_Boolean anEdgesOri[3];
-      GetTriangle( aTriId ).Edges( anEdges[0], anEdges[1], anEdges[2],
-        anEdgesOri[0], anEdgesOri[1], anEdgesOri[2] );
+      GetTriangle( aTriId ).Edges( anEdges, anEdgesOri );
 
       Standard_Boolean isCanNotBeRemoved = Standard_True;
       for ( Standard_Integer aCurEdgeIdx = 0; aCurEdgeIdx < 3; ++aCurEdgeIdx )
@@ -623,7 +629,7 @@ void BRepMesh_Delaun::cleanupMesh()
         {
           Standard_Integer anOtherEdgeId = ( aCurEdgeIdx + anOtherEdgeIt ) % 3;
           const BRepMesh_PairOfIndex& anOtherEdgePair = 
-            myMeshData->ElemConnectedTo( anEdges[anOtherEdgeId] );
+            myMeshData->ElementsConnectedTo( anEdges[anOtherEdgeId] );
 
           if ( anOtherEdgePair.Extent() < 2 )
           {
@@ -652,7 +658,7 @@ void BRepMesh_Delaun::cleanupMesh()
 
     // Destruction of triangles :
     Standard_Integer aDeletedTrianglesNb = 0;
-    NCollection_Map<Standard_Integer>::Iterator aDelTrianglesIt( aDelTriangles );
+    BRepMeshCol::MapOfInteger::Iterator aDelTrianglesIt( aDelTriangles );
     for ( ; aDelTrianglesIt.More(); aDelTrianglesIt.Next() )
     {
       deleteTriangle( aDelTrianglesIt.Key(), aLoopEdges );
@@ -660,10 +666,10 @@ void BRepMesh_Delaun::cleanupMesh()
     }
 
     // Destruction of remaining hanging edges
-    BRepMesh_MapOfIntegerInteger::Iterator aLoopEdgesIt( aLoopEdges );
+    BRepMeshCol::MapOfIntegerInteger::Iterator aLoopEdgesIt( aLoopEdges );
     for ( ; aLoopEdgesIt.More(); aLoopEdgesIt.Next() )
     {
-      if ( myMeshData->ElemConnectedTo( aLoopEdgesIt.Key() ).IsEmpty() )
+      if ( myMeshData->ElementsConnectedTo( aLoopEdgesIt.Key() ).IsEmpty() )
         myMeshData->RemoveLink( aLoopEdgesIt.Key() );
     }
 
@@ -678,21 +684,21 @@ void BRepMesh_Delaun::cleanupMesh()
 //=======================================================================
 void BRepMesh_Delaun::frontierAdjust()
 {
-  Handle(BRepMesh_MapOfInteger)         aFrontier = Frontier();
-  NCollection_Vector<Standard_Integer>  aFailedFrontiers;
-  BRepMesh_MapOfIntegerInteger          aLoopEdges( 10, myMeshData->Allocator() );
-  BRepMesh_Delaun::HandleOfMapOfInteger aIntFrontierEdges = new NCollection_Map<Standard_Integer>();
+  BRepMeshCol::HMapOfInteger        aFrontier = Frontier();
+  BRepMeshCol::VectorOfInteger      aFailedFrontiers;
+  BRepMeshCol::MapOfIntegerInteger  aLoopEdges( 10, myMeshData->Allocator() );
+  BRepMeshCol::HMapOfInteger        aIntFrontierEdges = new BRepMeshCol::MapOfInteger;
   for ( Standard_Integer aPass = 1; aPass <= 2; ++aPass )
   {      
     // 1 pass): find external triangles on boundary edges;
     // 2 pass): find external triangles on boundary edges appeared 
     //          during triangles replacement.
     
-    BRepMesh_MapOfInteger::Iterator aFrontierIt( *aFrontier );
+    BRepMeshCol::MapOfInteger::Iterator aFrontierIt( *aFrontier );
     for ( ; aFrontierIt.More(); aFrontierIt.Next() )
     {
       Standard_Integer aFrontierId = aFrontierIt.Key();
-      const BRepMesh_PairOfIndex& aPair = myMeshData->ElemConnectedTo( aFrontierId );
+      const BRepMesh_PairOfIndex& aPair = myMeshData->ElementsConnectedTo( aFrontierId );
       Standard_Integer aNbElem = aPair.Extent();
       for( Standard_Integer aElemIt = 1; aElemIt <= aNbElem; ++aElemIt )
       {
@@ -702,8 +708,7 @@ void BRepMesh_Delaun::frontierAdjust()
             
         Standard_Integer e[3];
         Standard_Boolean o[3];
-        GetTriangle( aPriorElemId ).Edges( e[0], e[1], e[2],
-                                           o[0], o[1], o[2] );
+        GetTriangle( aPriorElemId ).Edges( e, o );
 
         Standard_Boolean isTriangleFound = Standard_False;
         for ( Standard_Integer n = 0; n < 3; ++n )
@@ -723,11 +728,11 @@ void BRepMesh_Delaun::frontierAdjust()
     }
 
     // destrucrion of remaining hanging edges :
-    BRepMesh_MapOfIntegerInteger::Iterator aLoopEdgesIt( aLoopEdges );
+    BRepMeshCol::MapOfIntegerInteger::Iterator aLoopEdgesIt( aLoopEdges );
     for ( ; aLoopEdgesIt.More(); aLoopEdgesIt.Next() )
     {
       Standard_Integer aLoopEdgeId = aLoopEdgesIt.Key();
-      if (myMeshData->ElemConnectedTo( aLoopEdgeId ).IsEmpty() )
+      if (myMeshData->ElementsConnectedTo( aLoopEdgeId ).IsEmpty() )
         myMeshData->RemoveLink( aLoopEdgeId );
     }
 
@@ -736,7 +741,7 @@ void BRepMesh_Delaun::frontierAdjust()
     for ( aFrontierIt.Reset(); aFrontierIt.More(); aFrontierIt.Next() )
     {
       Standard_Integer aFrontierId = aFrontierIt.Key();
-      if ( !myMeshData->ElemConnectedTo( aFrontierId ).IsEmpty() )
+      if ( !myMeshData->ElementsConnectedTo( aFrontierId ).IsEmpty() )
         continue;
 
       Standard_Boolean isSuccess = 
@@ -754,11 +759,11 @@ void BRepMesh_Delaun::frontierAdjust()
   // situation when frontier edge has a triangle at a right side, but its free 
   // links cross another frontieres  and meshLeftPolygonOf itself can't collect 
   // a closed polygon.
-  NCollection_Vector<Standard_Integer>::Iterator aFailedFrontiersIt( aFailedFrontiers );
+  BRepMeshCol::VectorOfInteger::Iterator aFailedFrontiersIt( aFailedFrontiers );
   for ( ; aFailedFrontiersIt.More(); aFailedFrontiersIt.Next() )
   {
     Standard_Integer aFrontierId = aFailedFrontiersIt.Value();
-    if ( !myMeshData->ElemConnectedTo( aFrontierId ).IsEmpty() )
+    if ( !myMeshData->ElementsConnectedTo( aFrontierId ).IsEmpty() )
       continue;
 
     meshLeftPolygonOf( aFrontierId, Standard_True, aIntFrontierEdges );
@@ -770,7 +775,7 @@ void BRepMesh_Delaun::frontierAdjust()
 //purpose  : Add boundig box for edge defined by start & end point to
 //           the given vector of bounding boxes for triangulation edges
 //=======================================================================
-void BRepMesh_Delaun::fillBndBox( NCollection_Sequence<Bnd_B2d>& theBoxes,
+void BRepMesh_Delaun::fillBndBox( BRepMeshCol::SequenceOfBndB2d& theBoxes,
                                   const BRepMesh_Vertex&         theV1,
                                   const BRepMesh_Vertex&         theV2 )
 {
@@ -787,14 +792,14 @@ void BRepMesh_Delaun::fillBndBox( NCollection_Sequence<Bnd_B2d>& theBoxes,
 Standard_Boolean BRepMesh_Delaun::meshLeftPolygonOf( 
   const Standard_Integer                theStartEdgeId,
   const Standard_Boolean                isForward,
-  BRepMesh_Delaun::HandleOfMapOfInteger theSkipped )
+  BRepMeshCol::HMapOfInteger            theSkipped )
 {
   if ( !theSkipped.IsNull() && theSkipped->Contains( theStartEdgeId ) )
     return Standard_True;
 
   const BRepMesh_Edge& aRefEdge = GetEdge( theStartEdgeId );
 
-  TColStd_SequenceOfInteger aPolygon;
+  BRepMeshCol::SequenceOfInteger aPolygon;
   Standard_Integer aStartNode, aPivotNode;
   if ( isForward )
   {
@@ -822,14 +827,14 @@ Standard_Boolean BRepMesh_Delaun::meshLeftPolygonOf(
   // Auxilary structures.
   // Bounding boxes of polygon links to be used for preliminary
   // analysis of intersections
-  NCollection_Sequence<Bnd_B2d> aBoxes;
+  BRepMeshCol::SequenceOfBndB2d aBoxes;
   fillBndBox( aBoxes, aStartEdgeVertexS, aPivotVertex );
 
   // Hanging ends
-  NCollection_Map<Standard_Integer> aDeadLinks;
+  BRepMeshCol::MapOfInteger aDeadLinks;
 
   // Links are temporarily excluded from consideration
-  NCollection_Map<Standard_Integer> aLeprousLinks;
+  BRepMeshCol::MapOfInteger aLeprousLinks;
   aLeprousLinks.Add( theStartEdgeId );
 
   Standard_Boolean isSkipLeprous = Standard_True;
@@ -918,12 +923,12 @@ Standard_Integer BRepMesh_Delaun::findNextPolygonLink(
   const Standard_Integer&                     thePivotNode,
   const BRepMesh_Vertex&                      thePivotVertex,
   const gp_Vec2d&                             theRefLinkDir,
-  const NCollection_Sequence<Bnd_B2d>&        theBoxes,
-  const TColStd_SequenceOfInteger&            thePolygon,
-  const BRepMesh_Delaun::HandleOfMapOfInteger theSkipped,
+  const BRepMeshCol::SequenceOfBndB2d&        theBoxes,
+  const BRepMeshCol::SequenceOfInteger&       thePolygon,
+  const BRepMeshCol::HMapOfInteger            theSkipped,
   const Standard_Boolean&                     isSkipLeprous,
-  NCollection_Map<Standard_Integer>&          theLeprousLinks,
-  NCollection_Map<Standard_Integer>&          theDeadLinks,
+  BRepMeshCol::MapOfInteger&                  theLeprousLinks,
+  BRepMeshCol::MapOfInteger&                  theDeadLinks,
   Standard_Integer&                           theNextPivotNode,
   gp_Vec2d&                                   theNextLinkDir,
   Bnd_B2d&                                    theNextLinkBndBox )
@@ -934,7 +939,7 @@ Standard_Integer BRepMesh_Delaun::findNextPolygonLink(
     RealFirst() : RealLast();
 
   Standard_Integer aNextLinkId = 0;
-  BRepMesh_ListOfInteger::Iterator aLinkIt( myMeshData->LinkNeighboursOf( thePivotNode ) );
+  BRepMeshCol::ListOfInteger::Iterator aLinkIt( myMeshData->LinksConnectedTo( thePivotNode ) );
   for ( ; aLinkIt.More(); aLinkIt.Next() )
   {
     const Standard_Integer& aNeighbourLinkInfo = aLinkIt.Value();
@@ -954,7 +959,7 @@ Standard_Integer BRepMesh_Delaun::findNextPolygonLink(
 
     // Determine whether the link belongs to the mesh
     if ( aNeighbourLink.Movability() == BRepMesh_Free &&
-         myMeshData->ElemConnectedTo( aNeighbourLinkInfo ).IsEmpty() )
+         myMeshData->ElementsConnectedTo( aNeighbourLinkInfo ).IsEmpty() )
     {
       theDeadLinks.Add( aNeighbourLinkId );
       continue;
@@ -1027,13 +1032,13 @@ Standard_Integer BRepMesh_Delaun::findNextPolygonLink(
 //           <theLinkBndBox> parameter.
 //=======================================================================
 Standard_Boolean BRepMesh_Delaun::checkIntersection( 
-  const BRepMesh_Edge&                 theLink,
-  const TColStd_SequenceOfInteger&     thePolygon,
-  const NCollection_Sequence<Bnd_B2d>& thePolyBoxes,
-  const Standard_Boolean               isConsiderEndPointTouch,
-  const Standard_Boolean               isConsiderPointOnEdge,
-  const Standard_Boolean               isSkipLastEdge,
-  Bnd_B2d&                             theLinkBndBox ) const
+  const BRepMesh_Edge&                  theLink,
+  const BRepMeshCol::SequenceOfInteger& thePolygon,
+  const BRepMeshCol::SequenceOfBndB2d&  thePolyBoxes,
+  const Standard_Boolean                isConsiderEndPointTouch,
+  const Standard_Boolean                isConsiderPointOnEdge,
+  const Standard_Boolean                isSkipLastEdge,
+  Bnd_B2d&                              theLinkBndBox ) const
 {
   theLinkBndBox.Add( GetVertex( theLink.FirstNode() ).Coord() );
   theLinkBndBox.Add( GetVertex( theLink.LastNode()  ).Coord() );
@@ -1059,11 +1064,10 @@ Standard_Boolean BRepMesh_Delaun::checkIntersection(
         continue;
 
       gp_Pnt2d anIntPnt;
-      BRepMesh_WireInterferenceChecker::IntFlag aIntFlag = 
-        intSegSeg( theLink, aPolyLink, isConsiderEndPointTouch, 
-        isConsiderPointOnEdge, anIntPnt );
+      BRepMesh_GeomTool::IntFlag aIntFlag = intSegSeg( theLink, aPolyLink, 
+        isConsiderEndPointTouch, isConsiderPointOnEdge, anIntPnt );
 
-      if ( aIntFlag != BRepMesh_WireInterferenceChecker::NoIntersection )
+      if ( aIntFlag != BRepMesh_GeomTool::NoIntersection )
         return Standard_False;
     }
   }
@@ -1081,16 +1085,14 @@ inline void BRepMesh_Delaun::addTriangle( const Standard_Integer (&theEdgesId)[3
                                           const Standard_Integer (&theNodesId)[3] )
 {
   Standard_Integer aNewTriangleId = 
-    myMeshData->AddElement( BRepMesh_Triangle( 
-      theEdgesId[0],  theEdgesId[1],  theEdgesId[2], 
-      theEdgesOri[0], theEdgesOri[1], theEdgesOri[2],
-      BRepMesh_Free ) );
+    myMeshData->AddElement(BRepMesh_Triangle(theEdgesId, 
+      theEdgesOri, BRepMesh_Free));
 
-  Standard_Boolean isAdded = myCircles.Add( 
+  Standard_Boolean isAdded = myCircles.Bind( 
+    aNewTriangleId,
     GetVertex( theNodesId[0] ).Coord(), 
     GetVertex( theNodesId[1] ).Coord(),
-    GetVertex( theNodesId[2] ).Coord(),
-    aNewTriangleId );
+    GetVertex( theNodesId[2] ).Coord() );
     
   if ( !isAdded )
     myMeshData->RemoveElement( aNewTriangleId );
@@ -1100,17 +1102,17 @@ inline void BRepMesh_Delaun::addTriangle( const Standard_Integer (&theEdgesId)[3
 //function : cleanupPolygon
 //purpose  : Remove internal triangles from the given polygon
 //=======================================================================
-void BRepMesh_Delaun::cleanupPolygon( const TColStd_SequenceOfInteger&     thePolygon,
-                                      const NCollection_Sequence<Bnd_B2d>& thePolyBoxes )
+void BRepMesh_Delaun::cleanupPolygon( const BRepMeshCol::SequenceOfInteger& thePolygon,
+                                      const BRepMeshCol::SequenceOfBndB2d&  thePolyBoxes )
 {
   Standard_Integer aPolyLen = thePolygon.Length();
   if ( aPolyLen < 3 )
     return;
 
-  BRepMesh_MapOfIntegerInteger aLoopEdges( 10, myMeshData->Allocator() );
-  NCollection_Map<Standard_Integer>    anIgnoredEdges;
-  NCollection_Map<Standard_Integer>    aPolyVerticesFindMap;
-  NCollection_Vector<Standard_Integer> aPolyVertices;
+  BRepMeshCol::MapOfIntegerInteger aLoopEdges( 10, myMeshData->Allocator() );
+  BRepMeshCol::MapOfInteger    anIgnoredEdges;
+  BRepMeshCol::MapOfInteger    aPolyVerticesFindMap;
+  BRepMeshCol::VectorOfInteger aPolyVertices;
   // Collect boundary vertices of the polygon
   for ( Standard_Integer aPolyIt = 1; aPolyIt <= aPolyLen; ++aPolyIt )
   {
@@ -1120,7 +1122,7 @@ void BRepMesh_Delaun::cleanupPolygon( const TColStd_SequenceOfInteger&     thePo
 
     Standard_Boolean isForward = ( aPolyEdgeInfo > 0 );
     const BRepMesh_PairOfIndex& aPair = 
-      myMeshData->ElemConnectedTo( aPolyEdgeId );
+      myMeshData->ElementsConnectedTo( aPolyEdgeId );
 
     Standard_Integer anElemIt = 1;
     for ( ; anElemIt <= aPair.Extent(); ++anElemIt )
@@ -1131,8 +1133,7 @@ void BRepMesh_Delaun::cleanupPolygon( const TColStd_SequenceOfInteger&     thePo
 
       Standard_Integer anEdges[3];
       Standard_Boolean anEdgesOri[3];
-      GetTriangle( anElemId ).Edges( anEdges[0], anEdges[1], anEdges[2],
-        anEdgesOri[0], anEdgesOri[1], anEdgesOri[2] );
+      GetTriangle( anElemId ).Edges(anEdges, anEdgesOri);
 
       Standard_Integer isTriangleFound = Standard_False;
       for ( Standard_Integer anEdgeIt = 0; anEdgeIt < 3; ++anEdgeIt )
@@ -1177,7 +1178,7 @@ void BRepMesh_Delaun::cleanupPolygon( const TColStd_SequenceOfInteger&     thePo
   if ( aPolyVertices.First() != aPolyVertices.Last() )
     aPolyVertices.Append( aPolyVertices.First() );
 
-  NCollection_Map<Standard_Integer> aSurvivedLinks( anIgnoredEdges );
+  BRepMeshCol::MapOfInteger aSurvivedLinks( anIgnoredEdges );
 
   Standard_Integer aPolyVertIt          = 0;
   Standard_Integer anUniqueVerticesNum  = aPolyVertices.Length() - 1;
@@ -1188,14 +1189,14 @@ void BRepMesh_Delaun::cleanupPolygon( const TColStd_SequenceOfInteger&     thePo
       thePolyBoxes, aSurvivedLinks, aLoopEdges );
   }
 
-  BRepMesh_MapOfIntegerInteger::Iterator aLoopEdgesIt( aLoopEdges );
+  BRepMeshCol::MapOfIntegerInteger::Iterator aLoopEdgesIt( aLoopEdges );
   for ( ; aLoopEdgesIt.More(); aLoopEdgesIt.Next() )
   {
     const Standard_Integer& aLoopEdgeId = aLoopEdgesIt.Key();
     if ( anIgnoredEdges.Contains( aLoopEdgeId ) )
       continue;
 
-    if ( myMeshData->ElemConnectedTo( aLoopEdgeId ).IsEmpty() )
+    if ( myMeshData->ElementsConnectedTo( aLoopEdgeId ).IsEmpty() )
       myMeshData->RemoveLink( aLoopEdgesIt.Key() );
   }
 }
@@ -1206,19 +1207,19 @@ void BRepMesh_Delaun::cleanupPolygon( const TColStd_SequenceOfInteger&     thePo
 //           inside the polygon or crossed it.
 //=======================================================================
 void BRepMesh_Delaun::killTrianglesAroundVertex( 
-  const Standard_Integer                        theZombieNodeId,
-  const NCollection_Vector<Standard_Integer>&   thePolyVertices,
-  const NCollection_Map<Standard_Integer>&      thePolyVerticesFindMap,
-  const TColStd_SequenceOfInteger&              thePolygon,
-  const NCollection_Sequence<Bnd_B2d>&          thePolyBoxes,
-  NCollection_Map<Standard_Integer>&            theSurvivedLinks,
-  BRepMesh_MapOfIntegerInteger&                 theLoopEdges )
+  const Standard_Integer                theZombieNodeId,
+  const BRepMeshCol::VectorOfInteger&   thePolyVertices,
+  const BRepMeshCol::MapOfInteger&      thePolyVerticesFindMap,
+  const BRepMeshCol::SequenceOfInteger& thePolygon,
+  const BRepMeshCol::SequenceOfBndB2d&  thePolyBoxes,
+  BRepMeshCol::MapOfInteger&            theSurvivedLinks,
+  BRepMeshCol::MapOfIntegerInteger&     theLoopEdges )
 {
-  BRepMesh_ListOfInteger::Iterator aNeighborsIt = 
-      myMeshData->LinkNeighboursOf( theZombieNodeId );
+  BRepMeshCol::ListOfInteger::Iterator aNeighborsIt = 
+    myMeshData->LinksConnectedTo( theZombieNodeId );
 
   // Try to infect neighbor nodes
-  NCollection_Vector<Standard_Integer> aVictimNodes;
+  BRepMeshCol::VectorOfInteger aVictimNodes;
   for ( ; aNeighborsIt.More(); aNeighborsIt.Next() )
   {
     const Standard_Integer& aNeighborLinkId = aNeighborsIt.Value();
@@ -1276,7 +1277,7 @@ void BRepMesh_Delaun::killTrianglesAroundVertex(
   }
 
   // Go and do your job!
-  NCollection_Vector<Standard_Integer>::Iterator aVictimIt( aVictimNodes );
+  BRepMeshCol::VectorOfInteger::Iterator aVictimIt( aVictimNodes );
   for ( ; aVictimIt.More(); aVictimIt.Next() )
   {
     killTrianglesAroundVertex( aVictimIt.Value(), thePolyVertices,
@@ -1290,8 +1291,8 @@ void BRepMesh_Delaun::killTrianglesAroundVertex(
 //purpose  : Checks is the given vertex lies inside the polygon
 //=======================================================================
 Standard_Boolean BRepMesh_Delaun::isVertexInsidePolygon( 
-  const Standard_Integer&                     theVertexId,
-  const NCollection_Vector<Standard_Integer>& thePolygonVertices ) const
+  const Standard_Integer&             theVertexId,
+  const BRepMeshCol::VectorOfInteger& thePolygonVertices ) const
 {
   Standard_Integer aPolyLen = thePolygonVertices.Length();
   if ( aPolyLen < 3 )
@@ -1334,10 +1335,10 @@ void BRepMesh_Delaun::killTrianglesOnIntersectingLinks(
   const Standard_Integer&               theLinkToCheckId, 
   const BRepMesh_Edge&                  theLinkToCheck,
   const Standard_Integer&               theEndPoint,
-  const TColStd_SequenceOfInteger&      thePolygon,
-  const NCollection_Sequence<Bnd_B2d>&  thePolyBoxes,
-  NCollection_Map<Standard_Integer>&    theSurvivedLinks,
-  BRepMesh_MapOfIntegerInteger&         theLoopEdges )
+  const BRepMeshCol::SequenceOfInteger& thePolygon,
+  const BRepMeshCol::SequenceOfBndB2d&  thePolyBoxes,
+  BRepMeshCol::MapOfInteger&            theSurvivedLinks,
+  BRepMeshCol::MapOfIntegerInteger&     theLoopEdges )
 {
   if ( theSurvivedLinks.Contains( theLinkToCheckId ) )
     return;
@@ -1355,8 +1356,8 @@ void BRepMesh_Delaun::killTrianglesOnIntersectingLinks(
 
   killLinkTriangles( theLinkToCheckId, theLoopEdges );
 
-  BRepMesh_ListOfInteger::Iterator aNeighborsIt = 
-    myMeshData->LinkNeighboursOf( theEndPoint );
+  BRepMeshCol::ListOfInteger::Iterator aNeighborsIt = 
+    myMeshData->LinksConnectedTo( theEndPoint );
 
   for ( ; aNeighborsIt.More(); aNeighborsIt.Next() )
   {
@@ -1377,11 +1378,11 @@ void BRepMesh_Delaun::killTrianglesOnIntersectingLinks(
 //purpose  : Kill triangles bound to the given link.
 //=======================================================================
 void BRepMesh_Delaun::killLinkTriangles( 
-  const Standard_Integer&       theLinkId, 
-  BRepMesh_MapOfIntegerInteger& theLoopEdges )
+  const Standard_Integer&           theLinkId, 
+  BRepMeshCol::MapOfIntegerInteger& theLoopEdges )
 {
   const BRepMesh_PairOfIndex& aPair = 
-      myMeshData->ElemConnectedTo( theLinkId );
+    myMeshData->ElementsConnectedTo( theLinkId );
 
   Standard_Integer anElemNb = aPair.Extent();
   for ( Standard_Integer aPairIt = 1; aPairIt <= anElemNb; ++aPairIt )
@@ -1420,17 +1421,17 @@ void BRepMesh_Delaun::getOrientedNodes(const BRepMesh_Edge&   theEdge,
 //purpose  : Processes loop within the given polygon formed by range of 
 //           its links specified by start and end link indices.
 //=======================================================================
-void BRepMesh_Delaun::processLoop(const Standard_Integer               theLinkFrom,
-                                  const Standard_Integer               theLinkTo,
-                                  const TColStd_SequenceOfInteger&     thePolygon,
-                                  const NCollection_Sequence<Bnd_B2d>& thePolyBoxes)
+void BRepMesh_Delaun::processLoop(const Standard_Integer                theLinkFrom,
+                                  const Standard_Integer                theLinkTo,
+                                  const BRepMeshCol::SequenceOfInteger& thePolygon,
+                                  const BRepMeshCol::SequenceOfBndB2d&  thePolyBoxes)
 {
   Standard_Integer aNbOfLinksInLoop = theLinkTo - theLinkFrom - 1;
   if ( aNbOfLinksInLoop < 3 )
     return;
 
-  TColStd_SequenceOfInteger     aPolygon;
-  NCollection_Sequence<Bnd_B2d> aPolyBoxes;
+  BRepMeshCol::SequenceOfInteger aPolygon;
+  BRepMeshCol::SequenceOfBndB2d  aPolyBoxes;
   for ( ; aNbOfLinksInLoop > 0; --aNbOfLinksInLoop )
   {
     Standard_Integer aLoopLinkIndex = theLinkFrom + aNbOfLinksInLoop;
@@ -1446,12 +1447,12 @@ void BRepMesh_Delaun::processLoop(const Standard_Integer               theLinkFr
 //           given polygon.
 //=======================================================================
 Standard_Integer BRepMesh_Delaun::createAndReplacePolygonLink(
-  const Standard_Integer         *theNodes,
-  const gp_Pnt2d                 *thePnts,
-  const Standard_Integer         theRootIndex,
-  const ReplaceFlag              theReplaceFlag,
-  TColStd_SequenceOfInteger&     thePolygon,
-  NCollection_Sequence<Bnd_B2d>& thePolyBoxes )
+  const Standard_Integer          *theNodes,
+  const gp_Pnt2d                  *thePnts,
+  const Standard_Integer          theRootIndex,
+  const ReplaceFlag               theReplaceFlag,
+  BRepMeshCol::SequenceOfInteger& thePolygon,
+  BRepMeshCol::SequenceOfBndB2d&  thePolyBoxes )
 {
   Standard_Integer aNewEdgeId = 
     myMeshData->AddLink( BRepMesh_Edge(
@@ -1486,9 +1487,9 @@ Standard_Integer BRepMesh_Delaun::createAndReplacePolygonLink(
 //function : meshPolygon
 //purpose  : 
 //=======================================================================
-void BRepMesh_Delaun::meshPolygon( TColStd_SequenceOfInteger&            thePolygon,
-                                   NCollection_Sequence<Bnd_B2d>&        thePolyBoxes,
-                                   BRepMesh_Delaun::HandleOfMapOfInteger theSkipped )
+void BRepMesh_Delaun::meshPolygon( BRepMeshCol::SequenceOfInteger& thePolygon,
+                                   BRepMeshCol::SequenceOfBndB2d&  thePolyBoxes,
+                                   BRepMeshCol::HMapOfInteger      theSkipped )
 {
   // Check is the source polygon elementary
   if ( meshElementaryPolygon( thePolygon ) )
@@ -1535,16 +1536,16 @@ void BRepMesh_Delaun::meshPolygon( TColStd_SequenceOfInteger&            thePoly
       };
 
       gp_Pnt2d anIntPnt;
-      BRepMesh_WireInterferenceChecker::IntFlag aIntFlag = intSegSeg( *aCurEdge, 
-        *aNextEdge, Standard_False, Standard_True, anIntPnt );
+      BRepMesh_GeomTool::IntFlag aIntFlag = intSegSeg( *aCurEdge, *aNextEdge, 
+        Standard_False, Standard_True, anIntPnt );
 
-      if ( aIntFlag == BRepMesh_WireInterferenceChecker::NoIntersection )
+      if ( aIntFlag == BRepMesh_GeomTool::NoIntersection )
         continue;
 
       Standard_Boolean isRemoveFromFirst  = Standard_False;
       Standard_Boolean isAddReplacingEdge = Standard_True;
       Standard_Integer aIndexToRemoveTo   = aNextPolyIt;
-      if ( aIntFlag == BRepMesh_WireInterferenceChecker::Cross )
+      if ( aIntFlag == BRepMesh_GeomTool::Cross )
       {
         Standard_Real aLoopArea = polyArea( thePolygon, aPolyIt + 1, aNextPolyIt );
         gp_Vec2d aVec1( anIntPnt, aCurPnts [1] );
@@ -1586,7 +1587,7 @@ void BRepMesh_Delaun::meshPolygon( TColStd_SequenceOfInteger&            thePoly
             theSkipped->Add( Abs( thePolygon( aSkippedLinkIt ) ) );
         }
       }
-      else if ( aIntFlag == BRepMesh_WireInterferenceChecker::PointOnSegment )
+      else if ( aIntFlag == BRepMesh_GeomTool::PointOnSegment )
       {
         // Indentify chopping link 
         Standard_Boolean isFirstChopping = Standard_False;
@@ -1657,7 +1658,7 @@ void BRepMesh_Delaun::meshPolygon( TColStd_SequenceOfInteger&            thePoly
             thePolygon, thePolyBoxes );
         }
       }
-      else if ( aIntFlag == BRepMesh_WireInterferenceChecker::Glued )
+      else if ( aIntFlag == BRepMesh_GeomTool::Glued )
       {
         if ( aCurNodes[1] == aNextNodes[0] )
         {
@@ -1666,7 +1667,7 @@ void BRepMesh_Delaun::meshPolygon( TColStd_SequenceOfInteger&            thePoly
         }
         // TODO: Non-adjacent glued links within the polygon
       }
-      else if ( aIntFlag == BRepMesh_WireInterferenceChecker::Same )
+      else if ( aIntFlag == BRepMesh_GeomTool::Same )
       {
         processLoop( aPolyIt, aNextPolyIt, thePolygon, thePolyBoxes );
 
@@ -1710,7 +1711,7 @@ void BRepMesh_Delaun::meshPolygon( TColStd_SequenceOfInteger&            thePoly
 //purpose  : Triangulation of closed polygon containing only three edges.
 //=======================================================================
 inline Standard_Boolean BRepMesh_Delaun::meshElementaryPolygon( 
-  const TColStd_SequenceOfInteger& thePolygon )
+  const BRepMeshCol::SequenceOfInteger& thePolygon )
 {
   Standard_Integer aPolyLen = thePolygon.Length();
   if ( aPolyLen < 3 )
@@ -1728,7 +1729,7 @@ inline Standard_Boolean BRepMesh_Delaun::meshElementaryPolygon(
     anEdges[anEdgeIt]           = Abs( anEdgeInfo );
     anEdgesOri[anEdgeIt]        = ( anEdgeInfo > 0 );
   }
-    
+  
   const BRepMesh_Edge& anEdge1 = GetEdge( anEdges[0] );
   const BRepMesh_Edge& anEdge2 = GetEdge( anEdges[1] );
   
@@ -1752,8 +1753,8 @@ inline Standard_Boolean BRepMesh_Delaun::meshElementaryPolygon(
 //           its edges in the structure.
 //           (negative index means reversed edge)
 //=======================================================================
-void BRepMesh_Delaun::meshSimplePolygon( TColStd_SequenceOfInteger&     thePolygon,
-                                         NCollection_Sequence<Bnd_B2d>& thePolyBoxes )
+void BRepMesh_Delaun::meshSimplePolygon( BRepMeshCol::SequenceOfInteger& thePolygon,
+                                         BRepMeshCol::SequenceOfBndB2d&  thePolyBoxes )
 {
   // Check is the given polygon elementary
   if ( meshElementaryPolygon( thePolygon ) )
@@ -1843,11 +1844,10 @@ void BRepMesh_Delaun::meshSimplePolygon( TColStd_SequenceOfInteger&     thePolyg
 
           // intersection is possible...                  
           gp_Pnt2d anIntPnt;
-          BRepMesh_WireInterferenceChecker::IntFlag aIntFlag = 
-            intSegSeg( aCheckLink, aPolyLink, Standard_False, 
-            Standard_False, anIntPnt );
+          BRepMesh_GeomTool::IntFlag aIntFlag = intSegSeg( aCheckLink, aPolyLink, 
+            Standard_False, Standard_False, anIntPnt );
 
-          if( aIntFlag != BRepMesh_WireInterferenceChecker::NoIntersection )
+          if( aIntFlag != BRepMesh_GeomTool::NoIntersection )
           {
             isIntersect = Standard_True;
             break;
@@ -1899,11 +1899,11 @@ void BRepMesh_Delaun::meshSimplePolygon( TColStd_SequenceOfInteger&     thePolyg
   // polygon.
   if ( aUsedLinkId < aPolyLen )
   {
-    TColStd_SequenceOfInteger aRightPolygon;
+    BRepMeshCol::SequenceOfInteger aRightPolygon;
     thePolygon.Split( aUsedLinkId, aRightPolygon );
     aRightPolygon.Prepend( -aNewEdgesInfo[2] );
 
-    NCollection_Sequence<Bnd_B2d> aRightPolyBoxes;
+    BRepMeshCol::SequenceOfBndB2d aRightPolyBoxes;
     thePolyBoxes.Split( aUsedLinkId, aRightPolyBoxes );
 
     Bnd_B2d aBox;
@@ -1937,22 +1937,22 @@ void BRepMesh_Delaun::meshSimplePolygon( TColStd_SequenceOfInteger&     thePolyg
 //function : RemoveVertex
 //purpose  : Removes a vertex from the triangulation
 //=======================================================================
-void  BRepMesh_Delaun::RemoveVertex( const BRepMesh_Vertex& theVertex )
+void BRepMesh_Delaun::RemoveVertex( const BRepMesh_Vertex& theVertex )
 {
   BRepMesh_SelectorOfDataStructureOfDelaun aSelector( myMeshData );
   aSelector.NeighboursOf( theVertex );
 
-  BRepMesh_MapOfIntegerInteger aLoopEdges( 10, myMeshData->Allocator() );
+  BRepMeshCol::MapOfIntegerInteger aLoopEdges( 10, myMeshData->Allocator() );
 
   // Loop on triangles to be destroyed :
-  BRepMesh_MapOfInteger::Iterator aTriangleIt( aSelector.Elements() );
+  BRepMeshCol::MapOfInteger::Iterator aTriangleIt( aSelector.Elements() );
   for ( ; aTriangleIt.More(); aTriangleIt.Next() )
     deleteTriangle( aTriangleIt.Key(), aLoopEdges );
 
-  NCollection_Sequence<Bnd_B2d> aBoxes;
-  TColStd_SequenceOfInteger     aPolygon;
+  BRepMeshCol::SequenceOfBndB2d  aBoxes;
+  BRepMeshCol::SequenceOfInteger aPolygon;
   Standard_Integer aLoopEdgesCount = aLoopEdges.Extent();
-  BRepMesh_MapOfIntegerInteger::Iterator aLoopEdgesIt( aLoopEdges );
+  BRepMeshCol::MapOfIntegerInteger::Iterator aLoopEdgesIt( aLoopEdges );
 
   if ( aLoopEdgesIt.More() )
   {
@@ -1982,7 +1982,7 @@ void  BRepMesh_Delaun::RemoveVertex( const BRepMesh_Vertex& theVertex )
     aLastNode = aFirstNode;
     while ( aPivotNode != aLastNode )
     {
-      BRepMesh_ListOfInteger::Iterator aLinkIt( myMeshData->LinkNeighboursOf( aPivotNode ) );
+      BRepMeshCol::ListOfInteger::Iterator aLinkIt( myMeshData->LinksConnectedTo( aPivotNode ) );
       for ( ; aLinkIt.More(); aLinkIt.Next() )
       {
         if ( aLinkIt.Value() != anEdgeId &&
@@ -2023,15 +2023,15 @@ void  BRepMesh_Delaun::RemoveVertex( const BRepMesh_Vertex& theVertex )
 //function : AddVertices
 //purpose  : Adds some vertices in the triangulation.
 //=======================================================================
-void  BRepMesh_Delaun::AddVertices( BRepMesh_Array1OfVertexOfDelaun& theVertices )
+void BRepMesh_Delaun::AddVertices( BRepMeshCol::Array1OfVertexOfDelaun& theVertices )
 {
-  BRepMesh_HeapSortVertexOfDelaun::Sort( theVertices, 
-    BRepMesh_ComparatorOfVertexOfDelaun( SortingDirection ) );
+  std::make_heap(theVertices.begin(), theVertices.end(), ComparatorOfVertexOfDelaun());
+  std::sort_heap(theVertices.begin(), theVertices.end(), ComparatorOfVertexOfDelaun());
 
   Standard_Integer aLower  = theVertices.Lower();
   Standard_Integer anUpper = theVertices.Upper();
     
-  TColStd_Array1OfInteger aVertexIndexes( aLower, anUpper );
+  BRepMeshCol::Array1OfInteger aVertexIndexes( aLower, anUpper );
   for ( Standard_Integer i = aLower; i <= anUpper; ++i )     
     aVertexIndexes(i) = myMeshData->AddNode( theVertices(i) );
 
@@ -2130,17 +2130,17 @@ Standard_Boolean BRepMesh_Delaun::UseEdge( const Standard_Integer /*theIndex*/ )
 //function : getEdgesByType
 //purpose  : Gives the list of edges with type defined by input parameter
 //=======================================================================
-Handle(BRepMesh_MapOfInteger) BRepMesh_Delaun::getEdgesByType(
+BRepMeshCol::HMapOfInteger BRepMesh_Delaun::getEdgesByType(
   const BRepMesh_DegreeOfFreedom theEdgeType ) const
 {
-  Handle(BRepMesh_MapOfInteger) aResult = new BRepMesh_MapOfInteger;
-  BRepMesh_MapOfInteger::Iterator anEdgeIt( myMeshData->LinkOfDomain() );
+  BRepMeshCol::HMapOfInteger aResult = new BRepMeshCol::MapOfInteger;
+  BRepMeshCol::MapOfInteger::Iterator anEdgeIt( myMeshData->LinksOfDomain() );
 
   for ( ; anEdgeIt.More(); anEdgeIt.Next() )
   {
     Standard_Integer anEdge = anEdgeIt.Key();
     Standard_Boolean isToAdd = (theEdgeType == BRepMesh_Free) ?
-      (myMeshData->ElemConnectedTo( anEdge ).Extent() <= 1) :
+      (myMeshData->ElementsConnectedTo( anEdge ).Extent() <= 1) :
       (GetEdge( anEdge ).Movability() == theEdgeType);
 
     if (isToAdd)
@@ -2205,27 +2205,14 @@ Standard_Boolean BRepMesh_Delaun::Contains( const Standard_Integer theTriangleId
   Standard_Boolean o[3];
   Standard_Integer p[3];
 
-  GetTriangle( theTriangleId ).Edges( e[0], e[1], e[2],
-                                      o[0], o[1], o[2] );
-                                      
+  const BRepMesh_Triangle& aElement = GetTriangle( theTriangleId );
+  aElement.Edges(e, o);
+
   const BRepMesh_Edge* anEdges[3] = { &GetEdge( e[0] ),
                                       &GetEdge( e[1] ),
                                       &GetEdge( e[2] ) };
-  if ( o[0] )
-  {
-    p[0] = anEdges[0]->FirstNode();
-    p[1] = anEdges[0]->LastNode();
-  }
-  else
-  {
-    p[1] = anEdges[0]->FirstNode();
-    p[0] = anEdges[0]->LastNode();
-  }
-  
-  if ( o[2] )
-    p[2] = anEdges[2]->FirstNode();
-  else
-    p[2] = anEdges[2]->LastNode();
+
+  myMeshData->ElementNodes(aElement, p);
 
   gp_XY aPoints[3];
   aPoints[0] = GetVertex( p[0] ).Coord();
@@ -2279,7 +2266,7 @@ Standard_Boolean BRepMesh_Delaun::Contains( const Standard_Integer theTriangleId
 //function : intSegSeg
 //purpose  : Checks intersection between the two segments.
 //=============================================================================
-BRepMesh_WireInterferenceChecker::IntFlag BRepMesh_Delaun::intSegSeg( 
+BRepMesh_GeomTool::IntFlag BRepMesh_Delaun::intSegSeg( 
   const BRepMesh_Edge&   theEdg1,
   const BRepMesh_Edge&   theEdg2,
   const Standard_Boolean isConsiderEndPointTouch,
@@ -2292,7 +2279,7 @@ BRepMesh_WireInterferenceChecker::IntFlag BRepMesh_Delaun::intSegSeg(
   p3 = GetVertex( theEdg2.FirstNode() ).Coord();
   p4 = GetVertex( theEdg2.LastNode()  ).Coord();
   
-  return BRepMesh_WireInterferenceChecker::Intersect(p1, p2, p3, p4,
+  return BRepMesh_GeomTool::IntSegSeg(p1, p2, p3, p4,
     isConsiderEndPointTouch, isConsiderPointOnEdge, theIntPnt);
 }
 
@@ -2301,9 +2288,9 @@ BRepMesh_WireInterferenceChecker::IntFlag BRepMesh_Delaun::intSegSeg(
 //purpose  : Returns area of the loop of the given polygon defined by indices 
 //           of its start and end links.
 //=============================================================================
-Standard_Real BRepMesh_Delaun::polyArea( const TColStd_SequenceOfInteger& thePolygon,
-                                         const Standard_Integer           theStartIndex,
-                                         const Standard_Integer           theEndIndex ) const
+Standard_Real BRepMesh_Delaun::polyArea( const BRepMeshCol::SequenceOfInteger& thePolygon,
+                                         const Standard_Integer                theStartIndex,
+                                         const Standard_Integer                theEndIndex ) const
 {
   Standard_Real aArea = 0.0;
   Standard_Integer aPolyLen = thePolygon.Length();
index 71c2fab..ae6da81 100755 (executable)
 #include <Standard_DefineAlloc.hxx>
 #include <Standard_Macro.hxx>
 
+#include <gp_XY.hxx>
+#include <gp_XYZ.hxx>
 #include <BRepMesh_CircleTool.hxx>
 #include <BRepMesh_Triangle.hxx>
 #include <BRepMesh_Edge.hxx>
-#include <BRepMesh_MapOfInteger.hxx>
-#include <BRepMesh_MapOfIntegerInteger.hxx>
+#include <BRepMesh_Collections.hxx>
 #include <BRepMesh_DataStructureOfDelaun.hxx>
-#include <NCollection_Sequence.hxx>
-#include <BRepMesh_WireInterferenceChecker.hxx>
+#include <BRepMesh_GeomTool.hxx>
 
 class Bnd_B2d;
 class Bnd_Box2d;
 class BRepMesh_Array1OfVertexOfDelaun;
 class BRepMesh_Vertex;
-class TColStd_Array1OfInteger;
-class TColStd_SequenceOfInteger;
-class TColStd_MapOfInteger;
 
 //! Compute the Delaunay's triangulation with the algorithm of Watson.
 class BRepMesh_Delaun
@@ -43,52 +40,52 @@ public:
   DEFINE_STANDARD_ALLOC
 
   //! Creates the triangulation with an empty Mesh data structure.
-  Standard_EXPORT BRepMesh_Delaun (BRepMesh_Array1OfVertexOfDelaun& theVertices,
-                                   const Standard_Boolean           isPositive = Standard_True);
+  Standard_EXPORT BRepMesh_Delaun (BRepMeshCol::Array1OfVertexOfDelaun& theVertices,
+                                   const Standard_Boolean               isPositive = Standard_True);
 
   //! Creates the triangulation with an existent Mesh data structure.
   Standard_EXPORT BRepMesh_Delaun (const Handle(BRepMesh_DataStructureOfDelaun)& theOldMesh,
-                                   BRepMesh_Array1OfVertexOfDelaun&              theVertices,
+                                   BRepMeshCol::Array1OfVertexOfDelaun&          theVertices,
                                    const Standard_Boolean                        isPositive = Standard_True);
 
   //! Creates the triangulation with an existant Mesh data structure.
   Standard_EXPORT BRepMesh_Delaun (const Handle(BRepMesh_DataStructureOfDelaun)& theOldMesh,
-                                   TColStd_Array1OfInteger&                      theVertexIndices,
+                                   BRepMeshCol::Array1OfInteger&                 theVertexIndices,
                                    const Standard_Boolean                        isPositive = Standard_True);
 
   //! Initializes the triangulation with an array of vertices.
-  Standard_EXPORT void Init (BRepMesh_Array1OfVertexOfDelaun& theVertices);
+  Standard_EXPORT void Init (BRepMeshCol::Array1OfVertexOfDelaun& theVertices);
 
   //! Removes a vertex from the triangulation.
   Standard_EXPORT void RemoveVertex (const BRepMesh_Vertex& theVertex);
 
   //! Adds some vertices into the triangulation.
-  Standard_EXPORT void AddVertices (BRepMesh_Array1OfVertexOfDelaun& theVertices);
+  Standard_EXPORT void AddVertices (BRepMeshCol::Array1OfVertexOfDelaun& theVertices);
 
   //! Modify mesh to use the edge.
   //! @return True if done
   Standard_EXPORT Standard_Boolean UseEdge (const Standard_Integer theEdge);
 
   //! Gives the Mesh data structure.
-  const Handle(BRepMesh_DataStructureOfDelaun)& Result() const
+  inline const Handle(BRepMesh_DataStructureOfDelaun)& Result() const
   {
     return myMeshData;
   }
 
   //! Gives the list of frontier edges.
-  inline Handle(BRepMesh_MapOfInteger) Frontier() const
+  inline BRepMeshCol::HMapOfInteger Frontier() const
   {
     return getEdgesByType (BRepMesh_Frontier);
   }
 
   //! Gives the list of internal edges.
-  inline Handle(BRepMesh_MapOfInteger) InternalEdges() const
+  inline BRepMeshCol::HMapOfInteger InternalEdges() const
   {
     return getEdgesByType (BRepMesh_Fixed);
   }
 
   //! Gives the list of free edges used only one time
-  inline Handle(BRepMesh_MapOfInteger) FreeEdges() const
+  inline BRepMeshCol::HMapOfInteger FreeEdges() const
   {
     return getEdgesByType (BRepMesh_Free);
   }
@@ -127,31 +124,29 @@ private:
     InsertBefore
   };
 
-  typedef NCollection_DataMap<Standard_Integer, NCollection_Map<Standard_Integer> > DataMapOfMap;
-
-  typedef NCollection_Handle<NCollection_Map<Standard_Integer> > HandleOfMapOfInteger;
+  typedef NCollection_DataMap<Standard_Integer, BRepMeshCol::MapOfInteger> DataMapOfMap;
 
   //! Add boundig box for edge defined by start & end point to
   //! the given vector of bounding boxes for triangulation edges.
-  void fillBndBox (NCollection_Sequence<Bnd_B2d>&   theBoxes,
+  void fillBndBox (BRepMeshCol::SequenceOfBndB2d&   theBoxes,
                    const BRepMesh_Vertex&           theV1,
                    const BRepMesh_Vertex&           theV2);
 
   //! Gives the list of edges with type defined by the input parameter.
   //! If the given type is BRepMesh_Free returns list of edges
   //! that have number of connected elements less or equal 1.
-  Handle(BRepMesh_MapOfInteger) getEdgesByType (const BRepMesh_DegreeOfFreedom theEdgeType) const;
+  BRepMeshCol::HMapOfInteger getEdgesByType (const BRepMesh_DegreeOfFreedom theEdgeType) const;
 
   //! Create super mesh and run triangulation procedure.
-  void perform (Bnd_Box2d&               theBndBox,
-                TColStd_Array1OfInteger& theVertexIndices);
+  void perform (Bnd_Box2d&                    theBndBox,
+                BRepMeshCol::Array1OfInteger& theVertexIndices);
 
   //! Build the super mesh.
   void superMesh (const Bnd_Box2d& theBox);
 
   //! Computes the triangulation and adds the vertices,
   //! edges and triangles to the Mesh data structure.
-  void compute (TColStd_Array1OfInteger& theVertexIndices);
+  void compute (BRepMeshCol::Array1OfInteger& theVertexIndices);
 
   //! Adjust the mesh on the frontier.
   void frontierAdjust();
@@ -159,56 +154,56 @@ private:
   //! Find left polygon of the given edge and call meshPolygon.
   Standard_Boolean meshLeftPolygonOf (const Standard_Integer theEdgeIndex,
                                       const Standard_Boolean isForward,
-                                      HandleOfMapOfInteger   theSkipped = NULL);
+                                      BRepMeshCol::HMapOfInteger theSkipped = NULL);
 
   //! Find next link starting from the given node and has maximum
   //! angle respect the given reference link.
   //! Each time the next link is found other neighbor links at the pivot
   //! node are marked as leprous and will be excluded from consideration
   //! next time until a hanging end is occured.
-  Standard_Integer findNextPolygonLink (const Standard_Integer&              theFirstNode,
-                                        const Standard_Integer&              thePivotNode,
-                                        const BRepMesh_Vertex&               thePivotVertex,
-                                        const gp_Vec2d&                      theRefLinkDir,
-                                        const NCollection_Sequence<Bnd_B2d>& theBoxes,
-                                        const TColStd_SequenceOfInteger&     thePolygon,
-                                        const HandleOfMapOfInteger           theSkipped,
-                                        const Standard_Boolean&              isSkipLeprous,
-                                        NCollection_Map<Standard_Integer>&   theLeprousLinks,
-                                        NCollection_Map<Standard_Integer>&   theDeadLinks,
-                                        Standard_Integer&                    theNextPivotNode,
-                                        gp_Vec2d&                            theNextLinkDir,
-                                        Bnd_B2d&                             theNextLinkBndBox);
+  Standard_Integer findNextPolygonLink (const Standard_Integer&               theFirstNode,
+                                        const Standard_Integer&               thePivotNode,
+                                        const BRepMesh_Vertex&                thePivotVertex,
+                                        const gp_Vec2d&                       theRefLinkDir,
+                                        const BRepMeshCol::SequenceOfBndB2d&  theBoxes,
+                                        const BRepMeshCol::SequenceOfInteger& thePolygon,
+                                        const BRepMeshCol::HMapOfInteger      theSkipped,
+                                        const Standard_Boolean&               isSkipLeprous,
+                                        BRepMeshCol::MapOfInteger&            theLeprousLinks,
+                                        BRepMeshCol::MapOfInteger&            theDeadLinks,
+                                        Standard_Integer&                     theNextPivotNode,
+                                        gp_Vec2d&                             theNextLinkDir,
+                                        Bnd_B2d&                              theNextLinkBndBox);
 
   //! Check is the given link intersects the polygon boundaries.
   //! Returns bounding box for the given link trough the theLinkBndBox parameter.
-  Standard_Boolean checkIntersection (const BRepMesh_Edge&                 theLink,
-                                      const TColStd_SequenceOfInteger&     thePolygon,
-                                      const NCollection_Sequence<Bnd_B2d>& thePolyBoxes,
-                                      const Standard_Boolean               isConsiderEndPointTouch,
-                                      const Standard_Boolean               isConsiderPointOnEdge,
-                                      const Standard_Boolean               isSkipLastEdge,
-                                      Bnd_B2d&                             theLinkBndBox) const;
+  Standard_Boolean checkIntersection (const BRepMesh_Edge&                  theLink,
+                                      const BRepMeshCol::SequenceOfInteger& thePolygon,
+                                      const BRepMeshCol::SequenceOfBndB2d&  thePolyBoxes,
+                                      const Standard_Boolean                isConsiderEndPointTouch,
+                                      const Standard_Boolean                isConsiderPointOnEdge,
+                                      const Standard_Boolean                isSkipLastEdge,
+                                      Bnd_B2d&                              theLinkBndBox) const;
 
   //! Triangulatiion of a closed polygon described by the list
   //! of indexes of its edges in the structure.
   //! (negative index means reversed edge)
-  void meshPolygon (TColStd_SequenceOfInteger&     thePolygon,
-                    NCollection_Sequence<Bnd_B2d>& thePolyBoxes,
-                    HandleOfMapOfInteger           theSkipped = NULL);
+  void meshPolygon (BRepMeshCol::SequenceOfInteger& thePolygon,
+                    BRepMeshCol::SequenceOfBndB2d&  thePolyBoxes,
+                    BRepMeshCol::HMapOfInteger      theSkipped = NULL);
 
   //! Triangulatiion of a closed simple polygon (polygon without glued edges and loops)
   //! described by the list of indexes of its edges in the structure.
   //! (negative index means reversed edge)
-  void meshSimplePolygon (TColStd_SequenceOfInteger&     thePolygon,
-                          NCollection_Sequence<Bnd_B2d>& thePolyBoxes);
+  void meshSimplePolygon (BRepMeshCol::SequenceOfInteger& thePolygon,
+                          BRepMeshCol::SequenceOfBndB2d&  thePolyBoxes);
 
   //! Triangulation of closed polygon containing only three edges.
-  inline Standard_Boolean meshElementaryPolygon (const TColStd_SequenceOfInteger& thePolygon);
+  inline Standard_Boolean meshElementaryPolygon (const BRepMeshCol::SequenceOfInteger& thePolygon);
 
   //! Creates the triangles beetween the given node and the given polyline.
-  void createTriangles (const Standard_Integer        theVertexIndex,
-                        BRepMesh_MapOfIntegerInteger& thePoly);
+  void createTriangles (const Standard_Integer            theVertexIndex,
+                        BRepMeshCol::MapOfIntegerInteger& thePoly);
 
   //! Add a triangle based on the given oriented edges into mesh
   inline void addTriangle (const Standard_Integer (&theEdgesId)[3],
@@ -217,8 +212,8 @@ private:
 
   //! Deletes the triangle with the given index and adds the free edges into the map.
   //! When an edge is suppressed more than one time it is destroyed.
-  void deleteTriangle (const Standard_Integer        theIndex,
-                       BRepMesh_MapOfIntegerInteger& theLoopEdges);
+  void deleteTriangle (const Standard_Integer            theIndex,
+                       BRepMeshCol::MapOfIntegerInteger& theLoopEdges);
 
   //! Returns start and end nodes of the given edge in respect to its orientation.
   void getOrientedNodes (const BRepMesh_Edge&   theEdge,
@@ -227,21 +222,21 @@ private:
 
   //! Processes loop within the given polygon formed by range of its
   //! links specified by start and end link indices.
-  void processLoop (const Standard_Integer               theLinkFrom,
-                    const Standard_Integer               theLinkTo,
-                    const TColStd_SequenceOfInteger&     thePolygon,
-                    const NCollection_Sequence<Bnd_B2d>& thePolyBoxes);
+  void processLoop (const Standard_Integer                theLinkFrom,
+                    const Standard_Integer                theLinkTo,
+                    const BRepMeshCol::SequenceOfInteger& thePolygon,
+                    const BRepMeshCol::SequenceOfBndB2d&  thePolyBoxes);
 
   //! Creates new link based on the given nodes and updates the given polygon.
-  Standard_Integer createAndReplacePolygonLink (const Standard_Integer         theNodes[],
-                                                const gp_Pnt2d                 thePnts [],
-                                                const Standard_Integer         theRootIndex,
-                                                const ReplaceFlag              theReplaceFlag,
-                                                TColStd_SequenceOfInteger&     thePolygon,
-                                                NCollection_Sequence<Bnd_B2d>& thePolyBoxes);
+  Standard_Integer createAndReplacePolygonLink (const Standard_Integer          theNodes[],
+                                                const gp_Pnt2d                  thePnts [],
+                                                const Standard_Integer          theRootIndex,
+                                                const ReplaceFlag               theReplaceFlag,
+                                                BRepMeshCol::SequenceOfInteger& thePolygon,
+                                                BRepMeshCol::SequenceOfBndB2d&  thePolyBoxes);
   
   //! Creates the triangles on new nodes.
-  void createTrianglesOnNewVertices (TColStd_Array1OfInteger& theVertexIndices);
+  void createTrianglesOnNewVertices (BRepMeshCol::Array1OfInteger& theVertexIndices);
 
   //! Cleanup mesh from the free triangles.
   void cleanupMesh();
@@ -257,35 +252,35 @@ private:
                                       const Standard_Integer thePrevElementId);
 
   //! Remove internal triangles from the given polygon.
-  void cleanupPolygon (const TColStd_SequenceOfInteger&     thePolygon,
-                       const NCollection_Sequence<Bnd_B2d>& thePolyBoxes);
+  void cleanupPolygon (const BRepMeshCol::SequenceOfInteger& thePolygon,
+                       const BRepMeshCol::SequenceOfBndB2d&  thePolyBoxes);
 
   //! Checks is the given vertex lies inside the polygon.
-  Standard_Boolean isVertexInsidePolygon (const Standard_Integer&                     theVertexId,
-                                          const NCollection_Vector<Standard_Integer>& thePolygonVertices) const;
+  Standard_Boolean isVertexInsidePolygon (const Standard_Integer&             theVertexId,
+                                          const BRepMeshCol::VectorOfInteger& thePolygonVertices) const;
 
   //! Remove all triangles and edges that are placed inside the polygon or crossed it.
-  void killTrianglesAroundVertex (const Standard_Integer                      theZombieNodeId,
-                                  const NCollection_Vector<Standard_Integer>& thePolyVertices,
-                                  const NCollection_Map<Standard_Integer>&    thePolyVerticesFindMap,
-                                  const TColStd_SequenceOfInteger&            thePolygon,
-                                  const NCollection_Sequence<Bnd_B2d>&        thePolyBoxes,
-                                  NCollection_Map<Standard_Integer>&          theSurvivedLinks,
-                                  BRepMesh_MapOfIntegerInteger&               theLoopEdges);
+  void killTrianglesAroundVertex (const Standard_Integer                theZombieNodeId,
+                                  const BRepMeshCol::VectorOfInteger&   thePolyVertices,
+                                  const BRepMeshCol::MapOfInteger&      thePolyVerticesFindMap,
+                                  const BRepMeshCol::SequenceOfInteger& thePolygon,
+                                  const BRepMeshCol::SequenceOfBndB2d&  thePolyBoxes,
+                                  BRepMeshCol::MapOfInteger&            theSurvivedLinks,
+                                  BRepMeshCol::MapOfIntegerInteger&     theLoopEdges);
 
   //! Checks is the given link crosses the polygon boundary.
   //! If yes, kills its triangles and checks neighbor links on boundary intersection. Does nothing elsewhere.
-  void killTrianglesOnIntersectingLinks (const Standard_Integer&              theLinkToCheckId,
-                                         const BRepMesh_Edge&                 theLinkToCheck,
-                                         const Standard_Integer&              theEndPoint,
-                                         const TColStd_SequenceOfInteger&     thePolygon,
-                                         const NCollection_Sequence<Bnd_B2d>& thePolyBoxes,
-                                         NCollection_Map<Standard_Integer>&   theSurvivedLinks,
-                                         BRepMesh_MapOfIntegerInteger&        theLoopEdges);
+  void killTrianglesOnIntersectingLinks (const Standard_Integer&                theLinkToCheckId,
+                                         const BRepMesh_Edge&                   theLinkToCheck,
+                                         const Standard_Integer&                theEndPoint,
+                                         const BRepMeshCol::SequenceOfInteger&  thePolygon,
+                                         const BRepMeshCol::SequenceOfBndB2d&   thePolyBoxes,
+                                         BRepMeshCol::MapOfInteger&             theSurvivedLinks,
+                                         BRepMeshCol::MapOfIntegerInteger&      theLoopEdges);
 
   //! Kill triangles bound to the given link.
-  void killLinkTriangles (const Standard_Integer&       theLinkId,
-                          BRepMesh_MapOfIntegerInteger& theLoopEdges);
+  void killLinkTriangles (const Standard_Integer&           theLinkId,
+                          BRepMeshCol::MapOfIntegerInteger& theLoopEdges);
 
   //! Calculates distances between the given point and edges of triangle.
   Standard_Real calculateDist (const gp_XY            theVEdges[3],
@@ -297,7 +292,7 @@ private:
                                Standard_Integer&      theEdgeOn) const;
 
   //! Checks intersection between the two segments.
-  BRepMesh_WireInterferenceChecker::IntFlag intSegSeg (
+  BRepMesh_GeomTool::IntFlag intSegSeg(
     const BRepMesh_Edge&   theEdge1,
     const BRepMesh_Edge&   theEdge2,
     const Standard_Boolean isConsiderEndPointTouch,
@@ -305,9 +300,9 @@ private:
     gp_Pnt2d&              theIntPnt) const;
 
   //! Returns area of the loop of the given polygon defined by indices of its start and end links.
-  Standard_Real polyArea (const TColStd_SequenceOfInteger& thePolygon,
-                          const Standard_Integer           theStartIndex,
-                          const Standard_Integer           theEndIndex) const;
+  Standard_Real polyArea (const BRepMeshCol::SequenceOfInteger& thePolygon,
+                          const Standard_Integer                theStartIndex,
+                          const Standard_Integer                theEndIndex) const;
 
 private:
 
diff --git a/src/BRepMesh/BRepMesh_DiscretFactory.cdl b/src/BRepMesh/BRepMesh_DiscretFactory.cdl
deleted file mode 100644 (file)
index 2a84172..0000000
+++ /dev/null
@@ -1,114 +0,0 @@
--- Created on: 2008-04-10
--- Created by: Peter KURNEV <pkv@irinox>
--- Copyright (c) 2008-2014 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.
-
-class DiscretFactory from BRepMesh
-
-    ---Purpose:
-    -- This class intended to setup / retrieve default triangulation algorithm.
-    -- Use BRepMesh_DiscretFactory::Get() static method to retrieve global Factory instance.
-    -- Use BRepMesh_DiscretFactory::Discret() method to retrieve meshing tool.
-
-uses
-    DiscretRoot      from BRepMesh,
-    FactoryError     from BRepMesh,
-    PluginEntryType  from BRepMesh,
-    AsciiString      from TCollection,
-    MapOfAsciiString from TColStd,
-    Shape            from TopoDS,
-    MapOfFunctions   from Plugin
-
---raises
-
-is
-    Create
-        returns DiscretFactory from BRepMesh
-        is protected;
-    ---C++: alias "Standard_EXPORT virtual ~BRepMesh_DiscretFactory();"
-
-    Get (myclass)
-        returns DiscretFactory from BRepMesh;
-    ---C++: return &
-    ---Purpose:
-    -- Returns the global factory instance.
-
-    Names (me)
-        returns MapOfAsciiString from TColStd;
-    ---C++: return const &
-    ---Purpose:
-    -- Returns the list of registered meshing algorithms.
-
-    SetDefaultName (     me : out;
-                    theName : AsciiString from TCollection)
-        returns Boolean from Standard;
-    ---Purpose:
-    -- Setup meshing algorithm by name.
-    -- Returns true if requested tool is available.
-    -- On fail Factory will continue to use previous algo.
-
-    DefaultName (me)
-        returns AsciiString from TCollection;
-    ---C++: return const &
-    ---Purpose:
-    -- Returns name for current meshing algorithm.
-
-    SetFunctionName (         me : out;
-                     theFuncName : AsciiString from TCollection)
-        returns Boolean from Standard;
-    ---Purpose:
-    -- Advanced function. Changes function name to retrieve from plugin.
-    -- Returns true if requested tool is available.
-    -- On fail Factory will continue to use previous algo.
-
-    SetDefault (         me : out;
-                    theName : AsciiString from TCollection;
-                theFuncName : AsciiString from TCollection = "DISCRETALGO")
-        returns Boolean from Standard;
-    ---Purpose:
-    -- Setup meshing algorithm that should be created by this Factory.
-    -- Returns true if requested tool is available.
-    -- On fail Factory will continue to use previous algo.
-    -- Call ::ErrorStatus() method to retrieve fault reason.
-
-    FunctionName (me)
-        returns AsciiString from TCollection;
-    ---C++: return const &
-    ---Purpose:
-    -- Returns function name that should be exported by plugin.
-
-    Discret (me            : out;
-             theShape      : Shape from TopoDS;
-             theDeflection : Real  from Standard;
-             theAngle      : Real  from Standard)
-        returns DiscretRoot from BRepMesh;
-    ---Purpose:
-    -- Returns triangulation algorithm instance.
-
-    ErrorStatus (me)
-        returns FactoryError from BRepMesh;
-    ---Purpose:
-    -- Returns error status for last meshing algorithm switch.
-
-    Clear (me : out)
-        is protected;
-
-fields
-    myPluginEntry    : PluginEntryType from BRepMesh is protected;
-    myErrorStatus    : FactoryError from BRepMesh is protected;
-    myNames          : MapOfAsciiString from TColStd is protected;
-    myDefaultName    : AsciiString from TCollection is protected;
-    myFunctionName   : AsciiString from TCollection is protected;
-    myFactoryMethods : MapOfFunctions from Plugin is protected;
-
-end DiscretFactory;
index a366df1..8e727bd 100644 (file)
@@ -13,7 +13,7 @@
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
-#include <BRepMesh_DiscretFactory.ixx>
+#include <BRepMesh_DiscretFactory.hxx>
 
 #include <OSD_SharedLibrary.hxx>
 #include <OSD_Function.hxx>
@@ -52,13 +52,13 @@ namespace
 //purpose  :
 //=======================================================================
 BRepMesh_DiscretFactory::BRepMesh_DiscretFactory()
-: myPluginEntry (NULL),
-  myErrorStatus (BRepMesh_FE_NOERROR),
-  myDefaultName (THE_FAST_DISCRET_MESH),
+: myPluginEntry  (NULL),
+  myErrorStatus  (BRepMesh_FE_NOERROR),
+  myDefaultName  (THE_FAST_DISCRET_MESH),
   myFunctionName ("DISCRETALGO")
 {
   // register built-in meshing algorithms
-  myNames.Add (THE_FAST_DISCRET_MESH);
+  myNames.Add(THE_FAST_DISCRET_MESH);
 }
 
 //=======================================================================
@@ -67,14 +67,14 @@ BRepMesh_DiscretFactory::BRepMesh_DiscretFactory()
 //=======================================================================
 BRepMesh_DiscretFactory::~BRepMesh_DiscretFactory()
 {
-  Clear();
+  clear();
 }
 
 //=======================================================================
-//function : ~
+//function : clear
 //purpose  :
 //=======================================================================
-void BRepMesh_DiscretFactory::Clear()
+void BRepMesh_DiscretFactory::clear()
 {
   // what should we do here? Unload dynamic libraries and reset plugins list?
 }
@@ -91,65 +91,12 @@ BRepMesh_DiscretFactory& BRepMesh_DiscretFactory::Get()
 }
 
 //=======================================================================
-//function : ErrorStatus
-//purpose  :
-//=======================================================================
-BRepMesh_FactoryError BRepMesh_DiscretFactory::ErrorStatus() const
-{
-  return myErrorStatus;
-}
-
-//=======================================================================
-//function : Names
-//purpose  :
-//=======================================================================
-const TColStd_MapOfAsciiString& BRepMesh_DiscretFactory::Names() const
-{
-  return myNames;
-}
-
-//=======================================================================
-//function : SetDefaultName
-//purpose  :
-//=======================================================================
-Standard_Boolean BRepMesh_DiscretFactory::SetDefaultName (const TCollection_AsciiString& theName)
-{
-  return SetDefault (theName, myFunctionName);
-}
-
-//=======================================================================
-//function : DefaultName
-//purpose  :
-//=======================================================================
-const TCollection_AsciiString& BRepMesh_DiscretFactory::DefaultName() const
-{
-  return myDefaultName;
-}
-
-//=======================================================================
-//function : SetFunctionName
-//purpose  :
-//=======================================================================
-Standard_Boolean BRepMesh_DiscretFactory::SetFunctionName (const TCollection_AsciiString& theFuncName)
-{
-  return SetDefault (myDefaultName, theFuncName);
-}
-
-//=======================================================================
-//function : FunctionName
-//purpose  :
-//=======================================================================
-const TCollection_AsciiString& BRepMesh_DiscretFactory::FunctionName() const
-{
-  return myFunctionName;
-}
-
-//=======================================================================
 //function : SetDefault
 //purpose  :
 //=======================================================================
-Standard_Boolean BRepMesh_DiscretFactory::SetDefault (const TCollection_AsciiString& theName,
-                                                      const TCollection_AsciiString& theFuncName)
+Standard_Boolean BRepMesh_DiscretFactory::SetDefault(
+  const TCollection_AsciiString& theName,
+  const TCollection_AsciiString& theFuncName)
 {
   myErrorStatus = BRepMesh_FE_NOERROR;
   if (theName == THE_FAST_DISCRET_MESH)
@@ -221,17 +168,19 @@ Standard_Boolean BRepMesh_DiscretFactory::SetDefault (const TCollection_AsciiStr
 //function : Discret
 //purpose  :
 //=======================================================================
-Handle(BRepMesh_DiscretRoot) BRepMesh_DiscretFactory
-  ::Discret (const TopoDS_Shape& theShape,
-             const Standard_Real theDeflection,
-             const Standard_Real theAngle)
+Handle(BRepMesh_DiscretRoot) BRepMesh_DiscretFactory::Discret(
+  const TopoDS_Shape& theShape,
+  const Standard_Real theDeflection,
+  const Standard_Real theAngle)
 {
   Handle(BRepMesh_DiscretRoot) aDiscretRoot;
   BRepMesh_PDiscretRoot anInstancePtr = NULL;
   if (myPluginEntry != NULL)
   {
     // use plugin
-    Standard_Integer anErr = myPluginEntry (theShape, theDeflection, theAngle, anInstancePtr);
+    Standard_Integer anErr = myPluginEntry (theShape, 
+      theDeflection, theAngle, anInstancePtr);
+      
     if (anErr != 0 || anInstancePtr == NULL)
     {
       // can not create the algo specified - should never happens here
@@ -242,7 +191,8 @@ Handle(BRepMesh_DiscretRoot) BRepMesh_DiscretFactory
   else //if (myDefaultName == THE_FAST_DISCRET_MESH)
   {
     // use built-in
-    BRepMesh_IncrementalMesh::Discret (theShape, theDeflection, theAngle, anInstancePtr);
+    BRepMesh_IncrementalMesh::Discret (theShape, 
+      theDeflection, theAngle, anInstancePtr);
   }
 
   // cover with handle
diff --git a/src/BRepMesh/BRepMesh_DiscretFactory.hxx b/src/BRepMesh/BRepMesh_DiscretFactory.hxx
new file mode 100644 (file)
index 0000000..6d3bac9
--- /dev/null
@@ -0,0 +1,118 @@
+// Copyright (c) 2013 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 _BRepMesh_DiscretFactory_HeaderFile
+#define _BRepMesh_DiscretFactory_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Macro.hxx>
+#include <BRepMesh_PluginEntryType.hxx>
+#include <BRepMesh_FactoryError.hxx>
+#include <TColStd_MapOfAsciiString.hxx>
+#include <TCollection_AsciiString.hxx>
+#include <Plugin_MapOfFunctions.hxx>
+#include <BRepMesh_DiscretRoot.hxx>
+
+class TColStd_MapOfAsciiString;
+class TCollection_AsciiString;
+class BRepMesh_DiscretRoot;
+class TopoDS_Shape;
+
+//! This class intended to setup / retrieve default triangulation algorithm. <br>
+//! Use BRepMesh_DiscretFactory::Get() static method to retrieve global Factory instance. <br>
+//! Use BRepMesh_DiscretFactory::Discret() method to retrieve meshing tool. <br>
+class BRepMesh_DiscretFactory
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+  
+  //! Returns the global factory instance.
+  Standard_EXPORT static BRepMesh_DiscretFactory& Get();
+  
+  //! Returns the list of registered meshing algorithms.
+  inline const TColStd_MapOfAsciiString& Names() const
+  {
+    return myNames;
+  }
+  
+  //! Setup meshing algorithm by name. <br>
+  //! Returns TRUE if requested tool is available. <br>
+  //! On fail Factory will continue to use previous algo.
+  Standard_EXPORT Standard_Boolean SetDefaultName(const TCollection_AsciiString& theName)
+  {
+    return SetDefault(theName, myFunctionName);
+  }
+  
+  //! Returns name for current meshing algorithm.
+  inline const TCollection_AsciiString& DefaultName() const
+  {
+    return myDefaultName;
+  }
+  
+  //! Advanced function. Changes function name to retrieve from plugin. <br>
+  //! Returns TRUE if requested tool is available. <br>
+  //! On fail Factory will continue to use previous algo.
+  Standard_EXPORT Standard_Boolean SetFunctionName(const TCollection_AsciiString& theFuncName)
+  {
+    return SetDefault(myDefaultName, theFuncName);
+  }
+  
+  //! Returns function name that should be exported by plugin.
+  inline const TCollection_AsciiString& FunctionName() const
+  {
+    return myFunctionName;
+  }
+  
+  //! Returns error status for last meshing algorithm switch.
+  inline BRepMesh_FactoryError ErrorStatus() const
+  {
+    return myErrorStatus;
+  }
+
+  //! Setup meshing algorithm that should be created by this Factory. <br>
+  //! Returns TRUE if requested tool is available. <br>
+  //! On fail Factory will continue to use previous algo. <br>
+  //! Call ::ErrorStatus() method to retrieve fault reason.
+  Standard_EXPORT Standard_Boolean SetDefault(const TCollection_AsciiString& theName,
+                                              const TCollection_AsciiString& theFuncName = "DISCRETALGO");
+
+  //! Returns triangulation algorithm instance.
+  //! \param theShape shape to be meshed.
+  //! \param theLinDeflection linear deflection to be used for meshing.
+  //! \param theAngDeflection angular deflection to be used for meshing.
+  Standard_EXPORT Handle(BRepMesh_DiscretRoot) Discret(const TopoDS_Shape& theShape,
+                                                       const Standard_Real theLinDeflection,
+                                                       const Standard_Real theAngDeflection);
+
+protected:
+  
+  //! Constructor
+  Standard_EXPORT BRepMesh_DiscretFactory();
+
+  //! Destructor
+  Standard_EXPORT virtual ~BRepMesh_DiscretFactory();
+
+  //! Clears factory data.
+  Standard_EXPORT void clear();
+
+  BRepMesh_PluginEntryType  myPluginEntry;
+  BRepMesh_FactoryError     myErrorStatus;
+  TColStd_MapOfAsciiString  myNames;
+  TCollection_AsciiString   myDefaultName;
+  TCollection_AsciiString   myFunctionName;
+  Plugin_MapOfFunctions     myFactoryMethods;
+};
+
+#endif
diff --git a/src/BRepMesh/BRepMesh_DiscretRoot.cdl b/src/BRepMesh/BRepMesh_DiscretRoot.cdl
deleted file mode 100644 (file)
index a815e67..0000000
+++ /dev/null
@@ -1,92 +0,0 @@
--- Created on: 2008-04-10
--- Created by: Peter KURNEV <pkv@irinox>
--- Copyright (c) 2008-2014 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.
-
-deferred class DiscretRoot from BRepMesh
-
-inherits Transient from Standard
-
-    ---Purpose:
-    -- This is a common interface for meshing algorithms
-    -- instantiated by Mesh Factory and implemented by plugins.
-
-uses
-    Shape from TopoDS
-
---raises
-
-is
-    Initialize
-        returns DiscretRoot from BRepMesh;
-
-    SetDeflection (           me : mutable;
-                   theDeflection : Real from Standard);
-    ---Purpose:
-    -- Setup linear deflection.
-
-    ---C++: alias "Standard_EXPORT virtual ~BRepMesh_DiscretRoot();"
-
-    Deflection (me)
-        returns Real from Standard;
-    ---Purpose:
-    -- Returns linear deflection.
-
-    SetAngle (      me : mutable;
-              theAngle : Real from Standard);
-    ---Purpose:
-    -- Setup angular deflection.
-
-    Angle (me)
-        returns Real from Standard;
-    ---Purpose:
-    -- Returns angular deflection.
-
-    SetShape (      me : mutable;
-              theShape : Shape from TopoDS);
-    ---Purpose:
-    -- Set the shape to triangulate.
-
-    Shape (me)
-        returns Shape from TopoDS;
-    ---C++: return const &
-
-    Perform (me : mutable)
-        is deferred;
-    ---Purpose:
-    -- Compute triangulation for set shape.
-
-    IsDone (me)
-        returns Boolean from Standard;
-    ---Purpose:
-    -- Returns true if triangualtion was performed and has success.
-
-    --
-    --  Protected methods
-    --
-    SetDone (me : mutable)
-        is protected;
-
-    SetNotDone (me : mutable)
-        is protected;
-
-    Init (me : mutable)
-        is virtual protected;
-
-fields
-    myDeflection : Real from Standard is protected;
-    myAngle      : Real from Standard is protected;
-    myShape      : Shape from TopoDS  is protected;
-    myIsDone     : Boolean from Standard is protected;
-
-end DiscretRoot;
index 85f95f3..1d7123a 100644 (file)
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
-#include <BRepMesh_DiscretRoot.ixx>
+#include <BRepMesh_DiscretRoot.hxx>
+
+IMPLEMENT_STANDARD_HANDLE (BRepMesh_DiscretRoot, Standard_Transient)
+IMPLEMENT_STANDARD_RTTIEXT(BRepMesh_DiscretRoot, Standard_Transient)
 
 //=======================================================================
 //function : BRepMesh_DiscretRoot
 //=======================================================================
 BRepMesh_DiscretRoot::BRepMesh_DiscretRoot()
 : myDeflection (0.001),
-  myAngle (0.1),
-  myIsDone (Standard_False)
+  myAngle      (0.1),
+  myIsDone     (Standard_False)
 {
-  //
 }
 
 //=======================================================================
@@ -36,91 +38,9 @@ BRepMesh_DiscretRoot::~BRepMesh_DiscretRoot()
 }
 
 //=======================================================================
-//function : SetDeflection
-//purpose  :
-//=======================================================================
-void BRepMesh_DiscretRoot::SetDeflection (const Standard_Real theDeflection)
-{
-  myDeflection = theDeflection;
-}
-
-//=======================================================================
-//function : Deflection
-//purpose  : 
-//=======================================================================
-Standard_Real BRepMesh_DiscretRoot::Deflection() const
-{
-  return myDeflection;
-}
-
-//=======================================================================
-//function : SetAngle
-//purpose  :
-//=======================================================================
-void BRepMesh_DiscretRoot::SetAngle (const Standard_Real theAngle)
-{
-  myAngle = theAngle;
-}
-
-//=======================================================================
-//function : Angle
-//purpose  :
-//=======================================================================
-Standard_Real BRepMesh_DiscretRoot::Angle() const
-{
-  return myAngle;
-}
-
-//=======================================================================
-//function : SetShape
-//purpose  :
-//=======================================================================
-void BRepMesh_DiscretRoot::SetShape (const TopoDS_Shape& theShape)
-{
-  myShape = theShape;
-}
-
-//=======================================================================
-//function : Shape
-//purpose  :
-//=======================================================================
-const TopoDS_Shape& BRepMesh_DiscretRoot::Shape() const
-{
-  return myShape;
-}
-
-//=======================================================================
-//function : IsDone
-//purpose  :
-//=======================================================================
-Standard_Boolean BRepMesh_DiscretRoot::IsDone() const
-{
-  return myIsDone;
-}
-
-//=======================================================================
-//function : SetDone
-//purpose  :
-//=======================================================================
-void BRepMesh_DiscretRoot::SetDone()
-{
-  myIsDone = Standard_True;
-}
-
-//=======================================================================
-//function : SetNotDone
-//purpose  :
-//=======================================================================
-void BRepMesh_DiscretRoot::SetNotDone()
-{
-  myIsDone = Standard_False;
-}
-
-//=======================================================================
-//function : Init
+//function : init
 //purpose  :
 //=======================================================================
-void BRepMesh_DiscretRoot::Init()
+void BRepMesh_DiscretRoot::init()
 {
-  //
 }
diff --git a/src/BRepMesh/BRepMesh_DiscretRoot.hxx b/src/BRepMesh/BRepMesh_DiscretRoot.hxx
new file mode 100644 (file)
index 0000000..3d3c38e
--- /dev/null
@@ -0,0 +1,105 @@
+// Copyright (c) 2013 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 _BRepMesh_DiscretRoot_HeaderFile
+#define _BRepMesh_DiscretRoot_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineHandle.hxx>
+#include <TopoDS_Shape.hxx>
+#include <Standard_Transient.hxx>
+
+//! This is a common interface for meshing algorithms 
+//! instantiated by Mesh Factory and implemented by plugins.
+class BRepMesh_DiscretRoot : public Standard_Transient
+{
+public:
+  
+  //! Destructor
+  Standard_EXPORT virtual ~BRepMesh_DiscretRoot();
+
+  //! Setup linear deflection.
+  inline void SetDeflection(const Standard_Real theDeflection)
+  {
+    myDeflection = theDeflection;
+  }
+  
+  //! Returns linear deflection.
+  inline Standard_Real Deflection() const
+  {
+    return myDeflection;
+  }
+  
+  //! Setup angular deflection.
+  inline void SetAngle(const Standard_Real theAngle)
+  {
+    myAngle = theAngle;
+  }
+  
+  //! Returns angular deflection.
+  inline Standard_Real Angle() const
+  {
+    return myAngle;
+  }
+  
+  //! Set the shape to triangulate.
+  inline void SetShape(const TopoDS_Shape& theShape)
+  {
+    myShape = theShape;
+  }
+  
+  inline const TopoDS_Shape& Shape() const
+  {
+    return myShape;
+  }
+  
+  //! Returns true if triangualtion was performed and has success.
+  inline Standard_Boolean IsDone() const
+  {
+    return myIsDone;
+  }
+
+  //! Compute triangulation for set shape.
+  Standard_EXPORT virtual void Perform() = 0;
+
+
+  DEFINE_STANDARD_RTTI(BRepMesh_DiscretRoot)
+
+protected:
+  
+  //! Constructor
+  Standard_EXPORT BRepMesh_DiscretRoot();
+  
+  //! Sets IsDone flag.
+  inline void setDone()
+  {
+    myIsDone = Standard_True;
+  }
+  
+  //! Clears IsDone flag.
+  inline void setNotDone()
+  {
+    myIsDone = Standard_False;
+  }
+  
+  Standard_EXPORT virtual void init();
+
+  Standard_Real     myDeflection;
+  Standard_Real     myAngle;
+  TopoDS_Shape      myShape;
+  Standard_Boolean  myIsDone;
+};
+
+DEFINE_STANDARD_HANDLE(BRepMesh_DiscretRoot, Standard_Transient)
+
+#endif
diff --git a/src/BRepMesh/BRepMesh_Edge.cdl b/src/BRepMesh/BRepMesh_Edge.cdl
deleted file mode 100644 (file)
index 36b6c46..0000000
+++ /dev/null
@@ -1,84 +0,0 @@
--- Created on: 1993-09-22
--- Created by: Didier PIFFAULT
--- Copyright (c) 1993-1999 Matra Datavision
--- Copyright (c) 1999-2014 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.
-
-class Edge from BRepMesh 
-
-  ---Purpose: 
-
-
-uses    Boolean from Standard,
-        Integer from Standard,
-        DegreeOfFreedom from BRepMesh
-
-
-is            Create
-              returns Edge from BRepMesh;
-                 ---C++: inline
-                 
-              Create       (vDebut    : Integer from Standard;
-                            vFin      : Integer from Standard;
-                            canMove   : DegreeOfFreedom from BRepMesh)
-              ---Purpose: Contructs a link beetween to vertices.
-              returns Edge from BRepMesh;
-
-
-            FirstNode      (me)
-              ---Purpose: Give the index of first node of the Link.
-              ---C++: inline
-              returns Integer from Standard
-              is static;
-
-
-            LastNode       (me)
-              ---Purpose: Give the index of Last node of the Link.
-              ---C++: inline
-              returns Integer from Standard
-              is static;
-
-
-            Movability     (me)
-              ---C++: inline
-              returns DegreeOfFreedom from BRepMesh
-              is static;
-
-
-            SetMovability  (me   : in out;
-                            Move : DegreeOfFreedom from BRepMesh)
-              is static;
-
-       HashCode       (me;
-                       Upper : Integer from Standard)
-          returns Integer from Standard
-          ---C++: function call
-          is static;
-
-
-        SameOrientation(me; Other : Edge from BRepMesh)
-          returns Boolean from Standard
-          is static;
-
-
-        IsEqual        (me; Other : Edge from BRepMesh)
-          returns Boolean from Standard
-          ---C++: alias operator ==
-          is static;
-
-
-        fields  myFirstNode  : Integer from Standard;
-                myLastNode   : Integer from Standard;
-                myMovability : DegreeOfFreedom from BRepMesh;
-
-        end Edge;
diff --git a/src/BRepMesh/BRepMesh_Edge.cxx b/src/BRepMesh/BRepMesh_Edge.cxx
deleted file mode 100644 (file)
index 0700058..0000000
+++ /dev/null
@@ -1,48 +0,0 @@
-// Created on: 1993-09-23
-// Created by: Didier PIFFAULT
-// Copyright (c) 1993-1999 Matra Datavision
-// Copyright (c) 1999-2014 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 <BRepMesh_Edge.ixx>
-
-BRepMesh_Edge::BRepMesh_Edge(const Standard_Integer vDebut,
-                             const Standard_Integer vFin,
-                             const BRepMesh_DegreeOfFreedom canMove)
-                             : myFirstNode(vDebut), myLastNode(vFin), myMovability(canMove)
-{}
-
-void  BRepMesh_Edge::SetMovability(const BRepMesh_DegreeOfFreedom Move)
-{
-  myMovability =Move;
-}
-
-Standard_Integer  BRepMesh_Edge::HashCode(const Standard_Integer Upper)const 
-{
-  return ::HashCode(myFirstNode+myLastNode, Upper);
-}
-
-Standard_Boolean  BRepMesh_Edge::IsEqual(const BRepMesh_Edge& Other)const 
-{
-  if (myMovability==BRepMesh_Deleted || Other.myMovability==BRepMesh_Deleted)
-    return Standard_False;
-  return (myFirstNode==Other.myFirstNode && myLastNode==Other.myLastNode) ||
-    (myFirstNode==Other.myLastNode && myLastNode==Other.myFirstNode);
-}
-
-
-Standard_Boolean  BRepMesh_Edge::SameOrientation
-(const BRepMesh_Edge& Other)const 
-{
-  return (myFirstNode==Other.myFirstNode && myLastNode==Other.myLastNode);
-}
diff --git a/src/BRepMesh/BRepMesh_Edge.hxx b/src/BRepMesh/BRepMesh_Edge.hxx
new file mode 100644 (file)
index 0000000..603c4cc
--- /dev/null
@@ -0,0 +1,122 @@
+// Copyright (c) 2013 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 _BRepMesh_Edge_HeaderFile
+#define _BRepMesh_Edge_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Macro.hxx>
+#include <BRepMesh_DegreeOfFreedom.hxx>
+
+//! Light weighted structure representing link of the mesh.
+class BRepMesh_Edge
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+  
+  //! Default constructor.
+  Standard_EXPORT BRepMesh_Edge()
+    : myFirstNode (-1),
+      myLastNode  (-1),
+      myMovability(BRepMesh_Deleted)
+  {
+  }
+
+  //! Contructs a link beetween two vertices.
+  Standard_EXPORT BRepMesh_Edge(const Standard_Integer         theFirstNode,
+                                const Standard_Integer         theLastNode,
+                                const BRepMesh_DegreeOfFreedom theMovability)
+    : myFirstNode (theFirstNode),
+      myLastNode  (theLastNode),
+      myMovability(theMovability)
+  {
+  }
+
+  //! Returns index of first node of the Link.
+  inline Standard_Integer FirstNode() const
+  {
+    return myFirstNode;
+  }
+
+  //! Returns index of last node of the Link.
+  inline Standard_Integer LastNode() const
+  {
+    return myLastNode;
+  }
+  
+  //! Returns movability flag of the Link.
+  inline BRepMesh_DegreeOfFreedom Movability() const
+  {
+    return myMovability;
+  }
+  
+  //! Sets movability flag of the Link.
+  //! \param theMovability flag to be set.
+  inline void SetMovability(const BRepMesh_DegreeOfFreedom theMovability)
+  {
+    myMovability = theMovability;
+  }
+  
+  //! Returns hash code for this edge.
+  //! \param theUpper upper index in the container.
+  //! \return hash code.
+  Standard_EXPORT Standard_Integer HashCode(const Standard_Integer theUpper) const
+  {
+    return ::HashCode(myFirstNode + myLastNode, theUpper);
+  }
+  
+  //! Checks if the given edge and this one have the same orientation.
+  //! \param theOther edge to be checked against this one.
+  //! \retrun TRUE if edges have the same orientation, FALSE if not.
+  inline Standard_Boolean IsSameOrientation(const BRepMesh_Edge& theOther) const
+  {
+    return (myFirstNode == theOther.myFirstNode && myLastNode == theOther.myLastNode);
+  }
+  
+  //! Checks for equality with another edge.
+  //! \param theOther edge to be checked against this one.
+  //! \return TRUE if equal, FALSE if not.
+  inline Standard_Boolean IsEqual(const BRepMesh_Edge& theOther) const
+  {
+    if (myMovability          == BRepMesh_Deleted || 
+        theOther.myMovability == BRepMesh_Deleted)
+    {
+      return Standard_False;
+    }
+
+    return IsSameOrientation(theOther) || 
+      (myFirstNode == theOther.myLastNode && myLastNode == theOther.myFirstNode);
+  }
+
+  //! Alias for IsEqual.
+  Standard_Boolean operator ==(const BRepMesh_Edge& Other) const
+  {
+    return IsEqual(Other);
+  }
+
+private:
+
+  Standard_Integer          myFirstNode;
+  Standard_Integer          myLastNode;
+  BRepMesh_DegreeOfFreedom  myMovability;
+};
+
+inline Standard_Integer HashCode(const BRepMesh_Edge&   theEdge,
+                                 const Standard_Integer theUpper)
+{
+  return theEdge.HashCode(theUpper);
+}
+
+#endif
diff --git a/src/BRepMesh/BRepMesh_Edge.lxx b/src/BRepMesh/BRepMesh_Edge.lxx
deleted file mode 100644 (file)
index 17731d3..0000000
+++ /dev/null
@@ -1,38 +0,0 @@
-// Created on: 1993-09-23
-// Created by: Didier PIFFAULT
-// Copyright (c) 1993-1999 Matra Datavision
-// Copyright (c) 1999-2014 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.
-
-inline BRepMesh_Edge::BRepMesh_Edge()
-: myFirstNode(-1),
-  myLastNode(-1),
-  myMovability(BRepMesh_Deleted)
-{
-}
-
-inline Standard_Integer  BRepMesh_Edge::FirstNode()const 
-{
-  return myFirstNode;
-}
-
-inline Standard_Integer  BRepMesh_Edge::LastNode()const 
-{
-  return myLastNode;
-}
-
-inline BRepMesh_DegreeOfFreedom  BRepMesh_Edge::Movability()const 
-{
-  return myMovability;
-}
-
diff --git a/src/BRepMesh/BRepMesh_FaceAttribute.cdl b/src/BRepMesh/BRepMesh_FaceAttribute.cdl
deleted file mode 100644 (file)
index c877588..0000000
+++ /dev/null
@@ -1,81 +0,0 @@
--- Created on: 2008-10-31
--- Created by: EPA
--- Copyright (c) 2008-2014 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.
-
-class FaceAttribute from BRepMesh inherits TShared from MMgt
-
-    ---Purpose: auxiliary class for FastDiscret and FastDiscretFace classes
-
-uses    
-    Real          from Standard,
-    Address       from Standard,
-    ClassifierPtr from BRepMesh
-
-is 
-
-    Create returns FaceAttribute from BRepMesh;
-
-    GetDefFace(me:mutable) returns Real;
-       ---C++: return &
-       ---C++: inline    
-
-    GetUMin(me:mutable) returns Real;
-       ---C++: return &
-       ---C++: inline
-
-    GetVMin(me:mutable) returns Real;
-       ---C++: return &
-       ---C++: inline
-
-    GetUMax(me:mutable) returns Real;
-       ---C++: return &
-       ---C++: inline
-
-    GetVMax(me:mutable) returns Real;
-       ---C++: return &
-       ---C++: inline
-
-    GetDeltaX(me:mutable) returns Real;
-       ---C++: return &
-       ---C++: inline
-
-    GetDeltaY(me:mutable) returns Real;
-       ---C++: return &
-       ---C++: inline
-
-    GetMinX(me:mutable) returns Real;
-       ---C++: return &
-       ---C++: inline
-
-    GetMinY(me:mutable) returns Real;
-       ---C++: return &
-       ---C++: inline
-       
-    GetClassifier(me:mutable) returns ClassifierPtr from BRepMesh;
-       ---C++: return &
-       ---C++: inline
-
-fields  
-    mydefface   : Real          from Standard;
-    myumin      : Real          from Standard;
-    myumax      : Real          from Standard;
-    myvmin      : Real          from Standard;
-    myvmax      : Real          from Standard;
-    mydeltaX    : Real          from Standard;
-    mydeltaY    : Real          from Standard;
-    myminX      : Real          from Standard;
-    myminY      : Real          from Standard;
-    myclassifier: ClassifierPtr from BRepMesh;
-
-end FaceAttribute;
index 121457f..0ce1d9c 100644 (file)
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
-#include <BRepMesh_FaceAttribute.ixx>
+#include <BRepMesh_FaceAttribute.hxx>
+
+IMPLEMENT_STANDARD_HANDLE (BRepMesh_FaceAttribute, Standard_Transient)
+IMPLEMENT_STANDARD_RTTIEXT(BRepMesh_FaceAttribute, Standard_Transient)
 
 //=======================================================================
 //function : BRepMesh_FaceAttribute
diff --git a/src/BRepMesh/BRepMesh_FaceAttribute.hxx b/src/BRepMesh/BRepMesh_FaceAttribute.hxx
new file mode 100644 (file)
index 0000000..bd856b3
--- /dev/null
@@ -0,0 +1,99 @@
+// Copyright (c) 2013 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 _BRepMesh_FaceAttribute_HeaderFile
+#define _BRepMesh_FaceAttribute_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineHandle.hxx>
+#include <BRepMesh_Collections.hxx>
+#include <Standard_Transient.hxx>
+
+
+//! auxiliary class for FastDiscret and FastDiscretFace classes <br>
+class BRepMesh_FaceAttribute : public Standard_Transient
+{
+public:
+
+  Standard_EXPORT BRepMesh_FaceAttribute();
+  
+  inline Standard_Real& GetDefFace()
+  {
+    return mydefface;
+  }
+
+  inline Standard_Real& GetUMin()
+  {
+    return myumin;
+  }
+
+  inline Standard_Real& GetVMin()
+  {
+    return myvmin;
+  }
+
+  inline Standard_Real& GetUMax()
+  {
+    return myumax;
+  }
+
+  inline Standard_Real& GetVMax()
+  {
+    return myvmax;
+  }
+
+  inline Standard_Real& GetDeltaX()
+  {
+    return mydeltaX;
+  }
+
+  inline Standard_Real& GetDeltaY()
+  {
+    return mydeltaY;
+  }
+
+  inline Standard_Real& GetMinX()
+  {
+    return myminX;
+  }
+
+  inline Standard_Real& GetMinY()
+  {
+    return myminY;
+  }
+
+  inline BRepMeshCol::HClassifier& GetClassifier()
+  {
+    return myclassifier;
+  }
+
+
+  DEFINE_STANDARD_RTTI(BRepMesh_FaceAttribute)
+
+private: 
+
+  Standard_Real mydefface;
+  Standard_Real myumin;
+  Standard_Real myumax;
+  Standard_Real myvmin;
+  Standard_Real myvmax;
+  Standard_Real mydeltaX;
+  Standard_Real mydeltaY;
+  Standard_Real myminX;
+  Standard_Real myminY;
+  BRepMeshCol::HClassifier myclassifier;
+};
+
+DEFINE_STANDARD_HANDLE(BRepMesh_FaceAttribute, Standard_Transient)
+
+#endif
diff --git a/src/BRepMesh/BRepMesh_FaceAttribute.lxx b/src/BRepMesh/BRepMesh_FaceAttribute.lxx
deleted file mode 100644 (file)
index 5d71575..0000000
+++ /dev/null
@@ -1,63 +0,0 @@
-// Created by: Ekaterina SMIRNOVA
-// Copyright (c) 2008-2014 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.
-
-inline Standard_Real& BRepMesh_FaceAttribute::GetDefFace()
-{
-  return mydefface;
-}
-
-inline Standard_Real& BRepMesh_FaceAttribute::GetUMin()
-{
-  return myumin;
-}
-
-inline Standard_Real& BRepMesh_FaceAttribute::GetVMin()
-{
-  return myvmin;
-}
-
-inline Standard_Real& BRepMesh_FaceAttribute::GetUMax()
-{
-  return myumax;
-}
-
-inline Standard_Real& BRepMesh_FaceAttribute::GetVMax()
-{
-  return myvmax;
-}
-
-inline Standard_Real& BRepMesh_FaceAttribute::GetDeltaX()
-{
-  return mydeltaX;
-}
-
-inline Standard_Real& BRepMesh_FaceAttribute::GetDeltaY()
-{
-  return mydeltaY;
-}
-
-inline Standard_Real& BRepMesh_FaceAttribute::GetMinX()
-{
-  return myminX;
-}
-
-inline Standard_Real& BRepMesh_FaceAttribute::GetMinY()
-{
-  return myminY;
-}
-
-inline BRepMesh_ClassifierPtr& BRepMesh_FaceAttribute::GetClassifier()
-{
-  return myclassifier;
-}
index 613ceb1..2085079 100644 (file)
@@ -18,6 +18,7 @@
 
 #include <Standard.hxx>
 #include <Standard_Mutex.hxx>
+#include <TopoDS.hxx>
 #include <TopoDS_Face.hxx>
 #include <TopoDS_Edge.hxx>
 #include <TopLoc_Location.hxx>
@@ -66,22 +67,20 @@ public:
       aEdges.push_back(TopoDS::Edge(aEdgeIt.Current()));
 
     BRepMesh_EdgeChecker aEdgeChecker(aFaceT, aFaceLoc, myMutex, myIsFailed);
+#ifdef HAVE_TBB
     if (myIsInParallel)
     {
-    #ifdef HAVE_TBB
       // check faces in parallel threads using TBB
       tbb::parallel_for_each(aEdges.begin(), aEdges.end(), aEdgeChecker);
-    #else
-      // alternative parallelization not yet available
-      for (std::vector<TopoDS_Edge>::iterator it(aEdges.begin()); it != aEdges.end(); it++)
-        aEdgeChecker(*it);
-    #endif
     }
     else
     {
+#endif
       for (std::vector<TopoDS_Edge>::iterator it(aEdges.begin()); it != aEdges.end(); it++)
         aEdgeChecker(*it);
+#ifdef HAVE_TBB
     }
+#endif
   }
 
   //! Returns status of the check.
similarity index 68%
rename from src/BRepMesh/BRepMesh_BaseAllocator.hxx
rename to src/BRepMesh/BRepMesh_FactoryError.hxx
index 1fbdc5b..0be62a2 100644 (file)
@@ -1,4 +1,4 @@
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
+// Copyright (c) 2013 OPEN CASCADE SAS
 //
 // This file is part of Open CASCADE Technology software library.
 //
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
-#include <NCollection_IncAllocator.hxx>
 
-typedef Handle(NCollection_IncAllocator) BRepMesh_BaseAllocator;
+#ifndef _BRepMesh_FactoryError_HeaderFile
+#define _BRepMesh_FactoryError_HeaderFile
+
+enum BRepMesh_FactoryError
+{
+  BRepMesh_FE_NOERROR,
+  BRepMesh_FE_LIBRARYNOTFOUND,
+  BRepMesh_FE_FUNCTIONNOTFOUND,
+  BRepMesh_FE_CANNOTCREATEALGO
+};
+
+#endif
diff --git a/src/BRepMesh/BRepMesh_FastDiscret.cdl b/src/BRepMesh/BRepMesh_FastDiscret.cdl
deleted file mode 100644 (file)
index 340eddc..0000000
+++ /dev/null
@@ -1,351 +0,0 @@
--- Created on: 1996-02-27
--- Created by: Laurent PAINNOT
--- Copyright (c) 1996-1999 Matra Datavision
--- Copyright (c) 1999-2014 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.
-
-class FastDiscret from BRepMesh inherits TShared from MMgt
-
-        ---Purpose: Algorithm  to mesh  a shape  with  respect of  the
-        --          frontier the deflection  and by option the  shared
-        --          components.
-
-
-uses    Boolean                   from Standard,
-        Integer                   from Standard,
-        Box                       from Bnd,
-        Real                      from Standard,
-        Shape                     from TopoDS,
-        Face                      from TopoDS,
-        Edge                      from TopoDS,
-        FaceAttribute             from BRepMesh,
-        Vertex                    from TopoDS,
-        Triangle                  from BRepMesh,
-        Vertex                    from BRepMesh,
-        Edge                      from BRepMesh,
-        ListOfInteger             from TColStd,
-        MapOfInteger              from TColStd,
-        SequenceOfInteger         from TColStd,
-        ListOfReal                from TColStd,
-        IndexedMapOfInteger       from TColStd,
-        SequenceOfPnt2d           from TColgp,
-        Dir                       from gp,
-        Pnt                       from gp,
-        XY                        from gp,
-        Pnt2d                     from gp,
-        DataMapOfIntegerPnt       from BRepMesh,
-        DataMapOfIntegerListOfXY  from BRepMesh,
-        DataMapOfShapePairOfPolygon from  BRepMesh,
-        Delaun                    from BRepMesh,
-        DataMapOfVertexInteger    from BRepMesh,
-        DataStructureOfDelaun     from BRepMesh,
-        ListOfVertex              from BRepMesh,
-        MapOfShape                from TopTools,
-        HSurface                  from BRepAdaptor,
-        ClassifierPtr             from BRepMesh,
-        IndexedMapOfReal          from TColStd,
-        Status                    from BRepMesh,
-        DataMapOfShapeReal        from TopTools,
-        ListOfShape               from TopTools,
-        Curve                     from Geom2d,
-        MapOfInteger              from BRepMesh,
-        BaseAllocator             from BRepMesh,
-        DataMapOfFaceAttribute    from BRepMesh,
-        IndexedDataMapOfShapeListOfShape from TopTools,
-        MutexForShapeProvider     from TopTools,
-        ShapeEnum                 from TopAbs
-
-is
-
-        Create (defle       : Real    from Standard;
-                angle       : Real    from Standard;
-                B           : Box     from Bnd;
-                withShare   : Boolean from Standard=Standard_True;
-                inshape     : Boolean from Standard=Standard_False;
-                relative    : Boolean from Standard=Standard_False;
-                shapetrigu  : Boolean from Standard=Standard_False;
-                isInParallel: Boolean from Standard=Standard_False)
-          returns FastDiscret from BRepMesh;
-
-
-        Create (defle       : Real    from Standard;
-                shape       : Shape   from TopoDS;
-                B           : Box     from Bnd;
-                angle       : Real    from Standard;
-                withShare   : Boolean from Standard=Standard_True;
-                inshape     : Boolean from Standard=Standard_False;
-                relative    : Boolean from Standard=Standard_False;
-                shapetrigu  : Boolean from Standard=Standard_False;
-                isInParallel: Boolean from Standard=Standard_False)
-           ---Purpose: if the  boolean    <relative>   is  True,    the
-           --          deflection used   for the polygonalisation   of
-           --          each edge will be <defle> * Size of Edge.
-           --          the deflection used for the faces will be the maximum
-           --          deflection of their edges.
-           --          
-           --          if <shapetrigu> is True, the triangulation, if exists
-           --          with a correct deflection, can be used to re-triangulate 
-           --          the shape.
-           --          
-           --          if   <inshape>   is   True, the      calculated
-           --          triangulation will be stored in the shape.
-            returns FastDiscret from BRepMesh;
-
-
-        Perform (me: mutable; shape: Shape from TopoDS) is static;
-        ---Purpose: Build triangulation on the whole shape
-
-        Add (me: mutable; face: Face from TopoDS;
-                          ancestor : IndexedDataMapOfShapeListOfShape from TopTools) is static;
-        ---Purpose: Record a face for further processing.
-
-        Process (me; face: Face from TopoDS) is static;
-        ---Purpose: Triangulate a face previously recorded for
-            --          processing by call to Add(). Can be executed in
-            --          parallel threads.
-        ---C++: alias operator ()
-
-        CurrentFaceStatus(me)
-        returns Status from BRepMesh;
-
-        Add (me     : mutable;
-             edge   : Edge     from TopoDS;
-             face   : Face     from TopoDS;
-             S      : HSurface from BRepAdaptor;
-             C      : Curve    from Geom2d;
-             ancestor : IndexedDataMapOfShapeListOfShape from TopTools;
-             defedge: Real     from Standard;
-             first  : Real     from Standard;
-             last   : Real     from Standard)
-        is static private;
-
-        Add (me     : mutable;
-             theVert: Vertex   from TopoDS;
-             face   : Face     from TopoDS;
-             S      : HSurface from BRepAdaptor) is private;
-
-        Update (me: mutable; 
-                Edge   : Edge     from TopoDS; 
-                Face   : Face     from TopoDS; 
-                C      : Curve    from Geom2d;
-                defedge: Real     from Standard;
-                first  : Real     from Standard;
-                last   : Real     from Standard)     
-        returns Boolean is private;
-
-        RelativeEdgeDeflection(myclass;
-                               edge    : Edge    from TopoDS;
-                               defle   : Real    from Standard;
-                               dtotale : Real    from Standard;
-                               cdef    : out Real    from Standard)
-        ---Purpose: Returns computed relative deflection for edge
-          returns Real from Standard;
-
-        BoxMaxDimension(myclass;
-                        box    : in Box from Bnd;
-                        maxdim : out Real from Standard);
-        ---Purpose: Returns the maximal dimension of Bnd_Box
-
-        InternalVertices
-               (me         : mutable;
-               caro       : HSurface            from BRepAdaptor;
-               inter      : in out ListOfVertex from BRepMesh;
-               defedge    : Real                from Standard;
-               classifier : ClassifierPtr       from BRepMesh)
-        is static private;
-
-
-        Control (me      : mutable;
-                 caro    : HSurface                from BRepAdaptor;
-                 defface : Real                    from Standard;
-                 inter   : in out ListOfVertex     from BRepMesh;
-                 badTri  : in out ListOfInteger    from TColStd;
-                 nulTri  : in out ListOfInteger    from TColStd;
-                 trigu   : in out Delaun           from BRepMesh;
-                 isfirst : Boolean                 from Standard)
-          returns Real from Standard is static private;
-
-        AddInShape(me: mutable;
-                   face   : Face from TopoDS;
-                   defedge: Real from Standard)
-        is static private;
-
-        SetParallel (           me : mutable;
-                     theInParallel : Boolean from Standard);
-        ---Purpose:
-        -- Request algorithm to launch in multiple threads
-        -- to improve performance (should be supported by plugin).
-
-        IsParallel (me)
-            returns Boolean from Standard;
-        ---Purpose:
-        -- Returns the multi-threading usage flag.
-        
-        CreateMutexesForSubShapes(me               : mutable;
-                                  theShape : Shape      from TopoDS;
-                                  theType  : ShapeEnum  from TopAbs);
-         ---Purpose:
-         -- Creates mutexes for each sub-shape of type theType in theShape.
-         -- Used to avoid data races.
-                            
-        RemoveAllMutexes(me: mutable);
-        ---Purpose:
-        -- Removes all created mutexes
-
--- Output :
-
-
-        NbTriangles(me)
-            ---Purpose: Gives the number of built triangles.
-            returns Integer from Standard
-            is static;
-
-        Triangle   (me;
-                    Index : Integer from Standard)
-            ---Purpose: Gives the triangle of <Index>.
-            ---C++: return const &
-            returns Triangle from BRepMesh
-            is static;
-
-
-        NbEdges    (me)
-            ---Purpose: Gives the number of built Edges
-            returns Integer from Standard
-            is static;
-
-        Edge       (me;
-                    Index : Integer from Standard)
-            ---Purpose: Gives the edge of index <Index>.
-            ---C++: return const &
-              returns Edge from BRepMesh
-            is static;
-
-        NbVertices (me)
-            ---Purpose: Gives the number of built Vertices.
-            returns Integer from Standard
-            is static;
-
-        Vertex     (me;
-                    Index : Integer from Standard)
-            ---Purpose: Gives the vertex of <Index>.
-            ---C++: return const &
-            returns Vertex from BRepMesh
-            is static;
-
-        Pnt        (me;
-                    Index : Integer from Standard)
-            ---Purpose: Gives the location3d of the vertex of <Index>.
-            ---C++: return const &
-            returns Pnt from gp
-            is static;
-
-        VerticesOfDomain
-                 (me; Indices : in out MapOfInteger from BRepMesh)
-            ---Purpose: Gives the list of indices of the vertices
-            is static;
-
-
-        EdgesOfDomain
-                 (me; Indices : in out MapOfInteger from BRepMesh)
-            ---Purpose: Gives the list of indices of the edges
-            ---C++: inline
-            is static;
-
-
-        TrianglesOfDomain(me; Indices: in out MapOfInteger from BRepMesh)
-            ---Purpose: Gives the list of indices of the triangles
-            ---C++: inline
-            is static;
-
-
-        NbPoint3d (me)
-            ---Purpose: Gives the  number of different  location in 3d
-            --          space.  It  is  different    of the number  of
-            --          vertices if there is more than one surface.
-            --          Even for one surface, the number can be different
-            --          if an edge is shared.
-            ---C++: inline
-            returns Integer from Standard
-            is static;
-
-        Point3d    (me;
-                    Index : Integer from Standard)
-            ---Purpose: Gives the 3d space location of the vertex <Index>.
-            ---C++: return const &
-            ---C++: inline
-            returns Pnt from gp
-            is static;
-
-
-        GetDeflection(me)
-            ---Purpose: returns the deflection value.
-            ---C++: inline
-            returns Real from Standard;
-
-        GetAngle(me)  
-            ---Purpose: returns the deflection value.
-            ---C++: inline
-            returns Real from Standard;
-
-        WithShare(me)
-            ---C++: inline
-            returns Boolean from Standard;
-    
-        InShape(me)
-            ---C++: inline
-            returns Boolean from Standard;
-    
-        ShapeTrigu(me)
-            ---C++: inline
-            returns Boolean from Standard;
-    
-        GetFaceAttribute(me;
-                         face    : Face from TopoDS;
-                         fattrib : in out FaceAttribute from BRepMesh)
-            ---Purpose: returns the face deflection value.
-            returns Boolean from Standard;
-    
-        RemoveFaceAttribute(me   : mutable;
-                            face : Face     from TopoDS);
-            ---Purpose: remove face attribute as useless to free locate memory
-    
-        GetMapOfDefEdge(me)
-            ---C++: return const &
-            ---C++: inline
-            returns DataMapOfShapeReal from TopTools;
-    
-fields  
-      myAngle        : Real                          from Standard;
-      myDeflection   : Real                          from Standard;
-      myDtotale      : Real                          from Standard;
-      myWithShare    : Boolean                       from Standard;
-      myInParallel   : Boolean                       from Standard;
-      myVertices     : DataMapOfVertexInteger        from BRepMesh;
-      myEdges        : DataMapOfShapePairOfPolygon   from BRepMesh;
-      myInternaledges: DataMapOfShapePairOfPolygon   from BRepMesh;
-      myNbLocat      : Integer                       from Standard;
-      myLocation3d   : DataMapOfIntegerPnt           from BRepMesh;
-      myStructure    : DataStructureOfDelaun         from BRepMesh;
-      myMapattrib    : DataMapOfFaceAttribute        from BRepMesh;
-      myVemap        : IndexedMapOfInteger           from TColStd;
-      myLocation2d   : DataMapOfIntegerListOfXY      from BRepMesh;
-      myRelative     : Boolean                       from Standard;
-      myShapetrigu   : Boolean                       from Standard;
-      myInshape      : Boolean                       from Standard; 
-      myFacestate    : Status                        from BRepMesh;
-      myMapdefle     : DataMapOfShapeReal            from TopTools;
-      myNottriangulated : ListOfShape                from TopTools;
-      myAllocator    : BaseAllocator                 from BRepMesh;
-      myMutexProvider: MutexForShapeProvider         from TopTools;
-
-end FastDiscret;
index 9ef6818..87ca40a 100644 (file)
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
-#include <BRepMesh_FastDiscret.ixx>
+#include <BRepMesh_FastDiscret.hxx>
 
+#include <BRepMesh_WireChecker.hxx>
 #include <BRepMesh_FastDiscretFace.hxx>
 #include <BRepMesh_FaceAttribute.hxx>
 #include <BRepMesh_DataStructureOfDelaun.hxx>
-#include <BRepMesh_ClassifierPtr.hxx>
-#include <BRepMesh_Classifier.hxx>
-#include <BRepMesh_WireChecker.hxx>
 #include <BRepMesh_GeomTool.hxx>
 #include <BRepMesh_PairOfPolygon.hxx>
-#include <BRepMesh_DataMapOfShapePairOfPolygon.hxx>
-#include <BRepMesh_DataMapIteratorOfDataMapOfShapePairOfPolygon.hxx>
-#include <Geom_Plane.hxx>
-#include <GeomAbs_IsoType.hxx>
-#include <GeomAbs_SurfaceType.hxx>
-#include <TopAbs.hxx>
-#include <TColStd_HArray1OfReal.hxx>
-#include <Precision.hxx>
-
-#include <BRep_Builder.hxx>
-#include <BRep_Tool.hxx>
-#include <Poly_Triangulation.hxx>
-#include <Poly_PolygonOnTriangulation.hxx>
-#include <Poly_Connect.hxx>
-#include <TColStd_SequenceOfInteger.hxx>
-#include <TColStd_Array1OfInteger.hxx>
-#include <TColStd_HArray1OfInteger.hxx>
-
-#include <TColgp_Array1OfPnt.hxx>
-#include <TColgp_Array1OfPnt2d.hxx>
-#include <Precision.hxx>
+#include <BRepMesh_Classifier.hxx>
+#include <BRepMesh_ShapeTool.hxx>
 
 #include <BRepAdaptor_Curve.hxx>
 #include <BRepAdaptor_Surface.hxx>
 #include <BRepAdaptor_HSurface.hxx>
+
+#include <Bnd_Box.hxx>
 #include <BRepTools.hxx>
-#include <BndLib_Add3dCurve.hxx>
 #include <BRepBndLib.hxx>
-#include <Bnd_Box.hxx>
-#include <TopoDS.hxx>
-#include <TopExp.hxx>
-#include <TopExp_Explorer.hxx>
+#include <BndLib_Add3dCurve.hxx>
+#include <BRep_Tool.hxx>
+#include <Poly_Triangulation.hxx>
+#include <Poly_PolygonOnTriangulation.hxx>
 
+#include <Precision.hxx>
 #include <Geom2d_Curve.hxx>
-
-#include <TColStd_DataMapOfIntegerInteger.hxx>
-#include <BRepMesh_ShapeTool.hxx>
-#include <ElSLib.hxx>
 #include <Geom_Surface.hxx>
-#include <Adaptor3d_IsoCurve.hxx>
-#include <BRepMesh_IndexedMapOfVertex.hxx>
+#include <Geom_Plane.hxx>
+#include <GeomAbs_SurfaceType.hxx>
 #include <Extrema_LocateExtPC.hxx>
 
-#include <BRepMesh_ListOfXY.hxx>
-#include <BRepMesh_ListIteratorOfListOfXY.hxx>
-
 #include <TColStd_Array1OfInteger.hxx>
-#include <Standard_ErrorHandler.hxx>
-#include <Standard_Failure.hxx>
-//#include <TColStd_DataMapOfInteger.hxx>
+#include <TColStd_HArray1OfReal.hxx>
+#include <TColgp_Array1OfPnt.hxx>
+#include <TColgp_Array1OfPnt2d.hxx>
 #include <TColGeom2d_SequenceOfCurve.hxx>
+#include <SortTools_ShellSortOfReal.hxx>
+#include <TCollection_CompareOfReal.hxx>
+
 #include <TopTools_SequenceOfShape.hxx>
+#include <TopTools_ListIteratorOfListOfShape.hxx>
+#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
+
+#include <TopAbs.hxx>
+#include <TopoDS.hxx>
+#include <TopoDS_Vertex.hxx>
+#include <TopExp.hxx>
+#include <TopExp_Explorer.hxx>
+
+#include <Standard_ErrorHandler.hxx>
+#include <Standard_Failure.hxx>
 #include <NCollection_IncAllocator.hxx>
 
 #include <BRep_ListIteratorOfListOfPointRepresentation.hxx>
 #include <BRep_PointRepresentation.hxx>
-#include <BRep_TVertex.hxx>
-#include <TColStd_MapOfInteger.hxx>
-#include <SortTools_ShellSortOfReal.hxx>
-#include <TCollection_CompareOfReal.hxx>
-
-#include <TopTools_HArray1OfShape.hxx>
-#include <TopTools_ListIteratorOfListOfShape.hxx>
 
 #include <vector>
 
 
 #define UVDEFLECTION 1.e-05
 
-inline Standard_Real MaxFaceTol (const TopoDS_Face& theFace)
-{
-  Standard_Real T, TMax = BRep_Tool::Tolerance(theFace);
-  TopExp_Explorer Ex;
-
-  for (Ex.Init(theFace,TopAbs_EDGE); Ex.More(); Ex.Next())
-  {
-    T = BRep_Tool::Tolerance(TopoDS::Edge(Ex.Current()));
-    if (T > TMax) TMax = T;
-  }
-
-  for (Ex.Init(theFace,TopAbs_VERTEX); Ex.More(); Ex.Next())
-  {
-    T = BRep_Tool::Tolerance(TopoDS::Vertex(Ex.Current()));
-    if (T > TMax) TMax = T;
-  }
-
-  return TMax;
-}
-
+IMPLEMENT_STANDARD_HANDLE (BRepMesh_FastDiscret, Standard_Transient)
+IMPLEMENT_STANDARD_RTTIEXT(BRepMesh_FastDiscret, Standard_Transient)
 
 //=======================================================================
 //function : BRepMesh_FastDiscret
@@ -141,7 +104,7 @@ BRepMesh_FastDiscret::BRepMesh_FastDiscret(const Standard_Real    theDefle,
 {
   myAllocator = new NCollection_IncAllocator(64000);
   if(myRelative)
-    BoxMaxDimension(theBox, myDtotale);
+    BRepMesh_ShapeTool::BoxMaxDimension(theBox, myDtotale);
 }
 
 //=======================================================================
@@ -149,10 +112,10 @@ BRepMesh_FastDiscret::BRepMesh_FastDiscret(const Standard_Real    theDefle,
 //purpose  : 
 //=======================================================================
 
-BRepMesh_FastDiscret::BRepMesh_FastDiscret(const Standard_Real    theDefle,
-                                           const TopoDS_Shape&    theShape,
-                                           const Bnd_Box&         theBox,
+BRepMesh_FastDiscret::BRepMesh_FastDiscret(const TopoDS_Shape&    theShape,
+                                           const Standard_Real    theDefle,
                                            const Standard_Real    theAngl,
+                                           const Bnd_Box&         theBox,
                                            const Standard_Boolean theWithShare,
                                            const Standard_Boolean theInshape,
                                            const Standard_Boolean theRelative,
@@ -169,7 +132,7 @@ BRepMesh_FastDiscret::BRepMesh_FastDiscret(const Standard_Real    theDefle,
 {
   myAllocator = new NCollection_IncAllocator(64000);
   if(myRelative)
-    BoxMaxDimension(theBox, myDtotale);
+    BRepMesh_ShapeTool::BoxMaxDimension(theBox, myDtotale);
   Perform(theShape);
 }
 
@@ -192,52 +155,6 @@ Standard_Boolean BRepMesh_FastDiscret::IsParallel() const
 }
 
 //=======================================================================
-//function : BoxMaxDimension
-//purpose  : 
-//=======================================================================
-
-void BRepMesh_FastDiscret::BoxMaxDimension(const Bnd_Box& theBox, Standard_Real& theMaxDim)
-{
-  if(theBox.IsVoid())
-    return;
-  Standard_Real TXmin, TYmin, TZmin, TXmax, TYmax, TZmax;
-  theBox.Get(TXmin, TYmin, TZmin, TXmax, TYmax, TZmax);
-  theMaxDim = TXmax-TXmin;
-  const Standard_Real dy = TYmax-TYmin;
-  const Standard_Real dz = TZmax-TZmin;
-  if (dy > theMaxDim) theMaxDim = dy;
-  if (dz > theMaxDim) theMaxDim = dz;
-}
-
-//=======================================================================
-//function : RelativeEdgeDeflection
-//purpose  : 
-//=======================================================================
-
-Standard_Real BRepMesh_FastDiscret::RelativeEdgeDeflection(const TopoDS_Edge& theEdge,
-                                                                                                  const Standard_Real theDefle,
-                                                                                                    const Standard_Real theDTotale,
-                                                           Standard_Real& theDefCoef)
-{
-  theDefCoef = 1.;
-  Standard_Real defedge = theDefle;
-  if(theEdge.IsNull())
-    return defedge;
-
-  Bnd_Box B;
-  BRepBndLib::Add(theEdge, B);
-  BoxMaxDimension(B, defedge);
-            
-  // adjusted in relation to the total size:
-  theDefCoef = theDTotale/(2*defedge);
-  if (theDefCoef < 0.5) theDefCoef = 0.5;
-  if (theDefCoef > 2.) theDefCoef = 2.;
-  defedge = theDefCoef * defedge * theDefle;
-
-  return defedge;
-}
-
-//=======================================================================
 //function : Perform(shape)
 //purpose  : 
 //=======================================================================
@@ -253,24 +170,22 @@ void BRepMesh_FastDiscret::Perform(const TopoDS_Shape& theShape)
     aFaces.push_back(aF);
   }
 
+#ifdef HAVE_TBB
   if (myInParallel)
   {
-  #ifdef HAVE_TBB
     CreateMutexesForSubShapes(theShape, TopAbs_EDGE);
     // mesh faces in parallel threads using TBB
     tbb::parallel_for_each (aFaces.begin(), aFaces.end(), *this);
-  #else
-    // alternative parallelization not yet available
-    for (std::vector<TopoDS_Face>::iterator it(aFaces.begin()); it != aFaces.end(); it++)
-      Process (*it);
-  #endif
     RemoveAllMutexes();
   }
   else
   {
+#endif
     for (std::vector<TopoDS_Face>::iterator it(aFaces.begin()); it != aFaces.end(); it++)
       Process (*it);
+#ifdef HAVE_TBB
   }
+#endif
 }
 
 
@@ -353,12 +268,12 @@ void BRepMesh_FastDiscret::Add(const TopoDS_Face& theface,
   Standard_Integer nbEdge = 0;
   Standard_Real savangle = myAngle;
   Standard_Real cdef;
-  Standard_Real maxdef = 2.* MaxFaceTol(theface);
+  Standard_Real maxdef = 2.* BRepMesh_ShapeTool::MaxFaceTolerance(theface);
   defface = 0.;
 
   if (!myRelative) defface = Max(myDeflection, maxdef);
 
-  TColStd_SequenceOfReal aFSeq, aLSeq;
+  BRepMeshCol::SequenceOfReal aFSeq, aLSeq;
   TColGeom2d_SequenceOfCurve aCSeq;
   TopTools_SequenceOfShape aShSeq;
 
@@ -380,7 +295,9 @@ void BRepMesh_FastDiscret::Add(const TopoDS_Face& theface,
             defedge = P->Deflection();
           }
           else {
-            defedge = RelativeEdgeDeflection(edge, myDeflection, myDtotale, cdef);
+            defedge = BRepMesh_ShapeTool::RelativeEdgeDeflection(edge, 
+              myDeflection, myDtotale, cdef);
+
             myAngle = savangle * cdef;
           }
           defface = defface + defedge;
@@ -497,7 +414,7 @@ void BRepMesh_FastDiscret::Add(const TopoDS_Face& theface,
     Standard_Integer nbVertices = myVemap.Extent();
     const Standard_Real tolclass = Precision::PConfusion(); //0.03*Max(myumax-myumin, myvmax-myvmin);
     
-    BRepMesh_ClassifierPtr classifier = new BRepMesh_Classifier;
+    BRepMeshCol::HClassifier classifier = new BRepMesh_Classifier;
     {
       BRepMesh_WireChecker aDFaceChecker(face, 
         tolclass, myInternaledges, myVemap, myStructure, 
@@ -694,28 +611,19 @@ void BRepMesh_FastDiscret::Add(const TopoDS_Face& theface,
       Nodes(i) = Pnt(index);
       Nodes2d(i).SetXY(Vertex(index).Coord());
     }
+    BRepMesh_ShapeTool::AddInFace(face, T);
 
-    // storage of triangulation in the BRep.
-    //TopLoc_Location loc = face.Location();
-    if (!loc.IsIdentity()) {
-      gp_Trsf tr = loc.Transformation();
-      tr.Invert();
-      for (i = Nodes.Lower(); i <= Nodes.Upper(); i++) 
-        Nodes(i).Transform(tr);
-    }
-
-    BRep_Builder B;
-    B.UpdateFace(face, T);
-
-    BRepMesh_DataMapIteratorOfDataMapOfShapePairOfPolygon It(myInternaledges);
-    for (; It.More(); It.Next()) {
+    BRepMeshCol::DMapOfShapePairOfPolygon::Iterator It(myInternaledges);
+    for (; It.More(); It.Next())
+    {
+      const TopoDS_Edge& aEdge = TopoDS::Edge(It.Key());
       const BRepMesh_PairOfPolygon& pair = It.Value();
       const Handle(Poly_PolygonOnTriangulation)& NOD1 = pair.First();
       const Handle(Poly_PolygonOnTriangulation)& NOD2 = pair.Last();
       if ( NOD1 == NOD2 )
-        B.UpdateEdge(TopoDS::Edge(It.Key()), NOD1, T, loc);
+        BRepMesh_ShapeTool::UpdateEdge(aEdge, NOD1, T, loc);
       else
-        B.UpdateEdge(TopoDS::Edge(It.Key()), NOD1, NOD2, T, loc);
+        BRepMesh_ShapeTool::UpdateEdge(aEdge, NOD1, NOD2, T, loc);
     }
   }
 
@@ -906,8 +814,8 @@ void BRepMesh_FastDiscret::Add( const TopoDS_Edge&                  theEdge,
 
   Handle(BRepMesh_FaceAttribute) aFaceAttribute;
   GetFaceAttribute ( theFace, aFaceAttribute );
-  theUV = BRepMesh_FastDiscretFace::FindUV(pBegin, uvFirst, 
-    ipf, theGFace, mindist, aFaceAttribute, myLocation2d);
+  theUV = BRepMesh_ShapeTool::FindUV(ipf, uvFirst, 
+    pBegin, mindist, aFaceAttribute, theGFace, myLocation2d);
 
   BRepMesh_Vertex vf(theUV, ipf, BRepMesh_Frontier);
   Standard_Integer ivf = myStructure->AddNode(vf);
@@ -940,8 +848,8 @@ void BRepMesh_FastDiscret::Add( const TopoDS_Edge&                  theEdge,
     }
   }
 
-  theUV = BRepMesh_FastDiscretFace::FindUV(pEnd, uvLast, ipl, 
-    theGFace, mindist, aFaceAttribute, myLocation2d);
+  theUV = BRepMesh_ShapeTool::FindUV(ipl, uvLast,
+    pEnd, mindist, aFaceAttribute, theGFace, myLocation2d);
 
   BRepMesh_Vertex vl(theUV, ipl, BRepMesh_Frontier);
   Standard_Integer ivl= myStructure->AddNode(vl);
@@ -1000,7 +908,7 @@ void BRepMesh_FastDiscret::Add( const TopoDS_Edge&                  theEdge,
       if ( aCurveType == GeomAbs_Circle )
         nbpmin = 4; //OCC287
 
-      BRepMesh_GeomTool GT(cons, wFirst, wLast, 0.5 * myAngle, otherdefedge, nbpmin);
+      BRepMesh_GeomTool GT(cons, wFirst, wLast, otherdefedge, 0.5 * myAngle, nbpmin);
 
       if ( aCurveType == GeomAbs_BSplineCurve )
       {
@@ -1015,7 +923,7 @@ void BRepMesh_FastDiscret::Add( const TopoDS_Edge&                  theEdge,
             const Standard_Real& anEndInt  = anIntervals.Value( aIntIt + 1 );
 
             BRepMesh_GeomTool aDetalizator( cons, aStartInt, anEndInt,
-              0.5 * myAngle, otherdefedge, nbpmin );
+              otherdefedge, 0.5 * myAngle, nbpmin );
 
             Standard_Integer aNbAddNodes = aDetalizator.NbPoints();
             for ( Standard_Integer aNodeIt = 1; aNodeIt <= aNbAddNodes; ++aNodeIt )
@@ -1023,7 +931,7 @@ void BRepMesh_FastDiscret::Add( const TopoDS_Edge&                  theEdge,
               Standard_Real aParam;
               gp_Pnt        aPoint3d;
               gp_Pnt2d      aPoint2d;
-              aDetalizator.Value( cons, theGFace, aNodeIt, aParam, aPoint3d, aPoint2d );
+              aDetalizator.Value( aNodeIt, theGFace, aParam, aPoint3d, aPoint2d );
               GT.AddPoint( aPoint3d, aParam, Standard_False );
             }
           }
@@ -1069,7 +977,7 @@ void BRepMesh_FastDiscret::Add( const TopoDS_Edge&                  theEdge,
           TColStd_Array1OfReal aParamArray(1, nbnodes);
           for (i = 1; i <= nbnodes; i++)
           {          
-            GT.Value(cons, theGFace, i, parf, P3d, uvf);            
+            GT.Value(i, theGFace, parf, P3d, uvf);            
             aParamArray.SetValue(i, parf);
           }
           for (i = 1; i < nbnodes; i++)
@@ -1103,7 +1011,7 @@ void BRepMesh_FastDiscret::Add( const TopoDS_Edge&                  theEdge,
         for (i = 2; i < GT.NbPoints(); i++)
         {
           // Record 3d point
-          GT.Value(cons, theGFace, i, puv, P3d, uv);
+          GT.Value(i, theGFace, puv, P3d, uv);
           myNbLocat++;
           myLocation3d.Bind(myNbLocat, P3d);
           NodInStruct(i) = myNbLocat;
@@ -1304,7 +1212,7 @@ Standard_Boolean BRepMesh_FastDiscret::Update(const TopoDS_Edge&          theEdg
                                               const Standard_Real         theLast)
 {
   TopLoc_Location Loc;
-  Handle(Poly_Triangulation) T, TNull;
+  Handle(Poly_Triangulation) T;
   Handle(Poly_PolygonOnTriangulation) Poly, NullPoly;
 
   Standard_Integer i = 1;
@@ -1404,8 +1312,8 @@ Standard_Boolean BRepMesh_FastDiscret::Update(const TopoDS_Edge&          theEdg
 
         Handle(BRepMesh_FaceAttribute) aFaceAttribute;
         GetFaceAttribute ( theFace, aFaceAttribute );
-        theUV = BRepMesh_FastDiscretFace::FindUV(pBegin, uvFirst, ipf, 
-          gFace, mindist, aFaceAttribute, myLocation2d);
+        theUV = BRepMesh_ShapeTool::FindUV(ipf, uvFirst,
+          pBegin, mindist, aFaceAttribute, gFace, myLocation2d);
 
         BRepMesh_Vertex vf(theUV,ipf,BRepMesh_Frontier);
         iv1 = myStructure->AddNode(vf);
@@ -1442,8 +1350,8 @@ Standard_Boolean BRepMesh_FastDiscret::Update(const TopoDS_Edge&          theEdg
           }
         }
         NewNodInStruct(nbnodes) = ipl;
-        theUV = BRepMesh_FastDiscretFace::FindUV(pEnd, uvLast, ipl, 
-          gFace, mindist, aFaceAttribute, myLocation2d);
+        theUV = BRepMesh_ShapeTool::FindUV(ipl, uvLast,
+          pEnd, mindist, aFaceAttribute, gFace, myLocation2d);
 
         BRepMesh_Vertex vl(theUV,ipl,BRepMesh_Frontier);
         
@@ -1589,16 +1497,14 @@ Standard_Boolean BRepMesh_FastDiscret::Update(const TopoDS_Edge&          theEdg
       }
       else
       {
-        BRep_Builder B;
-        B.UpdateEdge(theEdge,NullPoly,T,Loc);
-        B.UpdateFace(theFace,TNull);
+        BRepMesh_ShapeTool::NullifyEdge(theEdge, T, Loc);
+        BRepMesh_ShapeTool::NullifyFace(theFace);
       }
     }
     else if (!T.IsNull() && !T->HasUVNodes())
     {
-      BRep_Builder B;
-      B.UpdateEdge(theEdge,NullPoly,T,Loc);
-      B.UpdateFace(theFace,TNull);
+      BRepMesh_ShapeTool::NullifyEdge(theEdge, T, Loc);
+      BRepMesh_ShapeTool::NullifyFace(theFace);
     }
   }
   while (!Poly.IsNull());
@@ -1682,15 +1588,15 @@ const gp_Pnt& BRepMesh_FastDiscret::Pnt(const Standard_Integer Index) const
 //purpose  : 
 //=======================================================================
 
-void BRepMesh_FastDiscret::VerticesOfDomain(BRepMesh_MapOfInteger&  Indices) const 
+void BRepMesh_FastDiscret::VerticesOfDomain(BRepMeshCol::MapOfInteger&  Indices) const 
 { 
   Indices.Clear();
   
   // recuperate from the map of edges.
-  const BRepMesh_MapOfInteger& edmap = myStructure->LinkOfDomain();
+  const BRepMeshCol::MapOfInteger& edmap = myStructure->LinksOfDomain();
 
   // iterator on edges.
-  BRepMesh_MapOfInteger::Iterator iter(edmap);
+  BRepMeshCol::MapOfInteger::Iterator iter(edmap);
   
   Standard_Integer ind_edge;
   for (iter.Reset(); iter.More(); iter.Next()) {
diff --git a/src/BRepMesh/BRepMesh_FastDiscret.hxx b/src/BRepMesh/BRepMesh_FastDiscret.hxx
new file mode 100644 (file)
index 0000000..245fa60
--- /dev/null
@@ -0,0 +1,289 @@
+// Copyright (c) 2013 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 _BRepMesh_FastDiscret_HeaderFile
+#define _BRepMesh_FastDiscret_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineHandle.hxx>
+#include <BRepMesh_FastDiscret.hxx>
+#include <BRepMesh_DataStructureOfDelaun.hxx>
+#include <TColStd_IndexedMapOfInteger.hxx>
+#include <BRepMesh_Status.hxx>
+#include <TopTools_DataMapOfShapeReal.hxx>
+#include <TopTools_ListOfShape.hxx>
+#include <TopTools_MutexForShapeProvider.hxx>
+#include <Standard_Transient.hxx>
+#include <Handle_BRepAdaptor_HSurface.hxx>
+#include <Handle_Geom2d_Curve.hxx>
+#include <BRepMesh_Delaun.hxx>
+#include <TopAbs_ShapeEnum.hxx>
+#include <BRepMesh_Triangle.hxx>
+#include <BRepMesh_FaceAttribute.hxx>
+#include <BRepMesh_Collections.hxx>
+
+class BRepMesh_DataStructureOfDelaun;
+class Bnd_Box;
+class TopoDS_Shape;
+class TopoDS_Face;
+class TopTools_IndexedDataMapOfShapeListOfShape;
+class TopoDS_Edge;
+class BRepAdaptor_HSurface;
+class Geom2d_Curve;
+class TopoDS_Vertex;
+class BRepMesh_Edge;
+class BRepMesh_Vertex;
+class gp_Pnt;
+class BRepMesh_FaceAttribute;
+class TopTools_DataMapOfShapeReal;
+
+
+//! Algorithm to mesh a shape with respect of the <br>
+//! frontier the deflection and by option the shared <br>
+//! components. <br>
+class BRepMesh_FastDiscret : public Standard_Transient
+{
+public:
+  
+  Standard_EXPORT BRepMesh_FastDiscret(const Standard_Real defle,
+                                       const Standard_Real angle,
+                                       const Bnd_Box& B,
+                                       const Standard_Boolean withShare = Standard_True,
+                                       const Standard_Boolean inshape = Standard_False,
+                                       const Standard_Boolean relative = Standard_False,
+                                       const Standard_Boolean shapetrigu = Standard_False,
+                                       const Standard_Boolean isInParallel = Standard_False);
+
+  //! if the boolean <relative> is True, the <br>
+  //! deflection used for the polygonalisation of <br>
+  //! each edge will be <defle> * Size of Edge. <br>
+  //! the deflection used for the faces will be the maximum <br>
+  //! deflection of their edges. <br>
+  //! <br>
+  //! if <shapetrigu> is True, the triangulation, if exists <br>
+  //! with a correct deflection, can be used to re-triangulate <br>
+  //! the shape. <br>
+  //! <br>
+  //! if <inshape> is True, the calculated <br>
+  //! triangulation will be stored in the shape. <br>
+  Standard_EXPORT BRepMesh_FastDiscret(const TopoDS_Shape& shape,
+                                       const Standard_Real defle,
+                                       const Standard_Real angle,
+                                       const Bnd_Box& B,
+                                       const Standard_Boolean withShare = Standard_True,
+                                       const Standard_Boolean inshape = Standard_False,
+                                       const Standard_Boolean relative = Standard_False,
+                                       const Standard_Boolean shapetrigu = Standard_False,
+                                       const Standard_Boolean isInParallel = Standard_False);
+
+  //! Build triangulation on the whole shape <br>
+  Standard_EXPORT void Perform(const TopoDS_Shape& shape);
+
+  //! Record a face for further processing. <br>
+  Standard_EXPORT void Add(const TopoDS_Face& face,
+                           const TopTools_IndexedDataMapOfShapeListOfShape& ancestor) ;
+
+  //! Triangulate a face previously recorded for <br>
+  //! processing by call to Add(). Can be executed in <br>
+  //! parallel threads. <br>
+  Standard_EXPORT void Process(const TopoDS_Face& face) const;
+
+  void operator ()(const TopoDS_Face& face) const
+  {
+    Process(face);
+  }
+  
+  Standard_EXPORT BRepMesh_Status CurrentFaceStatus() const;
+  
+  //! Request algorithm to launch in multiple threads <br>
+  //! to improve performance (should be supported by plugin). <br>
+  Standard_EXPORT void SetParallel(const Standard_Boolean theInParallel);
+  
+  //! Returns the multi-threading usage flag. <br>
+  Standard_EXPORT Standard_Boolean IsParallel() const;
+  
+  //! Creates mutexes for each sub-shape of type theType in theShape. <br>
+  //! Used to avoid data races. <br>
+  Standard_EXPORT void CreateMutexesForSubShapes(const TopoDS_Shape& theShape,
+                                                 const TopAbs_ShapeEnum theType);
+  
+  //! Removes all created mutexes <br>
+  Standard_EXPORT void RemoveAllMutexes();
+
+  //! Gives the number of built triangles. <br>
+  Standard_EXPORT Standard_Integer NbTriangles() const;
+
+  //! Gives the triangle of <Index>. <br>
+  Standard_EXPORT const BRepMesh_Triangle& Triangle(const Standard_Integer Index) const;
+
+  //! Gives the number of built Edges <br>
+  Standard_EXPORT Standard_Integer NbEdges() const;
+
+  //! Gives the edge of index <Index>. <br>
+  Standard_EXPORT const BRepMesh_Edge& Edge(const Standard_Integer Index) const;
+
+  //! Gives the number of built Vertices. <br>
+  Standard_EXPORT Standard_Integer NbVertices() const;
+
+  //! Gives the vertex of <Index>. <br>
+  Standard_EXPORT const BRepMesh_Vertex& Vertex(const Standard_Integer Index) const;
+
+  //! Gives the nodes of triangle with the given index.
+  Standard_EXPORT void TriangleNodes(const Standard_Integer theIndex,
+                                     Standard_Integer       (&theNodes)[3]) const
+  {
+    myStructure->ElementNodes(Triangle(theIndex), theNodes);
+  }
+
+  //! Gives the location3d of the vertex of <Index>. <br>
+  Standard_EXPORT const gp_Pnt& Pnt(const Standard_Integer Index) const;
+
+  //! Gives the list of indices of the vertices <br>
+  Standard_EXPORT void VerticesOfDomain(BRepMeshCol::MapOfInteger& Indices) const;
+
+  //! Gives the list of indices of the edges <br>
+  inline void EdgesOfDomain(BRepMeshCol::MapOfInteger& Indices) const
+  { 
+    Indices = myStructure->LinksOfDomain();
+  }
+
+  //! Gives the list of indices of the triangles <br>
+  inline void TrianglesOfDomain(BRepMeshCol::MapOfInteger& Indices) const
+  { 
+    Indices = myStructure->ElementsOfDomain();
+  }
+
+  //! Gives the number of different location in 3d space.  
+  //! It is different of the number of vertices if there 
+  //! is more than one surface. <br>
+  //! Even for one surface, the number can be different
+  //! if an edge is shared. <br>
+  inline Standard_Integer NbPoint3d() const
+  {
+    return myNbLocat;
+  }
+
+  //! Gives the 3d space location of the vertex <Index>. <br>
+  inline const gp_Pnt& Point3d(const Standard_Integer Index) const
+  {
+    return myLocation3d(Index);
+  }
+
+  //! returns the deflection value. <br>
+  inline Standard_Real GetDeflection() const
+  {
+    return myDeflection;
+  }
+
+  //! returns the deflection value. <br>
+  inline Standard_Real GetAngle() const
+  {
+    return myAngle;
+  }
+  
+  inline Standard_Boolean WithShare() const
+  {
+    return myWithShare;
+  }
+  
+  inline Standard_Boolean InShape() const
+  {
+    return myInshape;
+  }
+  
+  inline Standard_Boolean ShapeTrigu() const
+  {
+    return myShapetrigu;
+  }
+
+  //! returns the face deflection value. <br>
+  Standard_EXPORT Standard_Boolean GetFaceAttribute(const TopoDS_Face& face,Handle(BRepMesh_FaceAttribute)& fattrib) const;
+
+  //! remove face attribute as useless to free locate memory <br>
+  Standard_EXPORT void RemoveFaceAttribute(const TopoDS_Face& face);
+  
+  inline const TopTools_DataMapOfShapeReal& GetMapOfDefEdge() const
+  {
+    return myMapdefle;
+  }
+
+
+  DEFINE_STANDARD_RTTI(BRepMesh_FastDiscret)
+
+private: 
+  
+  void Add(const TopoDS_Edge& edge,
+           const TopoDS_Face& face,
+           const Handle(BRepAdaptor_HSurface)& S,
+           const Handle(Geom2d_Curve)& C,
+           const TopTools_IndexedDataMapOfShapeListOfShape& ancestor,
+           const Standard_Real defedge,
+           const Standard_Real first,
+           const Standard_Real last);
+  
+  void Add(const TopoDS_Vertex& theVert,
+           const TopoDS_Face& face,
+           const Handle(BRepAdaptor_HSurface)& S);
+  
+  Standard_Boolean Update(const TopoDS_Edge& Edge,
+                          const TopoDS_Face& Face,
+                          const Handle(Geom2d_Curve)& C,
+                          const Standard_Real defedge,
+                          const Standard_Real first,
+                          const Standard_Real last);
+  
+  void InternalVertices(const Handle(BRepAdaptor_HSurface)& caro,
+                        BRepMeshCol::ListOfVertex& inter,
+                        const Standard_Real defedge,
+                        const BRepMeshCol::HClassifier& classifier);
+  
+  Standard_Real Control(const Handle(BRepAdaptor_HSurface)& caro,
+                        const Standard_Real defface,
+                        BRepMeshCol::ListOfVertex& inter,
+                        BRepMeshCol::ListOfInteger& badTri,
+                        BRepMeshCol::ListOfInteger& nulTri,
+                        BRepMesh_Delaun& trigu,
+                        const Standard_Boolean isfirst);
+  
+  void AddInShape(const TopoDS_Face& face,
+                  const Standard_Real defedge);
+
+private:
+
+  Standard_Real                             myAngle;
+  Standard_Real                             myDeflection;
+  Standard_Real                             myDtotale;
+  Standard_Boolean                          myWithShare;
+  Standard_Boolean                          myInParallel;
+  BRepMeshCol::DMapOfVertexInteger          myVertices;
+  BRepMeshCol::DMapOfShapePairOfPolygon     myEdges;
+  BRepMeshCol::DMapOfShapePairOfPolygon     myInternaledges;
+  Standard_Integer                          myNbLocat;
+  BRepMeshCol::DMapOfIntegerPnt             myLocation3d;
+  Handle_BRepMesh_DataStructureOfDelaun     myStructure;
+  BRepMeshCol::DMapOfFaceAttribute          myMapattrib;
+  TColStd_IndexedMapOfInteger               myVemap;
+  BRepMeshCol::DMapOfIntegerListOfXY        myLocation2d;
+  Standard_Boolean                          myRelative;
+  Standard_Boolean                          myShapetrigu;
+  Standard_Boolean                          myInshape;
+  BRepMesh_Status                           myFacestate;
+  TopTools_DataMapOfShapeReal               myMapdefle;
+  TopTools_ListOfShape                      myNottriangulated;
+  BRepMeshCol::Allocator                    myAllocator;
+  TopTools_MutexForShapeProvider            myMutexProvider;
+};
+
+DEFINE_STANDARD_HANDLE(BRepMesh_FastDiscret, Standard_Transient)
+
+#endif
diff --git a/src/BRepMesh/BRepMesh_FastDiscret.lxx b/src/BRepMesh/BRepMesh_FastDiscret.lxx
deleted file mode 100644 (file)
index 76df6df..0000000
+++ /dev/null
@@ -1,116 +0,0 @@
-// Created on: 2003-09-26
-// Created by: Open CASCADE Support
-// Copyright (c) 2003-2014 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 <BRepMesh_DataStructureOfDelaun.hxx>
-
-//=======================================================================
-//function : GetDeflection
-//purpose  : 
-//=======================================================================
-
-inline Standard_Real BRepMesh_FastDiscret::GetDeflection() const
-{
-  return myDeflection;
-}
-
-//=======================================================================
-//function : GetAngle
-//purpose  : 
-//=======================================================================
-
-inline Standard_Real BRepMesh_FastDiscret::GetAngle() const
-{
-  return myAngle;
-}
-
-//=======================================================================
-//function : GetMapOfDefEdge
-//purpose  : 
-//=======================================================================
-
-inline const TopTools_DataMapOfShapeReal& BRepMesh_FastDiscret::GetMapOfDefEdge() const
-{
-  return myMapdefle;
-}
-
-//=======================================================================
-//function : EdgesOfDomain
-//purpose  : 
-//=======================================================================
-
-inline void BRepMesh_FastDiscret::EdgesOfDomain(BRepMesh_MapOfInteger&  Indices) const 
-{ 
-  Indices = myStructure->LinkOfDomain();
-}
-
-//=======================================================================
-//function : TrianglesOfDomain
-//purpose  : 
-//=======================================================================
-
-inline void BRepMesh_FastDiscret::TrianglesOfDomain(BRepMesh_MapOfInteger&  Indices) const 
-{ 
-  Indices = myStructure->ElemOfDomain();
-}
-
-//=======================================================================
-//function : NbPoint3d
-//purpose  : 
-//=======================================================================
-
-inline Standard_Integer BRepMesh_FastDiscret::NbPoint3d() const
-{
-  return myNbLocat;
-}
-
-//=======================================================================
-//function : Point3d
-//purpose  : 
-//=======================================================================
-
-inline const gp_Pnt& BRepMesh_FastDiscret::Point3d(const Standard_Integer Index) const
-{
-  return myLocation3d(Index);
-}
-
-//=======================================================================
-//function : WithShare
-//purpose  : 
-//=======================================================================
-
-inline Standard_Boolean BRepMesh_FastDiscret::WithShare() const
-{
-  return myWithShare;
-}
-
-//=======================================================================
-//function : InShape
-//purpose  : 
-//=======================================================================
-
-inline Standard_Boolean BRepMesh_FastDiscret::InShape() const
-{
-  return myInshape;
-}
-
-//=======================================================================
-//function : ShapeTrigu
-//purpose  : 
-//=======================================================================
-
-inline Standard_Boolean BRepMesh_FastDiscret::ShapeTrigu() const
-{
-  return myShapetrigu;
-}
diff --git a/src/BRepMesh/BRepMesh_FastDiscretFace.cdl b/src/BRepMesh/BRepMesh_FastDiscretFace.cdl
deleted file mode 100644 (file)
index 0196d50..0000000
+++ /dev/null
@@ -1,170 +0,0 @@
--- Created on: 2008-10-28
--- Copyright (c) 2008-2014 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.
-
-private class FastDiscretFace from BRepMesh inherits TShared from MMgt
-
-        ---Purpose: Algorithm  to mesh  a face  with  respect of  the
-        --          frontier the deflection  and by option the  shared
-        --          components.
-
-
-uses    Boolean                   from Standard,
-        Integer                   from Standard,
-        Real                      from Standard,
-        Face                      from TopoDS,
-        Edge                      from TopoDS,
-        Vertex                    from TopoDS,
-        Pnt                       from gp,
-        Pnt2d                     from gp,
-        XY                        from gp,
-        HSurface                  from BRepAdaptor,
-        Delaun                    from BRepMesh,
-        DataStructureOfDelaun     from BRepMesh,
-        DataMapOfVertexInteger    from BRepMesh,
-        DataMapOfIntegerListOfXY  from BRepMesh,
-        DataMapOfShapeReal        from TopTools,
-        MutexForShapeProvider     from TopTools,
-        ListOfVertex              from BRepMesh,
-        ClassifierPtr             from BRepMesh,
-        Triangle                  from BRepMesh,
-        Edge                      from BRepMesh,
-        Vertex                    from BRepMesh,
-        FaceAttribute             from BRepMesh,
-        ListOfInteger             from TColStd,
-        BaseAllocator             from BRepMesh,
-        DataMapOfIntegerPnt       from BRepMesh,
-        IndexedMapOfInteger       from TColStd,
-        IndexedMapOfReal          from TColStd,
-        DataMapOfShapePairOfPolygon from  BRepMesh,
-        Triangulation             from Poly,
-        Location                  from TopLoc
-
-is 
-
-        Create (theAngle      : Real    from Standard;
-                theWithShare  : Boolean from Standard=Standard_True)
-          returns FastDiscretFace from BRepMesh;
-
-
-
-
-        Add  (me       : mutable;
-              theFace     : Face from TopoDS;
-              theAttrib   : FaceAttribute from BRepMesh;
-              theMapDefle : DataMapOfShapeReal from TopTools;
-              theMutexProvider : MutexForShapeProvider from TopTools)
-          is static;
-
-      
-        Add  (me     : mutable;
-              theVert       : Vertex   from TopoDS;
-              theFace       : Face     from TopoDS;
-              theSFace  : HSurface from BRepAdaptor) is private;
-            
-        RestoreStructureFromTriangulation
-               (me: mutable; 
-                theEdge    : Edge          from TopoDS;
-                theFace    : Face          from TopoDS;
-                theSurf    : HSurface      from BRepAdaptor;
-                theTrigu   : Triangulation from Poly;
-                theDefEdge : Real          from Standard;
-                theLoc     : Location      from TopLoc;
-                theMutexProvider: MutexForShapeProvider from TopTools)
-          returns Boolean from Standard is protected;
-        
-        InternalVertices  (me            : mutable;
-                           theCaro       : HSurface            from BRepAdaptor;
-                           theInternalV  : in out ListOfVertex from BRepMesh;
-                           theDefFace    : Real                from Standard;
-                           theClassifier : ClassifierPtr       from BRepMesh)
-          is static private;
-
-
-        Control  (me      : mutable;
-                  theCaro         : HSurface                from BRepAdaptor;
-                  theDefFace      : Real                    from Standard;
-                  theInternalV    : in out ListOfVertex     from BRepMesh;
-                  theBadTriangles : in out ListOfInteger    from TColStd;
-                  theNulTriangles : in out ListOfInteger    from TColStd;
-                  theTrigu        : in out Delaun           from BRepMesh;
-                  theIsFirst      : Boolean                 from Standard)
-          returns Real from Standard is static;
-
-        FindUV (myclass; 
-                theV            : Vertex                            from TopoDS; 
-                theXY           : Pnt2d                             from gp;
-                theIp           : Integer                           from Standard; 
-                theSFace        : HSurface                          from BRepAdaptor; 
-                theMinDist      : Real                              from Standard;
-                theFaceAttribute: FaceAttribute                     from BRepMesh;
-                theLocation2dMap: in out DataMapOfIntegerListOfXY   from BRepMesh)
-          returns XY from gp;
-
-        AddInShape (me: mutable;
-                    theFace   : Face     from TopoDS;
-                    theDefFace: Real     from Standard;
-                    theMutexProvider: MutexForShapeProvider from TopTools)
-          is static private;
-
-
--- Output :
-
-        Triangle   (me;
-                    theIndex : Integer from Standard)
-        ---Purpose: Gives the triangle of <Index>.
-        ---C++: return const &
-          returns Triangle from BRepMesh
-          is static;
-
-        Edge       (me;
-                    theIndex : Integer from Standard)
-        ---Purpose: Gives the edge of index <Index>.
-        ---C++: return const &
-          returns Edge from BRepMesh
-          is static;
-
-
-        Vertex     (me;
-                    theIndex : Integer from Standard)
-          ---Purpose: Gives the vertex of <Index>.
-          ---C++: return const &
-          returns Vertex from BRepMesh
-          is static;
-
-        Pnt        (me;
-                    theIndex : Integer from Standard)
-          ---Purpose: Gives the location3d of the vertex of <Index>.
-          ---C++: return const &
-          returns Pnt from gp
-          is static;
-
-fields  
-        myAngle         : Real                          from Standard;
-        myWithShare     : Boolean                       from Standard;
-        myVertices      : DataMapOfVertexInteger        from BRepMesh;
-        myInternaledges : DataMapOfShapePairOfPolygon   from BRepMesh;
-        myNbLocat       : Integer                       from Standard;
-        myLocation3d    : DataMapOfIntegerPnt           from BRepMesh;
-        myStructure     : DataStructureOfDelaun         from BRepMesh;
-        myListver       : ListOfVertex                  from BRepMesh;
-        myVemap         : IndexedMapOfInteger           from TColStd;
-        myLocation2d    : DataMapOfIntegerListOfXY      from BRepMesh;
-        myAttrib        : FaceAttribute                 from BRepMesh;
-        myInternalVerticesMode : Boolean                from Standard; --mode to accounting internal vertices 
-        myUParam        : IndexedMapOfReal              from TColStd;
-        myVParam        : IndexedMapOfReal              from TColStd;
-        myAllocator     : BaseAllocator                 from BRepMesh;
-end FastDiscretFace;
index f889017..b2e5f20 100644 (file)
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
-#include <BRepMesh_FastDiscretFace.ixx>
+#include <BRepMesh_FastDiscretFace.hxx>
 
-#include <Adaptor3d_IsoCurve.hxx>
-#include <BRepAdaptor_Curve.hxx>
-#include <BRepMesh_GeomTool.hxx>
-#include <BRepMesh_ListOfXY.hxx>
-#include <BRepMesh_Array1OfVertexOfDelaun.hxx>
-#include <BRepMesh_ListIteratorOfListOfVertex.hxx>
-#include <BRepMesh_ListIteratorOfListOfXY.hxx>
 #include <BRepMesh_PairOfPolygon.hxx>
-#include <BRepMesh_DataMapIteratorOfDataMapOfShapePairOfPolygon.hxx>
-#include <BRep_ListIteratorOfListOfPointRepresentation.hxx>
-#include <BRepMesh_ClassifierPtr.hxx>
 #include <BRepMesh_Classifier.hxx>
-#include <BRep_Builder.hxx>
+#include <BRepMesh_ShapeTool.hxx>
+#include <Poly_PolygonOnTriangulation.hxx>
+#include <Poly_Triangulation.hxx>
+
+#include <BRepAdaptor_Surface.hxx>
+#include <BRepAdaptor_HSurface.hxx>
+#include <BRepAdaptor_Curve.hxx>
+#include <Adaptor3d_IsoCurve.hxx>
+
+#include <BRep_ListIteratorOfListOfPointRepresentation.hxx>
 #include <BRep_PointRepresentation.hxx>
 #include <BRep_TVertex.hxx>
 #include <BRep_Tool.hxx>
-#include <Geom_Surface.hxx>
+
 #include <ElSLib.hxx>
+#include <GeomLib.hxx>
+#include <Geom_Surface.hxx>
+#include <Geom_BSplineSurface.hxx>
+#include <GCPnts_TangentialDeflection.hxx>
+
 #include <Standard_ErrorHandler.hxx>
 #include <Standard_Failure.hxx>
 #include <SortTools_ShellSortOfReal.hxx>
-#include <Poly_PolygonOnTriangulation.hxx>
-#include <Poly_Triangulation.hxx>
 #include <TCollection_CompareOfReal.hxx>
 #include <TColStd_Array1OfReal.hxx>
+#include <TColStd_ListOfInteger.hxx>
 #include <TColStd_SequenceOfReal.hxx>
 #include <TColStd_Array1OfInteger.hxx>
 #include <TColStd_HArray1OfReal.hxx>
+#include <TColgp_Array1OfPnt2d.hxx>
+#include <TopTools_DataMapOfShapeReal.hxx>
+
 #include <TopExp_Explorer.hxx>
 #include <TopoDS.hxx>
+#include <TopoDS_Vertex.hxx>
 #include <TopExp.hxx>
-#include <TColgp_Array1OfPnt2d.hxx>
+
 #include <NCollection_Map.hxx>
-#include <Geom_BSplineSurface.hxx>
-#include <GeomLib.hxx>
 #include <Bnd_Box2d.hxx>
 
 #define UVDEFLECTION 1.e-05
 
+IMPLEMENT_STANDARD_HANDLE (BRepMesh_FastDiscretFace, Standard_Transient)
+IMPLEMENT_STANDARD_RTTIEXT(BRepMesh_FastDiscretFace, Standard_Transient)
+
 static Standard_Real FUN_CalcAverageDUV(TColStd_Array1OfReal& P, const Standard_Integer PLen)
 {
   Standard_Integer i, j, n = 0;
@@ -169,7 +177,8 @@ void BRepMesh_FastDiscretFace::Add(const TopoDS_Face&                    theFace
         const TopoDS_Edge& edge = TopoDS::Edge(ex.Value());
         if(edge.IsNull())
           continue;
-        RestoreStructureFromTriangulation(edge, face, gFace, aFaceTrigu, theMapDefle(edge), loc, theMutexProvider);
+        RestoreStructureFromTriangulation(edge, face, gFace, aFaceTrigu, 
+          theMapDefle(edge), loc, theMutexProvider);
       }
     }
     
@@ -195,7 +204,7 @@ void BRepMesh_FastDiscretFace::Add(const TopoDS_Face&                    theFace
     Standard_Real deltaX = myAttrib->GetDeltaX();
     Standard_Real deltaY = myAttrib->GetDeltaY();
     
-    TColStd_Array1OfInteger tabvert_corr(1, nbVertices);
+    BRepMeshCol::Array1OfInteger tabvert_corr(1, nbVertices);
     gp_Pnt2d p2d;
     
     // Check the necessity to fill the map of parameters
@@ -222,7 +231,7 @@ void BRepMesh_FastDiscretFace::Add(const TopoDS_Face&                    theFace
       res.SetCoord((p2d.X() - umin ) / deltaX,
                    (p2d.Y() - vmin ) / deltaY);
       BRepMesh_Vertex v_new(res,v.Location3d(),v.Movability());
-      const BRepMesh_ListOfInteger& alist = myStructure->GetNodeList(i);
+      const BRepMeshCol::ListOfInteger& alist = myStructure->LinksConnectedTo(i);
       aMoveNodes.Add(v_new, alist);
       tabvert_corr(i) = i;
     }
@@ -230,7 +239,7 @@ void BRepMesh_FastDiscretFace::Add(const TopoDS_Face&                    theFace
     
     Standard_Boolean rajout;
     
-    BRepMesh_ClassifierPtr& classifier = theAttrib->GetClassifier();
+    BRepMeshCol::HClassifier& classifier = theAttrib->GetClassifier();
 
     switch (thetype)
     {
@@ -248,7 +257,7 @@ void BRepMesh_FastDiscretFace::Add(const TopoDS_Face&                    theFace
     Standard_Integer nbLinks = myStructure->NbLinks();
     for( i = 1; i <= nbLinks; i++ ) 
     {
-      if( myStructure->ElemConnectedTo(i).Extent() < 1 )
+      if( myStructure->ElementsConnectedTo(i).Extent() < 1 )
       {
         BRepMesh_Edge& anEdge = (BRepMesh_Edge&)trigu.GetEdge(i);
         if ( anEdge.Movability() == BRepMesh_Deleted )
@@ -263,8 +272,8 @@ void BRepMesh_FastDiscretFace::Add(const TopoDS_Face&                    theFace
     isaline = ((umax-umin) < UVDEFLECTION) || ((vmax-vmin) < UVDEFLECTION);
     
     Standard_Real aDef = -1;
-    if (!isaline && myStructure->ElemOfDomain().Extent() > 0) {
-      TColStd_ListOfInteger badTri, nulTri;
+    if (!isaline && myStructure->ElementsOfDomain().Extent() > 0) {
+      BRepMeshCol::ListOfInteger badTri, nulTri;
       
       if(!rajout)
       {
@@ -292,15 +301,15 @@ void BRepMesh_FastDiscretFace::Add(const TopoDS_Face&                    theFace
         InternalVertices(gFace, myListver, theAttrib->GetDefFace(), classifier);
         
         if (myListver.Extent() > 0) {
-          BRepMesh_Array1OfVertexOfDelaun verttab(1, myListver.Extent());
-          BRepMesh_ListIteratorOfListOfVertex itVer(myListver);
+          BRepMeshCol::Array1OfVertexOfDelaun verttab(1, myListver.Extent());
+          BRepMeshCol::ListOfVertex::Iterator itVer(myListver);
           ipn = 1;
           for (; itVer.More(); itVer.Next())
             verttab(ipn++) = itVer.Value();
           trigu.AddVertices(verttab);
         }
         //control internal points
-        BRepMesh_ListOfVertex vvlist;
+        BRepMeshCol::ListOfVertex vvlist;
         aDef = Control(gFace, theAttrib->GetDefFace(), vvlist, badTri, nulTri, trigu, Standard_False);
         myListver.Append(vvlist);
       }
@@ -316,7 +325,7 @@ void BRepMesh_FastDiscretFace::Add(const TopoDS_Face&                    theFace
       gp_XY res;
       res.SetCoord(p2d.X() * deltaX + umin, p2d.Y() * deltaY + vmin);
       BRepMesh_Vertex v_new(res,v.Location3d(),v.Movability());
-      const BRepMesh_ListOfInteger& alist = myStructure->GetNodeList(i);
+      const BRepMeshCol::ListOfInteger& alist = myStructure->LinksConnectedTo(i);
       aMoveNodes.Add(v_new, alist);
     }
     myStructure->ReplaceNodes(aMoveNodes);
@@ -326,9 +335,7 @@ void BRepMesh_FastDiscretFace::Add(const TopoDS_Face&                    theFace
   }
   catch(Standard_Failure)
   {
-    BRep_Builder B;
-    Handle(Poly_Triangulation) TNull;
-    B.UpdateFace(theFace,TNull);
+    BRepMesh_ShapeTool::NullifyFace(theFace);
   }
 #endif // DEB_MESH
   myStructure.Nullify();
@@ -418,7 +425,9 @@ Standard_Boolean BRepMesh_FastDiscretFace::RestoreStructureFromTriangulation
   if (mindist < BRep_Tool::Tolerance(pBegin) ||
       mindist < BRep_Tool::Tolerance(pEnd) ) mindist = theDefEdge;
   
-  anUV = FindUV(pBegin, uvFirst, ipf, theSurf, mindist, myAttrib, myLocation2d);
+  anUV = BRepMesh_ShapeTool::FindUV(ipf, uvFirst,
+    pBegin, mindist, myAttrib, theSurf, myLocation2d);
+
   Standard_Integer iv1, isv1;
   BRepMesh_Vertex vf(anUV, ipf, BRepMesh_Frontier);
   iv1 = myStructure->AddNode(vf);
@@ -459,7 +468,9 @@ Standard_Boolean BRepMesh_FastDiscretFace::RestoreStructureFromTriangulation
     }
   }
 
-  anUV = FindUV(pEnd, uvLast, ipl, theSurf, mindist, myAttrib, myLocation2d);
+  anUV = BRepMesh_ShapeTool::FindUV(ipl, uvLast,
+    pEnd, mindist, myAttrib, theSurf, myLocation2d);
+
   BRepMesh_Vertex vl(anUV, ipl, BRepMesh_Frontier);
   
   Standard_Integer isvl;
@@ -538,13 +549,13 @@ Standard_Boolean BRepMesh_FastDiscretFace::RestoreStructureFromTriangulation
 //purpose  : 
 //=======================================================================
 
-static void filterParameters(const TColStd_IndexedMapOfReal& theParams,
-                             const Standard_Real theMinDist,
-                             const Standard_Real theFilterDist,
-                             TColStd_SequenceOfReal& theResult)
+static void filterParameters(const BRepMeshCol::IMapOfReal& theParams,
+                             const Standard_Real            theMinDist,
+                             const Standard_Real            theFilterDist,
+                             BRepMeshCol::SequenceOfReal&   theResult)
 {
   // Sort sequence of parameters
-  TColStd_SequenceOfReal aParamTmp;
+  BRepMeshCol::SequenceOfReal aParamTmp;
   Standard_Integer aParamLength = 1;
   const Standard_Integer anInitLen = theParams.Extent();
     
@@ -633,9 +644,9 @@ static void filterParameters(const TColStd_IndexedMapOfReal& theParams,
 }
 
 void BRepMesh_FastDiscretFace::InternalVertices(const Handle(BRepAdaptor_HSurface)& theCaro,
-                                                BRepMesh_ListOfVertex&              theInternalV,
+                                                BRepMeshCol::ListOfVertex&          theInternalV,
                                                 const Standard_Real                 theDefFace,
-                                                const BRepMesh_ClassifierPtr&       theClassifier)
+                                                const BRepMeshCol::HClassifier&       theClassifier)
 {
   BRepMesh_Vertex newV;
   gp_Pnt2d p2d;
@@ -779,7 +790,7 @@ void BRepMesh_FastDiscretFace::InternalVertices(const Handle(BRepAdaptor_HSurfac
     Standard_Real pp, pasu, pasv;
     Standard_Real r = T.MinorRadius(), R = T.MajorRadius();
 
-    TColStd_SequenceOfReal ParamU, ParamV;
+    BRepMeshCol::SequenceOfReal ParamU, ParamV;
 
     Standard_Real Du, Dv;//, pasu, pasv;
     Dv = Max(1.0e0 - (theDefFace/r),0.0e0) ;
@@ -913,7 +924,7 @@ void BRepMesh_FastDiscretFace::InternalVertices(const Handle(BRepAdaptor_HSurfac
 
     Standard_Real aDuMaxLim = 0.1*(umax-umin);
     Standard_Real ddu = Min(aDuMaxLim,Max(0.005*(umax-umin),2.*uRes));
-    TColStd_SequenceOfReal ParamU; 
+    BRepMeshCol::SequenceOfReal ParamU; 
     filterParameters(myUParam,aMinDu,ddu,ParamU);
     Standard_Integer ParamULength = ParamU.Length();
    
@@ -923,7 +934,7 @@ void BRepMesh_FastDiscretFace::InternalVertices(const Handle(BRepAdaptor_HSurfac
 
     Standard_Real aDvMaxLim = 0.1*(vmax-vmin);
     Standard_Real ddv = Min(aDvMaxLim,Max(0.005*(vmax-vmin),2.*vRes));
-    TColStd_SequenceOfReal ParamV; 
+    BRepMeshCol::SequenceOfReal ParamV; 
     filterParameters(myVParam,aMinDv,ddv,ParamV);
     Standard_Integer ParamVLength = ParamV.Length();
 
@@ -1052,7 +1063,7 @@ void BRepMesh_FastDiscretFace::InternalVertices(const Handle(BRepAdaptor_HSurfac
     Standard_Integer i, j, nbpointsU = 10, nbpointsV = 10;
     Adaptor3d_IsoCurve tabu[11], tabv[11];
 
-    TColStd_SequenceOfReal ParamU, ParamV;
+    BRepMeshCol::SequenceOfReal ParamU, ParamV;
     Standard_Real u, v, du, dv;
     Standard_Integer iu, iv;
     Standard_Real f, l;
@@ -1123,7 +1134,7 @@ void BRepMesh_FastDiscretFace::InternalVertices(const Handle(BRepAdaptor_HSurfac
       ParamV.InsertAfter(1, (vmax+vmin)*0.5);
     }
     
-    TColStd_SequenceOfReal InsertV, InsertU;
+    BRepMeshCol::SequenceOfReal InsertV, InsertU;
     gp_Pnt P1;
 
     Adaptor3d_IsoCurve IsoV;
@@ -1193,9 +1204,9 @@ typedef NCollection_Map<BRepMesh_Couple> BRepMesh_MapOfCouple;
 //=======================================================================
 Standard_Real BRepMesh_FastDiscretFace::Control(const Handle(BRepAdaptor_HSurface)& theCaro,
                                                 const Standard_Real                 theDefFace,
-                                                BRepMesh_ListOfVertex&              theInternalV,
-                                                TColStd_ListOfInteger&              theBadTriangles,
-                                                TColStd_ListOfInteger&              theNulTriangles,
+                                                BRepMeshCol::ListOfVertex&          theInternalV,
+                                                BRepMeshCol::ListOfInteger&         theBadTriangles,
+                                                BRepMeshCol::ListOfInteger&         theNulTriangles,
                                                 BRepMesh_Delaun&                    theTrigu,
                                                 const Standard_Boolean              theIsFirst)
 {
@@ -1214,7 +1225,7 @@ Standard_Real BRepMesh_FastDiscretFace::Control(const Handle(BRepAdaptor_HSurfac
   // Create map of links to skip already processed
   Standard_Integer nbtriangles;
 
-  nbtriangles = myStructure->ElemOfDomain().Extent();
+  nbtriangles = myStructure->ElementsOfDomain().Extent();
   if (nbtriangles <= 0) return -1.0;
   BRepMesh_MapOfCouple theCouples(3*nbtriangles);
 
@@ -1241,7 +1252,7 @@ Standard_Real BRepMesh_FastDiscretFace::Control(const Handle(BRepAdaptor_HSurfac
   }
 
   NCollection_DataMap<Standard_Integer,gp_Dir> aNorMap;
-  NCollection_DataMap<Standard_Integer,Standard_Integer> aStatMap;
+  BRepMeshCol::MapOfIntegerInteger aStatMap;
 
   // Perform refinement passes
   for (; pass <= nbPasses && nbInserted && !allDegenerated; pass++)
@@ -1258,12 +1269,12 @@ Standard_Real BRepMesh_FastDiscretFace::Control(const Handle(BRepAdaptor_HSurfac
     caninsert = (myWithShare || pass < nbPasses);
 
     // Read mesh size
-    nbtriangles = myStructure->ElemOfDomain().Extent();
+    nbtriangles = myStructure->ElementsOfDomain().Extent();
     if (nbtriangles <= 0) break;
 
     // Iterate on current triangles
-    BRepMesh_MapOfInteger::Iterator triDom;
-    const BRepMesh_MapOfInteger& TriMap = myStructure->ElemOfDomain();
+    BRepMeshCol::MapOfInteger::Iterator triDom;
+    const BRepMeshCol::MapOfInteger& TriMap = myStructure->ElementsOfDomain();
     triDom.Initialize(TriMap);
     Standard_Integer aNbPnt = 0;
     Standard_Real umin = myAttrib->GetUMin();
@@ -1276,33 +1287,20 @@ Standard_Real BRepMesh_FastDiscretFace::Control(const Handle(BRepAdaptor_HSurfac
       const BRepMesh_Triangle& curTri=Triangle(TriId);
       if (curTri.Movability()==BRepMesh_Deleted) continue;
       
-      Standard_Boolean o1, o2, o3;
-      Standard_Integer v1 = 0, v2 = 0, v3 = 0, e1 = 0, e2 = 0, e3 = 0;
-      curTri.Edges(e1, e2, e3, o1, o2, o3);
-      
-      const BRepMesh_Edge& edg1=Edge(e1);
-      const BRepMesh_Edge& edg2=Edge(e2);
-      const BRepMesh_Edge& edg3=Edge(e3);
+      Standard_Integer v[3];
+      myStructure->ElementNodes(curTri, v);
+
+      Standard_Integer e[3];
+      Standard_Boolean o[3];
+      curTri.Edges(e, o);
       
-      Standard_Boolean m1 = (edg1.Movability() == BRepMesh_Frontier);
-      Standard_Boolean m2 = (edg2.Movability() == BRepMesh_Frontier);
-      Standard_Boolean m3 = (edg3.Movability() == BRepMesh_Frontier);
-      if (o1) {
-        v1=edg1.FirstNode();
-        v2=edg1.LastNode();
-      }
-      else {
-        v1=edg1.LastNode();
-        v2=edg1.FirstNode();
-      }
-      if (o2)
-        v3=edg2.LastNode();
-      else
-        v3=edg2.FirstNode();
+      Standard_Boolean m1 = (Edge(e[0]).Movability() == BRepMesh_Frontier);
+      Standard_Boolean m2 = (Edge(e[1]).Movability() == BRepMesh_Frontier);
+      Standard_Boolean m3 = (Edge(e[2]).Movability() == BRepMesh_Frontier);
 
-      const BRepMesh_Vertex& vert1=Vertex(v1);
-      const BRepMesh_Vertex& vert2=Vertex(v2);
-      const BRepMesh_Vertex& vert3=Vertex(v3);
+      const BRepMesh_Vertex& vert1=Vertex(v[0]);
+      const BRepMesh_Vertex& vert2=Vertex(v[1]);
+      const BRepMesh_Vertex& vert3=Vertex(v[2]);
 
       const gp_XYZ& p1=myLocation3d(vert1.Location3d()).Coord();
       const gp_XYZ& p2=myLocation3d(vert2.Location3d()).Coord();
@@ -1372,7 +1370,7 @@ Standard_Real BRepMesh_FastDiscretFace::Control(const Handle(BRepAdaptor_HSurfac
       if (!m2) // Not a boundary
       {
         // Check if this link was already processed
-        if (v2 < v3) { nf = v2; nl = v3; } else { nf = v3; nl = v2; }
+        if (v[1] < v[2]) { nf = v[1]; nl = v[2]; } else { nf = v[2]; nl = v[1]; }
         if (theCouples.Add(BRepMesh_Couple(nf,nl)))
         {
           // Check deflection on edge 1
@@ -1402,7 +1400,7 @@ Standard_Real BRepMesh_FastDiscretFace::Control(const Handle(BRepAdaptor_HSurfac
       if (!m3) // Not a boundary
       {
         // Check if this link was already processed
-        if (v1 < v3) { nf = v1; nl = v3; } else { nf = v3; nl = v1; }
+        if (v[0] < v[2]) { nf = v[0]; nl = v[2]; } else { nf = v[2]; nl = v[0]; }
         if (theCouples.Add(BRepMesh_Couple(nf,nl)))
         {
           // Check deflection on edge 2
@@ -1432,7 +1430,7 @@ Standard_Real BRepMesh_FastDiscretFace::Control(const Handle(BRepAdaptor_HSurfac
       if (!m1) // Not a boundary
       {
         // Check if this link was already processed
-        if (v1 < v2) { nf = v1; nl = v2; } else { nf = v2; nl = v1; }
+        if (v[0] < v[1]) { nf = v[0]; nl = v[1]; } else { nf =