EIC code displayed by LXR master/​include/​opencascade/​BRepMesh_VertexTool.hxx	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-09-18 09:19:53

 // 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_VertexTool_HeaderFile
 #define _BRepMesh_VertexTool_HeaderFile
 
 #include <Standard_Transient.hxx>
 #include <BRepMesh_VertexInspector.hxx>
 #include <Standard_OStream.hxx>
 #include <gp_XY.hxx>
 #include <IMeshData_Types.hxx>
 
 //! Describes data structure intended to keep mesh nodes
 //! defined in UV space and implements functionality
 //! providing their uniqueness regarding their position.
 class BRepMesh_VertexTool : public Standard_Transient
 {
 public:
   //! Constructor.
   //! @param theAllocator memory allocator to be used by internal collections.
   Standard_EXPORT BRepMesh_VertexTool(const occ::handle<NCollection_IncAllocator>& theAllocator);
 
   //! Sets new size of cell for cellfilter equal in both directions.
   void SetCellSize(const double theSize)
   {
     myCellFilter.Reset(theSize, myAllocator);
     mySelector.Clear();
   }
 
   //! Sets new size of cell for cellfilter.
   //! @param theSizeX size for X dimension.
   //! @param theSizeY size for Y dimension.
   void SetCellSize(const double theSizeX, const double theSizeY)
   {
     double                     aCellSizeC[2] = {theSizeX, theSizeY};
     NCollection_Array1<double> aCellSize(aCellSizeC[0], 1, 2);
     myCellFilter.Reset(aCellSize, myAllocator);
     mySelector.Clear();
   }
 
   //! Sets the tolerance to be used for identification of
   //! coincident vertices equal for both dimensions.
   void SetTolerance(const double theTolerance)
   {
     mySelector.SetTolerance(theTolerance);
     myTolerance[0] = theTolerance;
     myTolerance[1] = theTolerance;
   }
 
   //! Sets the tolerance to be used for identification of
   //! coincident vertices.
   //! @param theToleranceX tolerance for X dimension.
   //! @param theToleranceY tolerance for Y dimension.
   void SetTolerance(const double theToleranceX, const double theToleranceY)
   {
     mySelector.SetTolerance(theToleranceX, theToleranceY);
     myTolerance[0] = theToleranceX;
     myTolerance[1] = theToleranceY;
   }
 
   //! Gets the tolerance to be used for identification of
   //! coincident vertices.
   //! @param theToleranceX tolerance for X dimension.
   //! @param theToleranceY tolerance for Y dimension.
   void GetTolerance(double& theToleranceX, double& theToleranceY)
   {
     theToleranceX = myTolerance[0];
     theToleranceY = myTolerance[1];
   }
 
   //! Adds vertex with empty data to the tool.
   //! @param theVertex node to be added to the mesh.
   //! @param isForceAdd adds the given node to structure without
   //! checking on coincidence with other nodes.
   //! @return index of the node in the structure.
   Standard_EXPORT int Add(const BRepMesh_Vertex& theVertex, const bool isForceAdd);
 
   //! Deletes vertex with the given index from the tool.
   Standard_EXPORT void DeleteVertex(const int theIndex);
 
   //! Returns set of mesh vertices.
   const Handle(IMeshData::VectorOfVertex)& Vertices() const { return mySelector.Vertices(); }
 
   //! Returns set of mesh vertices.
   Handle(IMeshData::VectorOfVertex)& ChangeVertices() { return mySelector.ChangeVertices(); }
 
   //! Returns vertex by the given index.
   const BRepMesh_Vertex& FindKey(const int theIndex) { return mySelector.GetVertex(theIndex); }
 
   //! Returns index of the given vertex.
   int FindIndex(const BRepMesh_Vertex& theVertex)
   {
     mySelector.SetPoint(theVertex.Coord());
     myCellFilter.Inspect(theVertex.Coord(), mySelector);
     return mySelector.GetCoincidentPoint();
   }
 
   //! Returns a number of vertices.
   int Extent() const { return mySelector.NbVertices(); }
 
   //! Returns True when the map contains no keys.
   bool IsEmpty() const { return (Extent() == 0); }
 
   //! Substitutes vertex with the given by the given vertex with attributes.
   //! @param theIndex index of vertex to be substituted.
   //! @param theVertex replacement vertex.
   Standard_EXPORT void Substitute(const int theIndex, const BRepMesh_Vertex& theVertex);
 
   //! Remove last node from the structure.
   void RemoveLast() { DeleteVertex(Extent()); }
 
   //! Returns the list with indexes of vertices that have movability attribute
   //! equal to BRepMesh_Deleted and can be replaced with another node.
   const IMeshData::ListOfInteger& GetListOfDelNodes() const
   {
     return mySelector.GetListOfDelPoints();
   }
 
   DEFINE_STANDARD_RTTIEXT(BRepMesh_VertexTool, Standard_Transient)
 
 private:
   //! Expands the given point according to specified tolerance.
   //! @param thePoint point to be expanded.
   //! @param[out] theMinPoint bottom left corner of area defined by expanded point.
   //! @param[out] theMaxPoint top right corner of area defined by expanded point.
   void expandPoint(const gp_XY& thePoint, gp_XY& theMinPoint, gp_XY& theMaxPoint)
   {
     theMinPoint.SetX(thePoint.X() - myTolerance[0]);
     theMinPoint.SetY(thePoint.Y() - myTolerance[1]);
     theMaxPoint.SetX(thePoint.X() + myTolerance[0]);
     theMaxPoint.SetY(thePoint.Y() + myTolerance[1]);
   }
 
 private:
   occ::handle<NCollection_IncAllocator> myAllocator;
   IMeshData::VertexCellFilter           myCellFilter;
   BRepMesh_VertexInspector              mySelector;
   double                                myTolerance[2];
 };
 
 #endif

This page was automatically generated by the 2.3.7 LXR engine. The LXR team