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

netgen/include/gprim/geomops.hpp

@@ -0,0 +1,404 @@
+#ifndef FILE_GEOMOPS
+#define FILE_GEOMOPS
+
+/* *************************************************************************/
+/* File:   geomops.hpp                                                     */
+/* Author: Joachim Schoeberl                                               */
+/* Date:   20. Jul. 02                                                     */
+/* *************************************************************************/
+
+
+namespace netgen
+{
+
+  /*
+
+  Point - Vector operations
+
+  */
+
+
+  template <int D, typename T>
+  inline Vec<D,T> operator+ (Vec<D,T> a, Vec<D,T> b)
+  {
+    Vec<D,T> res;
+    for (int i = 0; i < D; i++)
+      res(i) = a(i) + b(i);
+    return res;
+  }
+
+
+
+  template <int D, typename T>
+  inline Point<D,T> operator+ (Point<D,T> a, Vec<D,T> b)
+  {
+    Point<D,T> res;
+    for (int i = 0; i < D; i++)
+      res(i) = a(i) + b(i);
+    return res;
+  }
+
+
+
+  template <int D, typename T>
+  inline Vec<D,T> operator- (Point<D,T> a, Point<D,T> b)
+  {
+    Vec<D,T> res;
+    for (int i = 0; i < D; i++)
+      res(i) = a(i) - b(i);
+    return res;
+  }
+
+  template <int D, typename T>
+  inline Point<D,T> operator- (Point<D,T> a, Vec<D,T> b)
+  {
+    Point<D,T> res;
+    for (int i = 0; i < D; i++)
+      res(i) = a(i) - b(i);
+    return res;
+  }
+
+  template <int D, typename T>
+  inline Vec<D,T> operator- (Vec<D,T> a, Vec<D,T> b)
+  {
+    Vec<D,T> res;
+    for (int i = 0; i < D; i++)
+      res(i) = a(i) - b(i);
+    return res;
+  }
+
+
+
+  template <int D, typename T>
+  inline Vec<D,T> operator* (T s, Vec<D,T> b)
+  {
+    Vec<D,T> res;
+    for (int i = 0; i < D; i++)
+      res(i) = s * b(i);
+    return res;
+  }
+
+  template <int D, int SW>
+  inline Vec<D, SIMD<double,SW>> operator* (SIMD<double,SW> s, Vec<D,double> b)
+  {
+    Vec<D,SIMD<double,SW>> res;
+    for (int i = 0; i < D; i++)
+      res(i) = s * b(i);
+    return res;
+  }
+  
+
+  template <int D>
+  inline double operator* (Vec<D> a, Vec<D> b)
+  {
+    double sum = 0;
+    for (int i = 0; i < D; i++)
+      sum += a(i) * b(i);
+    return sum;
+  }
+
+
+
+  template <int D, typename T>
+  inline Vec<D,T> operator- (Vec<D,T> b)
+  {
+    Vec<D,T> res;
+    for (int i = 0; i < D; i++)
+      res(i) = -b(i);
+    return res;
+  }
+
+
+  template <int D, typename T>
+  inline Point<D,T> & operator+= (Point<D,T> & a, Vec<D,T> b)
+  {
+    for (int i = 0; i < D; i++)
+      a(i) += b(i);
+    return a;
+  }
+
+  template <int D, typename T>
+  inline Vec<D,T> & operator+= (Vec<D,T> & a, Vec<D> b)
+  {
+    for (int i = 0; i < D; i++)
+      a(i) += b(i);
+    return a;
+  }
+
+
+  template <int D>
+  inline Point<D> & operator-= (Point<D> & a, const Vec<D> & b)
+  {
+    for (int i = 0; i < D; i++)
+      a(i) -= b(i);
+    return a;
+  }
+
+  template <int D>
+  inline Vec<D> & operator-= (Vec<D> & a, const Vec<D> & b)
+  {
+    for (int i = 0; i < D; i++)
+      a(i) -= b(i);
+    return a;
+  }
+
+
+
+  template <int D, typename T1, typename T2>
+  inline Vec<D,T1> & operator*= (Vec<D,T1> & a, T2 s)
+  {
+    for (int i = 0; i < D; i++)
+      a(i) *= s;
+    return a;
+  }
+
+
+  template <int D>
+  inline Vec<D> & operator/= (Vec<D> & a, double s)
+  {
+    for (int i = 0; i < D; i++)
+      a(i) /= s;
+    return a;
+  }
+
+
+
+
+  // Matrix - Vector operations
+
+  /*
+    template <int H, int W>
+    inline Vec<H> operator* (const Mat<H,W> & m, const Vec<W> & v)
+    {
+    Vec<H> res;
+    for (int i = 0; i < H; i++)
+    {
+    res(i) = 0;
+    for (int j = 0; j < W; j++)
+    res(i) += m(i,j) * v(j);
+    }
+    return res;
+    }
+  */
+
+  // thanks to VC60 partial template specialization features !!!
+
+  inline Vec<2> operator* (const Mat<2,2> & m, const Vec<2> & v)
+  {
+    Vec<2> res;
+    for (int i = 0; i < 2; i++)
+      {
+	res(i) = 0;
+	for (int j = 0; j < 2; j++)
+	  res(i) += m(i,j) * v(j);
+      }
+    return res;
+  }
+
+  inline Vec<2> operator* (const Mat<2,3> & m, const Vec<3> & v)
+  {
+    Vec<2> res;
+    for (int i = 0; i < 2; i++)
+      {
+	res(i) = 0;
+	for (int j = 0; j < 3; j++)
+	  res(i) += m(i,j) * v(j);
+      }
+    return res;
+  }
+
+
+  inline Vec<3> operator* (const Mat<3,2> & m, const Vec<2> & v)
+  {
+    Vec<3> res;
+    for (int i = 0; i < 3; i++)
+      {
+	res(i) = 0;
+	for (int j = 0; j < 2; j++)
+	  res(i) += m(i,j) * v(j);
+      }
+    return res;
+  }
+
+
+  inline Vec<3> operator* (const Mat<3,3> & m, const Vec<3> & v)
+  {
+    Vec<3> res;
+    for (int i = 0; i < 3; i++)
+      {
+	res(i) = 0;
+	for (int j = 0; j < 3; j++)
+	  res(i) += m(i,j) * v(j);
+      }
+    return res;
+  }
+
+
+
+
+
+
+
+  /*
+    template <int H1, int W1, int H2, int W2>
+    inline Mat<H1,W2> operator* (const Mat<H1,W1> & a, const Mat<H2,W2> & b)
+    {
+    Mat<H1,W2> m;
+    for (int i = 0; i < H1; i++)
+    for (int j = 0; j < W2; j++)
+    {
+    double sum = 0;
+    for (int k = 0; k < W1; k++)
+    sum += a(i,k) * b(k, j);
+    m(i,j) = sum; 
+    }
+    return m;
+    }
+  */
+
+  template <typename T>
+  inline Mat<2,2,T> operator* (const Mat<2,2,T> & a, const Mat<2,2,T> & b)
+  {
+    Mat<2,2,T> m;
+    for (int i = 0; i < 2; i++)
+      for (int j = 0; j < 2; j++)
+	{
+          T sum(0);
+	  for (int k = 0; k < 2; k++)
+	    sum += a(i,k) * b(k, j);
+	  m(i,j) = sum; 
+	}
+    return m;
+  }
+
+  inline Mat<2,2> operator* (const Mat<2,3> & a, const Mat<3,2> & b)
+  {
+    Mat<2,2> m;
+    for (int i = 0; i < 2; i++)
+      for (int j = 0; j < 2; j++)
+	{
+	  double sum = 0;
+	  for (int k = 0; k < 3; k++)
+	    sum += a(i,k) * b(k, j);
+	  m(i,j) = sum; 
+	}
+    return m;
+  }
+
+  template <typename T>
+  inline Mat<3,2,T> operator* (const Mat<3,2,T> & a, const Mat<2,2,T> & b)
+  {
+    Mat<3,2,T> m;
+    for (int i = 0; i < 3; i++)
+      for (int j = 0; j < 2; j++)
+	{
+	  T sum(0.0);
+	  for (int k = 0; k < 2; k++)
+	    sum += a(i,k) * b(k, j);
+	  m(i,j) = sum; 
+	}
+    return m;
+  }
+
+
+
+  inline Mat<2,3> operator* (const Mat<2,2> & a, const Mat<2,3> & b)
+  {
+    Mat<2,3> m;
+    for (int i = 0; i < 2; i++)
+      for (int j = 0; j < 3; j++)
+	{
+	  double sum = 0;
+	  for (int k = 0; k < 2; k++)
+	    sum += a(i,k) * b(k, j);
+	  m(i,j) = sum; 
+	}
+    return m;
+  }
+
+  template <typename T>
+  inline Mat<3,3,T> operator* (const Mat<3,3,T> & a, const Mat<3,3,T> & b)
+  {
+    Mat<3,3,T> m;
+    for (int i = 0; i < 3; i++)
+      for (int j = 0; j < 3; j++)
+	{
+	  T sum = T(0);
+	  for (int k = 0; k < 3; k++)
+	    sum += a(i,k) * b(k, j);
+	  m(i,j) = sum; 
+	}
+    return m;
+  }
+
+
+
+
+
+
+
+
+  template <int H, int W>
+  inline Mat<W,H> Trans (const Mat<H,W> & m)
+  {
+    Mat<W,H> res;
+    for (int i = 0; i < H; i++)
+      for (int j = 0; j < W; j++)
+	res(j,i) = m(i,j);
+    return res;
+  }
+
+
+
+
+
+
+
+
+
+
+
+  template <int D, typename T>
+  inline ostream & operator<< (ostream & ost, const Vec<D,T> & a)
+  {
+    ost << "(";
+    for (int i = 0; i < D-1; i++)
+      ost << a(i) << ", ";
+    ost << a(D-1) << ")";
+    return ost;
+  }
+
+  template <int D, typename T>
+  inline ostream & operator<< (ostream & ost, const Point<D,T> & a)
+  {
+    ost << "(";
+    for (int i = 0; i < D-1; i++)
+      ost << a(i) << ", ";
+    ost << a(D-1) << ")";
+    return ost;
+  }
+
+  template <int D>
+  inline ostream & operator<< (ostream & ost, const Box<D> & b)
+  {
+    ost << b.PMin() << " - " << b.PMax();
+    return ost;
+  }
+
+  template <int H, int W, typename T>
+  inline ostream & operator<< (ostream & ost, const Mat<H,W,T> & m)
+  {
+    ost << "(";
+    for (int i = 0; i < H; i++)
+      {
+	for (int j = 0; j < W; j++)
+	  ost << m(i,j) << "   ";
+	ost << endl;
+      }
+    return ost;
+  }
+
+
+}
+
+#endif

netgen/include/gprim/geomtest3d.hpp

@@ -0,0 +1,101 @@
+#ifndef FILE_GEOMTEST3D
+#define FILE_GEOMTEST3D
+
+/* *************************************************************************/
+/* File:   geomtest3d.hh                                                   */
+/* Author: Joachim Schoeberl                                               */
+/* Date:   13. Feb. 98                                                     */
+/* *************************************************************************/
+
+#include "geom3d.hpp"
+#include "geomobjects.hpp"
+
+namespace netgen
+{
+
+
+extern int
+IntersectTriangleLine (const Point<3> ** tri, const Point<3> ** line);
+
+
+
+/**
+  Returns 0, iff
+  closure (tet)  cup  closure (tri)  is empty, one corner point of tet,
+  one edge of tet or one face of tet
+ */
+extern int 
+IntersectTetTriangle (const Point<3> ** tet, const Point<3> ** tri,
+		      const int * tetpi = NULL, const int * tripi = NULL);
+
+/**
+  Same test as above, but tet int reference position (0, ex, ey, ez),
+  tetpi = 1, 2, 4, 5
+ */
+extern int 
+IntersectTetTriangleRef (const Point3d ** tri, const int * tripi = NULL);
+
+
+// 1, iff not regular triangulation
+extern int 
+IntersectTriangleTriangle (const Point<3> ** tri1, const Point<3> ** tri2);
+
+
+extern void
+LocalCoordinates (const Vec3d & e1, const Vec3d & e2,
+		  const Vec3d & v, double & lam1, double & lam2);
+
+/// return 1 = degenerated sphere
+extern int
+CalcSphereCenter (const Point<3> ** pts, Point<3> & c);
+
+/// return 1 = degenerated triangle
+extern int
+CalcTriangleCenter (const Point3d ** pts, Point3d & c);
+
+
+
+/*
+  Compute radius of cylinder fitting 4 points.
+  cylinder axis is in the direction of p1-p2
+*/
+extern double ComputeCylinderRadius (const Point3d & p1, const Point3d & p2,
+				     const Point3d & p3, const Point3d & p4);
+
+/*
+  Two triangles T1 and T2 have normals n1 and n2.
+  The height over the common edge is h1, and h2.
+  Radius of cylinder fitting both triangles
+*/
+extern double ComputeCylinderRadius (const Vec3d & n1, const Vec3d & n2,
+				     double h1, double h2);
+
+/// Minimal distance of point p to the line segment [lp1,lp2]
+DLL_HEADER double MinDistLP2 (const Point2d & lp1, const Point2d & lp2, const Point2d & p);
+
+/// Minimal distance of point p to the line segment [lp1,lp2]
+DLL_HEADER double MinDistLP2 (const Point3d & lp1, const Point3d & lp2, const Point3d & p);
+
+/// Minimal distance of point p to the triangle segment [tp1,tp2,pt3]
+DLL_HEADER double MinDistTP2 (const Point3d & tp1, const Point3d & tp2, 
+			  const Point3d & tp3, const Point3d & p);
+
+  inline double MinDistTP2 (const Point<2> & tp1, const Point<2> & tp2, 
+                            const Point<2> & tp3, const Point<2> & p)
+  {
+    return MinDistTP2 (Point<3> (tp1(0), tp1(1),0),
+                       Point<3> (tp2(0), tp2(1),0),
+                       Point<3> (tp3(0), tp3(1),0),
+                       Point<3> (p(0), p(1),0));
+  }
+
+/// Minimal distance of the 2 lines [l1p1,l1p2] and [l2p1,l2p2]
+extern double MinDistLL2 (const Point3d & l1p1, const Point3d & l1p2,
+			  const Point3d & l2p1, const Point3d & l2p2);
+
+extern double MinDistLL2 (const Point3d & l1p1, const Point3d & l1p2,
+		  const Point3d & l2p1, const Point3d & l2p2, double & lam1, double & lam2 );
+
+}
+
+#endif

netgen/include/gprim/gprim.hpp

@@ -0,0 +1,33 @@
+#ifndef FILE_GPRIM
+#define FILE_GPRIM
+
+/* *************************************************************************/
+/* File:   gprim.hpp                                                        */
+/* Author: Joachim Schoeberl                                               */
+/* Date:   14. Aug. 97                                                     */
+/* *************************************************************************/
+
+
+#include <myadt.hpp>
+#include <linalg.hpp>
+
+
+
+
+#include "geomobjects.hpp"
+#include "geomops.hpp"
+#include "geomfuncs.hpp"
+
+#include "geom2d.hpp"
+#include "geom3d.hpp"
+
+#include "geomtest3d.hpp"
+#include "transform3d.hpp"
+
+#include "adtree.hpp"
+
+#include "spline.hpp"
+#include "splinegeometry.hpp"
+
+
+#endif