netgen-mesher 6.2.2506.post35.dev0__cp314-cp314-win_amd64.whl

netgen/include/nglib_occ.h

@@ -0,0 +1,50 @@
+#ifndef NGLIB_OCC_HPP_INCLUDED
+#define NGLIB_OCC_HPP_INCLUDED
+
+/// Data type for NETGEN OpenCascade geometry
+typedef void * Ng_OCC_Geometry;
+typedef void * Ng_OCC_TopTools_IndexedMapOfShape;
+
+// **********************************************************
+// **   OpenCascade Geometry / Meshing Utilities           **
+// **********************************************************
+
+// Create new OCC Geometry Object
+NGLIB_API Ng_OCC_Geometry * Ng_OCC_NewGeometry ();
+
+// Delete an OCC Geometry Object
+NGLIB_API Ng_Result Ng_OCC_DeleteGeometry (Ng_OCC_Geometry * geom);
+
+// Loads geometry from STEP file
+NGLIB_API Ng_OCC_Geometry * Ng_OCC_Load_STEP (const char * filename);
+
+// Loads geometry from IGES file
+NGLIB_API Ng_OCC_Geometry * Ng_OCC_Load_IGES (const char * filename);
+
+// Loads geometry from BREP file
+NGLIB_API Ng_OCC_Geometry * Ng_OCC_Load_BREP (const char * filename);
+
+// Set the local mesh size based on geometry / topology
+NGLIB_API Ng_Result Ng_OCC_SetLocalMeshSize (Ng_OCC_Geometry * geom,
+                                              Ng_Mesh * mesh,
+                                              Ng_Meshing_Parameters * mp);
+
+// Mesh the edges and add Face descriptors to prepare for surface meshing
+NGLIB_API Ng_Result Ng_OCC_GenerateEdgeMesh (Ng_OCC_Geometry * geom,
+                                              Ng_Mesh * mesh,
+                                              Ng_Meshing_Parameters * mp);
+
+// Mesh the surfaces of an OCC geometry
+NGLIB_API Ng_Result Ng_OCC_GenerateSurfaceMesh (Ng_OCC_Geometry * geom,
+                                                 Ng_Mesh * mesh,
+                                                 Ng_Meshing_Parameters * mp);
+
+// Get the face map of an already loaded OCC geometry
+NGLIB_API Ng_Result Ng_OCC_GetFMap(Ng_OCC_Geometry * geom,
+                                    Ng_OCC_TopTools_IndexedMapOfShape * FMap);
+
+NGLIB_API void Ng_OCC_Uniform_Refinement (Ng_OCC_Geometry * geom,
+					   Ng_Mesh * mesh);
+NGLIB_API void Ng_OCC_Generate_SecondOrder (Ng_OCC_Geometry * geom,
+					   Ng_Mesh * mesh);
+#endif // NGLIB_OCC_HPP_INCLUDED

netgen/include/occ/occ_edge.hpp

@@ -0,0 +1,47 @@
+#ifndef FILE_OCC_EDGE_INCLUDED
+#define FILE_OCC_EDGE_INCLUDED
+
+
+// #pragma clang diagnostic push
+// #pragma clang diagnostic ignored "-Wdeprecated-declarations"
+
+#include <GProp_GProps.hxx>
+#include <TopoDS.hxx>
+#include <TopoDS_Edge.hxx>
+#include <Geom_Curve.hxx>
+#include <BRep_TEdge.hxx>
+#include <BRep_Tool.hxx>
+
+// #pragma clang diagnostic pop
+
+#include "occ_vertex.hpp"
+#include "meshing.hpp"
+
+namespace netgen
+{
+    class OCCEdge : public GeometryEdge 
+    {
+        public:
+        TopoDS_Edge edge;
+        Handle(Geom_Curve) curve;
+        double s0, s1;
+        GProp_GProps props;
+
+        public:
+        OCCEdge(TopoDS_Shape edge_, GeometryVertex & start_, GeometryVertex & end_);
+
+        auto Shape() const { return edge; }
+
+        double GetLength() const override;
+        Point<3> GetCenter() const override;
+        Point<3> GetPoint(double t) const override;
+        double CalcStep(double t, double sag) const override;
+        void ProjectPoint(Point<3>& p, EdgePointGeomInfo* gi) const override;
+        Vec<3> GetTangent(double t) const override;
+        bool IsDegenerated(double) const override {
+          return BRep_Tool::Degenerated(edge);
+        }
+    };
+}
+
+#endif // FILE_OCCEDGE_INCLUDED

netgen/include/occ/occ_face.hpp

@@ -0,0 +1,52 @@
+#ifndef FILE_OCC_FACE_INCLUDED
+#define FILE_OCC_FACE_INCLUDED
+
+// #pragma clang diagnostic push
+// #pragma clang diagnostic ignored "-Wdeprecated-declarations"
+
+#include <GProp_GProps.hxx>
+#include <TopoDS.hxx>
+#include <TopoDS_Face.hxx>
+#include <ShapeAnalysis_Surface.hxx>
+
+// #pragma clang diagnostic pop
+
+#include "occ_vertex.hpp"
+#include "meshing.hpp"
+
+namespace netgen
+{
+    class OCCFace : public GeometryFace 
+    {
+        TopoDS_Face face;
+        GProp_GProps props;
+        Box<3> bbox;
+
+        Handle( Geom_Surface ) surface;
+        Handle( ShapeAnalysis_Surface ) shape_analysis;
+        double tolerance;
+
+        public:
+        OCCFace(TopoDS_Shape dshape);
+
+        const TopoDS_Face Shape() const { return face; }
+
+        Point<3> GetCenter() const override;
+        virtual size_t GetNBoundaries() const override;
+        virtual Array<Segment> GetBoundary(const Mesh& mesh) const override;
+        virtual PointGeomInfo Project(Point<3>& p) const override;
+        virtual bool ProjectPointGI(Point<3>& p, PointGeomInfo& gi) const override;
+        virtual Point<3> GetPoint(const PointGeomInfo& gi) const override;
+        virtual void CalcEdgePointGI(const GeometryEdge& edge,
+                double t,
+                EdgePointGeomInfo& egi) const override;
+        virtual Box<3> GetBoundingBox() const override;
+
+        virtual double GetCurvature(const PointGeomInfo& gi) const override;
+
+        virtual void RestrictH(Mesh& mesh, const MeshingParameters& mparam) const override;
+        virtual Vec<3> GetNormal(const Point<3>& p, const PointGeomInfo* gi = nullptr) const override;
+    };
+}
+
+#endif // FILE_OCC_FACE_INCLUDED

netgen/include/occ/occ_solid.hpp

@@ -0,0 +1,23 @@
+#ifndef FILE_OCC_SOLID_INCLUDED
+#define FILE_OCC_SOLID_INCLUDED
+
+#include <TopoDS.hxx>
+#include <TopoDS_Solid.hxx>
+
+#include "meshing.hpp"
+
+namespace netgen
+{
+    class OCCSolid : public GeometrySolid 
+    {
+        TopoDS_Solid solid;
+
+        public:
+        OCCSolid(TopoDS_Shape dshape)
+            : solid(TopoDS::Solid(dshape))
+        { }
+        TopoDS_Solid& GetShape() { return solid; }
+    };
+}
+
+#endif // FILE_OCC_SOLID_INCLUDED

netgen/include/occ/occ_utils.hpp

@@ -0,0 +1,376 @@
+#ifndef FILE_OCC_UTILS_INCLUDED
+#define FILE_OCC_UTILS_INCLUDED
+
+
+
+#include <variant>
+
+// #pragma clang diagnostic push
+// #pragma clang diagnostic ignored "-Wdeprecated-declarations"
+
+#include <Standard_Version.hxx>
+#include <BRepGProp.hxx>
+#include <BRep_Tool.hxx>
+#include <GProp_GProps.hxx>
+#include <TopExp_Explorer.hxx>
+#include <TopTools_IndexedMapOfShape.hxx>
+#include <TopoDS.hxx>
+#include <TopoDS_Vertex.hxx>
+#include <gp_Trsf.hxx>
+#include <gp_GTrsf.hxx>
+
+#define NETGEN_OCC_VERSION_AT_LEAST(MAJOR, MINOR) \
+  ((OCC_VERSION_MAJOR > MAJOR) ||                               \
+   ((OCC_VERSION_MAJOR == MAJOR) && (OCC_VERSION_MINOR >= MINOR)))
+#define NETGEN_OCC_VERSION_AT_LEAST_MAJOR(MAJOR) \
+  (NETGEN_OCC_VERSION_AT_LEAST(MAJOR, 0))
+
+// #pragma clang diagnostic pop
+
+#include "meshing.hpp"
+
+#if NETGEN_OCC_VERSION_AT_LEAST(7, 4)
+#define OCC_HAVE_DUMP_JSON
+#endif
+
+namespace netgen
+{
+    inline Point<3> occ2ng (const gp_Pnt & p)
+    {
+        return Point<3> (p.X(), p.Y(), p.Z());
+    }
+
+    inline Point<2> occ2ng (const gp_Pnt2d & p)
+    {
+        return Point<2> (p.X(), p.Y());
+    }
+
+    inline Vec<3> occ2ng (const gp_Vec & v)
+    {
+        return Vec<3> (v.X(), v.Y(), v.Z());
+    }
+
+    DLL_HEADER Point<3> occ2ng (const TopoDS_Shape & s);
+
+    inline Point<3> occ2ng (const TopoDS_Vertex & v)
+    {
+        return occ2ng (BRep_Tool::Pnt (v));
+    }
+
+    DLL_HEADER Transformation<3> occ2ng (const gp_Trsf & t);
+    DLL_HEADER Transformation<3> occ2ng (const gp_GTrsf & t);
+    inline Transformation<3> occ2ng (const variant<gp_Trsf, gp_GTrsf> & t)
+    {
+      if(auto t1 = get_if<gp_Trsf>(&t))
+        return occ2ng(*t1);
+      return occ2ng(get<gp_GTrsf>(t));
+    }
+
+    inline gp_Pnt ng2occ (const Point<3> & p)
+    {
+        return gp_Pnt(p(0), p(1), p(2));
+    }
+
+    inline void CheckValidPropertyType(const TopoDS_Shape & shape)
+    {
+        switch (shape.ShapeType())
+        {
+          case TopAbs_SOLID:
+          case TopAbs_FACE:
+          case TopAbs_EDGE:
+          case TopAbs_VERTEX:
+            break;
+          default:
+            throw Exception("Cannot query properties of compound shapes - setting properties sets property on all highest dimension subshape type");
+        }
+    }
+
+    DLL_HEADER Box<3> GetBoundingBox( const TopoDS_Shape & shape );
+
+    struct OCCIdentification
+    {
+      TopoDS_Shape from;
+      TopoDS_Shape to;
+      optional<Transformation<3>> trafo = nullopt;
+      string name;
+      Identifications::ID_TYPE type;
+      bool opposite_direction = false;
+    };
+
+    Standard_Integer BuildTriangulation( const TopoDS_Shape & shape );
+
+
+    class MyExplorer
+    {
+      class Iterator
+      {
+        TopExp_Explorer exp;
+      public:
+        Iterator (TopoDS_Shape ashape, TopAbs_ShapeEnum atoFind, TopAbs_ShapeEnum atoAvoid)
+          : exp(ashape, atoFind, atoAvoid) { }
+        auto operator*() { return exp.Current(); }
+        Iterator & operator++() { exp.Next(); return *this; }
+        bool operator!= (nullptr_t nu) { return exp.More(); }
+      };
+
+    public:
+      TopoDS_Shape shape;
+      TopAbs_ShapeEnum toFind;
+      TopAbs_ShapeEnum toAvoid;
+      MyExplorer (TopoDS_Shape ashape, TopAbs_ShapeEnum atoFind, TopAbs_ShapeEnum atoAvoid = TopAbs_SHAPE)
+        : shape(ashape), toFind(atoFind), toAvoid(atoAvoid) { ; }
+      Iterator begin() { return Iterator(shape, toFind, toAvoid); }
+      auto end() { return nullptr; }
+    };
+
+    inline auto Explore (TopoDS_Shape shape, TopAbs_ShapeEnum toFind, TopAbs_ShapeEnum toAvoid = TopAbs_SHAPE)
+    {
+      return MyExplorer (shape, toFind, toAvoid);
+    }
+
+
+    class IndexMapIterator
+    {
+      class Iterator
+      {
+        const TopTools_IndexedMapOfShape & indmap;
+        int i;
+      public:
+        Iterator (const TopTools_IndexedMapOfShape & aindmap, int ai)
+          : indmap(aindmap), i(ai) { ; }
+        auto operator*() { return tuple(i, indmap(i)); }
+        Iterator & operator++() { i++; return *this; }
+        bool operator!= (const Iterator & i2) { return i != i2.i; }
+      };
+
+    public:
+      const TopTools_IndexedMapOfShape & indmap;
+      IndexMapIterator (const TopTools_IndexedMapOfShape & aindmap) : indmap(aindmap) { }
+      Iterator begin() { return Iterator(indmap, 1); }
+      Iterator end() { return Iterator(indmap, indmap.Extent()+1); }
+    };
+
+    inline auto Enumerate (const TopTools_IndexedMapOfShape & indmap)
+    {
+      return IndexMapIterator(indmap);
+    }
+
+    class ListOfShapes : public std::vector<TopoDS_Shape>
+    {
+    public:
+      DLL_HEADER TopoDS_Shape Max(gp_Vec dir);
+      DLL_HEADER TopoDS_Shape Nearest(gp_Pnt pnt);
+      DLL_HEADER ListOfShapes SubShapes(TopAbs_ShapeEnum type) const;
+
+      ListOfShapes Solids() const
+      {
+        return SubShapes(TopAbs_SOLID);
+      }
+      ListOfShapes Shells() const
+      {
+        return SubShapes(TopAbs_SHELL);
+      }
+      ListOfShapes Faces() const
+      {
+        return SubShapes(TopAbs_FACE);
+      }
+      ListOfShapes Wires() const
+      {
+        return SubShapes(TopAbs_WIRE);
+      }
+      ListOfShapes Edges() const
+      {
+        return SubShapes(TopAbs_EDGE);
+      }
+      ListOfShapes Vertices() const
+      {
+        return SubShapes(TopAbs_VERTEX);
+      }
+
+      ListOfShapes operator*(const ListOfShapes& other) const
+      {
+        ListOfShapes common;
+        for(const auto& shape : (*this))
+          for(const auto& shape_o : other)
+            if(shape.IsSame(shape_o))
+              common.push_back(shape);
+        return common;
+      }
+
+      ListOfShapes GetHighestDimShapes() const
+      {
+        for (auto type : {TopAbs_SOLID, TopAbs_FACE, TopAbs_EDGE, TopAbs_VERTEX})
+        {
+          auto ret = SubShapes(type);
+          if (ret.size() > 0)
+            return ret;
+        }
+        return ListOfShapes();
+      }
+    };
+
+    inline ListOfShapes GetSolids(const TopoDS_Shape & shape)
+    {
+      ListOfShapes sub;
+      for (TopExp_Explorer e(shape, TopAbs_SOLID); e.More(); e.Next())
+        sub.push_back(e.Current());
+      return sub;
+    }
+
+    inline ListOfShapes GetShells(const TopoDS_Shape & shape)
+    {
+      ListOfShapes sub;
+      for (TopExp_Explorer e(shape, TopAbs_SHELL); e.More(); e.Next())
+        sub.push_back(e.Current());
+      return sub;
+    }
+
+    inline ListOfShapes GetFaces(const TopoDS_Shape & shape)
+    {
+      ListOfShapes sub;
+      for (TopExp_Explorer e(shape, TopAbs_FACE); e.More(); e.Next())
+        sub.push_back(e.Current());
+      return sub;
+    }
+
+    inline ListOfShapes GetWires(const TopoDS_Shape & shape)
+    {
+      ListOfShapes sub;
+      for (TopExp_Explorer e(shape, TopAbs_WIRE); e.More(); e.Next())
+        sub.push_back(e.Current());
+      return sub;
+    }
+
+    inline ListOfShapes GetEdges(const TopoDS_Shape & shape)
+    {
+      ListOfShapes sub;
+      for (TopExp_Explorer e(shape, TopAbs_EDGE); e.More(); e.Next())
+        sub.push_back(e.Current());
+      return sub;
+    }
+
+    inline ListOfShapes GetVertices(const TopoDS_Shape & shape)
+    {
+      ListOfShapes sub;
+      for (TopExp_Explorer e(shape, TopAbs_VERTEX); e.More(); e.Next())
+        sub.push_back(e.Current());
+      return sub;
+    }
+
+    inline ListOfShapes GetHighestDimShapes(const TopoDS_Shape & shape)
+    {
+      auto ret = GetSolids(shape); if(ret.size() > 0) return ret;
+      ret = GetFaces(shape); if(ret.size() > 0) return ret;
+      ret = GetEdges(shape); if(ret.size() > 0) return ret;
+      ret = GetVertices(shape); if(ret.size() > 0) return ret;
+      return ListOfShapes();
+    }
+
+
+  class DirectionalInterval
+  {
+  public:
+    gp_Vec dir;
+    double minval = -1e99;
+    double maxval = 1e99;
+    bool openmin = false, openmax = false;
+
+    DirectionalInterval (gp_Vec adir) : dir(adir) { ; }
+    DirectionalInterval (const DirectionalInterval & i2) = default;
+
+    DirectionalInterval operator< (double val) const
+    {
+      DirectionalInterval i2 = *this;
+      i2.maxval = val;
+      i2.openmax = true;
+      return i2;
+    }
+
+    DirectionalInterval operator> (double val) const
+    {
+      DirectionalInterval i2 = *this;
+      i2.minval = val;
+      i2.openmin = true;
+      return i2;
+    }
+
+    DirectionalInterval operator<= (double val) const
+    {
+      DirectionalInterval i2 = *this;
+      i2.maxval = val;
+      i2.openmax = false;
+      return i2;
+    }
+
+    DirectionalInterval operator>= (double val) const
+    {
+      DirectionalInterval i2 = *this;
+      i2.minval = val;
+      i2.openmin = false;
+      return i2;
+    }
+
+    DirectionalInterval Intersect (const DirectionalInterval & i2)
+    {
+      DirectionalInterval res = *this;
+      res.minval = max(res.minval, i2.minval);
+      res.maxval = min(res.maxval, i2.maxval);
+      return res;
+    }
+
+    bool Contains (gp_Pnt p, double eps = 1e-8)
+    {
+      // cout << "Contains point " << p.X() << "," << p.Y() << "," << p.Z() << " ? " << endl;
+      double val = dir.X()*p.X() + dir.Y()*p.Y() + dir.Z() * p.Z();
+      // cout << "minval = " << minval << ", val = " << val << " maxval = " << maxval << endl;
+      if (openmin) {
+        if (val < minval+eps) return false;
+      } else {
+        if (val < minval-eps) return false;
+      }
+      if (openmax) {
+        if (val > maxval-eps) return false;
+      } else {
+        if (val > maxval+eps) return false;
+      }
+      return true;
+    }
+  };
+
+  inline auto Properties (TopoDS_Shape shape)
+  {
+    GProp_GProps props;
+    double tol;
+    switch (shape.ShapeType())
+    {
+      case TopAbs_SOLID:
+      case TopAbs_COMPOUND:
+      case TopAbs_COMPSOLID:
+        tol = 1e-2 * BRep_Tool::MaxTolerance(shape, TopAbs_FACE);
+        BRepGProp::VolumeProperties (shape, props, tol); break;
+      case TopAbs_FACE:
+      case TopAbs_SHELL:
+        tol = 1e-2 * BRep_Tool::MaxTolerance(shape, TopAbs_FACE);
+        BRepGProp::SurfaceProperties (shape, props, tol); break;
+      case TopAbs_WIRE:
+      case TopAbs_EDGE:
+        tol = 1e-2 * BRep_Tool::MaxTolerance(shape, TopAbs_EDGE);
+        BRepGProp::LinearProperties(shape, props, tol); break;
+      default:
+        BRepGProp::LinearProperties(shape, props);
+    }
+    return props;
+  }
+
+  inline gp_Pnt Center (TopoDS_Shape shape)
+  {
+    return Properties(shape).CentreOfMass();
+  }
+
+  inline double Mass (TopoDS_Shape shape)
+  {
+    return Properties(shape).Mass();
+  }
+  
+}
+#endif // FILE_OCC_UTILS_INCLUDED

netgen/include/occ/occ_vertex.hpp

@@ -0,0 +1,30 @@
+#ifndef FILE_OCC_VERTEX_INCLUDED
+#define FILE_OCC_VERTEX_INCLUDED
+
+// #pragma clang diagnostic push
+// #pragma clang diagnostic ignored "-Wdeprecated-declarations"
+
+#include <TopoDS.hxx>
+#include <BRep_TVertex.hxx>
+
+// #pragma clang diagnostic pop
+
+#include "meshing.hpp"
+#include "occ_utils.hpp"
+
+namespace netgen
+{
+    class OCCVertex : public GeometryVertex
+    {
+        TopoDS_Vertex vertex;
+        Point<3> p;
+
+        public:
+        OCCVertex( ) = default;
+        OCCVertex( TopoDS_Shape s );
+        ~OCCVertex() {}
+        Point<3> GetPoint() const override;
+    };
+}
+
+#endif // FILE_OCC_VERTEX_INCLUDED