Merge branch 'stlparams_from_python' into 'master'

STLParams from python

See merge request jschoeberl/netgen!188

libsrc/core/python_ngcore.cpp

@@ -40,7 +40,7 @@ namespace ngcore
 
     if (py::isinstance<py::list>(value))
       {             
-        py::list vdl(value);
+        auto vdl = py::cast<py::list>(value);
         if (py::len(vdl) > 0)
           {
             if(py::isinstance<double>(vdl[0]))
@@ -59,7 +59,7 @@ namespace ngcore
 
     if (py::isinstance<py::tuple>(value))
       {
-        py::tuple vdt(value);
+        auto vdt = py::cast<py::tuple>(value);
         if (py::isinstance<py::float_>(value))
           flags.SetFlag(s, makeCArray<double>(vdt));
         if (py::isinstance<py::int_>(value))
@@ -69,29 +69,32 @@ namespace ngcore
       }
   }
 
-  Flags CreateFlagsFromKwArgs(py::object pyclass, const py::kwargs& kwargs, py::list info)
+  Flags CreateFlagsFromKwArgs(const py::kwargs& kwargs, py::object pyclass, py::list info)
   {
     static std::shared_ptr<Logger> logger = GetLogger("Flags");
-    auto flags_doc = pyclass.attr("__flags_doc__")();
     py::dict flags_dict;
 
     if (kwargs.contains("flags"))
       {
-        logger->warn("WARNING: using flags as kwarg is deprecated in {}, use the flag arguments as kwargs instead!",
+        logger->warn("WARNING: using flags as kwarg is deprecated{}, use the flag arguments as kwargs instead!",
-                     std::string(py::str(pyclass)));
+                     pyclass.is_none() ? "" : std::string(" in ") + std::string(py::str(pyclass)));
         auto addflags = py::cast<py::dict>(kwargs["flags"]);
         for (auto item : addflags)
           flags_dict[item.first.cast<string>().c_str()] = item.second;
       }
+    py::dict special;
+    if(!pyclass.is_none())
+      {
+        auto flags_doc = pyclass.attr("__flags_doc__")();
         for (auto item : kwargs)
           if (!flags_doc.contains(item.first.cast<string>().c_str()) &&
               !(item.first.cast<string>() == "flags"))
             logger->warn("WARNING: kwarg '{}' is an undocumented flags option for class {}, maybe there is a typo?",
                          item.first.cast<string>(), std::string(py::str(pyclass)));
       
-    py::dict special;
         if(py::hasattr(pyclass,"__special_treated_flags__"))
           special = pyclass.attr("__special_treated_flags__")();
+      }
     for (auto item : kwargs)
       {
         auto name = item.first.cast<string>();
@@ -116,4 +119,47 @@ namespace ngcore
     return flags;
   }
 
+  py::dict CreateDictFromFlags(const Flags& flags)
+  {
+    py::dict d;
+    std::string key;
+    for(auto i : Range(flags.GetNFlagsFlags()))
+      {
+        auto& f = flags.GetFlagsFlag(i, key);
+        d[key.c_str()] = CreateDictFromFlags(f);
+      }
+    for(auto i : Range(flags.GetNStringListFlags()))
+      {
+        auto strlistflag = flags.GetStringListFlag(i, key);
+        py::list lst;
+        for(auto& val : *strlistflag)
+          lst.append(val);
+        d[key.c_str()] = lst;
+      }
+    for(auto i : Range(flags.GetNNumListFlags()))
+      {
+        auto numlistflag = flags.GetNumListFlag(i, key);
+        py::list lst;
+        for(auto& val : *numlistflag)
+          lst.append(val);
+        d[key.c_str()] = lst;
+      }
+    for(auto i : Range(flags.GetNStringFlags()))
+      {
+        auto val = flags.GetStringFlag(i, key);
+        d[key.c_str()] = val;
+      }
+    for(auto i : Range(flags.GetNNumFlags()))
+      {
+        auto val = flags.GetNumFlag(i, key);
+        d[key.c_str()] = val;
+      }
+    for(auto i : Range(flags.GetNDefineFlags()))
+      {
+        auto val = flags.GetDefineFlag(i, key);
+        d[key.c_str()] = val;
+      }
+    return d;
+  }
+
 } // namespace ngcore

libsrc/core/python_ngcore.hpp

@@ -16,7 +16,6 @@ namespace ngcore
   Array<T> makeCArray(const py::object& obj)
   {
     Array<T> arr;
-    arr.SetAllocSize(py::len(obj));
     if(py::isinstance<py::list>(obj))
         for(auto& val : py::cast<py::list>(obj))
           arr.Append(py::cast<T>(val));
@@ -30,7 +29,10 @@ namespace ngcore
   
   void NGCORE_API SetFlag(Flags &flags, std::string s, py::object value);
   // Parse python kwargs to flags
-  Flags NGCORE_API CreateFlagsFromKwArgs(py::object pyclass, const py::kwargs& kwargs, py::list info = py::list());
+  Flags NGCORE_API CreateFlagsFromKwArgs(const py::kwargs& kwargs, py::object pyclass = py::none(),
+                                         py::list info = py::list());
+  // Create python dict from kwargs
+  py::dict NGCORE_API CreateDictFromFlags(const Flags& flags);
 
   // ***************  Archiving functionality  **************
   

libsrc/meshing/meshfunc.cpp

@@ -12,10 +12,11 @@ namespace netgen
 
 
   // extern double teterrpow; 
-  MESHING3_RESULT MeshVolume (MeshingParameters & mp, Mesh& mesh3d)
+  MESHING3_RESULT MeshVolume (const MeshingParameters & c_mp, Mesh& mesh3d)
   {
     static Timer t("MeshVolume"); RegionTimer reg(t);
 
+     MeshingParameters mp = c_mp; // copy mp to change them here
      int oldne;
      int meshed;
 
@@ -637,7 +638,7 @@ namespace netgen
 
 
 
-  MESHING3_RESULT OptimizeVolume (MeshingParameters & mp, 
+  MESHING3_RESULT OptimizeVolume (const MeshingParameters & mp, 
 				  Mesh & mesh3d)
     //				  const CSGeometry * geometry)
   {

libsrc/meshing/meshfunc.hpp

@@ -16,13 +16,13 @@ class Mesh;
 // class CSGeometry;
 
 /// Build tet-mesh
-DLL_HEADER MESHING3_RESULT MeshVolume (MeshingParameters & mp, Mesh& mesh3d);
+DLL_HEADER MESHING3_RESULT MeshVolume (const MeshingParameters & mp, Mesh& mesh3d);
 
 /// Build mixed-element mesh
 // MESHING3_RESULT MeshMixedVolume (MeshingParameters & mp, Mesh& mesh3d);
 
 /// Optimize tet-mesh
-DLL_HEADER MESHING3_RESULT OptimizeVolume (MeshingParameters & mp, Mesh& mesh3d);
+DLL_HEADER MESHING3_RESULT OptimizeVolume (const MeshingParameters & mp, Mesh& mesh3d);
 //			       const CSGeometry * geometry = NULL);
 
 DLL_HEADER void RemoveIllegalElements (Mesh & mesh3d);

libsrc/meshing/meshtype.hpp

@@ -1280,6 +1280,8 @@ namespace netgen
     bool inverttrigs = false;
     ///
     bool autozrefine = false;
+
+    Flags geometrySpecificParameters;
     ///
     MeshingParameters ();
     ///
@@ -1307,7 +1309,7 @@ namespace netgen
     NgArray<MeshSizePoint> meshsize_points;
     
     void (*render_function)(bool) = NULL;
-    void Render(bool blocking = false)
+    void Render(bool blocking = false) const
     {
       if (render_function) 
         (*render_function)(blocking);

libsrc/meshing/python_mesh.cpp

@@ -1019,17 +1019,14 @@ DLL_HEADER void ExportNetgenMeshing(py::module &m)
   typedef MeshingParameters MP;
   auto mp = py::class_<MP> (m, "MeshingParameters")
     .def(py::init<>())
-    .def(py::init([](py::kwargs kwargs)
+            .def(py::init([](MeshingParameters* other, py::kwargs kwargs)
                   {
                     MeshingParameters mp;
-                    CreateMPfromKwargs(mp, kwargs);
+                    if(other) mp = *other;
+                    CreateMPfromKwargs(mp, kwargs, false);
                     return mp;
-                  }), meshingparameter_description.c_str())
+                  }), py::arg("mp")=nullptr, meshingparameter_description.c_str())
     .def("__str__", &ToString<MP>)
-    .def_property("maxh", [](const MP & mp ) { return mp.maxh; },
-                  [](MP & mp, double maxh) { return mp.maxh = maxh; })
-    .def_property("grading", [](const MP & mp ) { return mp.grading; },
-                  [](MP & mp, double grading) { return mp.grading = grading; })
     .def("RestrictH", FunctionPointer
          ([](MP & mp, double x, double y, double z, double h)
           {

libsrc/meshing/python_mesh.hpp

@@ -1,5 +1,9 @@
+#ifndef NETGEN_MESHING_PYTHON_MESH_HPP
+#define NETGEN_MESHING_PYTHON_MESH_HPP
 
 #include <pybind11/pybind11.h>
+
+#include <core/python_ngcore.hpp>
 #include "meshing.hpp"
 
 namespace netgen
@@ -80,89 +84,98 @@ elsizeweight: float = 0.2
 
 )delimiter";
 
-  inline void CreateMPfromKwargs(MeshingParameters& mp, py::kwargs kwargs)
+inline void CreateMPfromKwargs(MeshingParameters& mp, py::kwargs kwargs, bool throw_if_not_all_parsed=true)
   {
     if(kwargs.contains("optimize3d"))
-      mp.optimize3d = py::cast<string>(kwargs["optimize3d"]);
+      mp.optimize3d = py::cast<string>(kwargs.attr("pop")("optimize3d"));
     if(kwargs.contains("optsteps3d"))
-      mp.optsteps3d = py::cast<int>(kwargs["optsteps3d"]);
+      mp.optsteps3d = py::cast<int>(kwargs.attr("pop")("optsteps3d"));
     if(kwargs.contains("optimize2d"))
-      mp.optimize2d = py::cast<string>(kwargs["optimize2d"]);
+      mp.optimize2d = py::cast<string>(kwargs.attr("pop")("optimize2d"));
     if(kwargs.contains("optsteps2d"))
-      mp.optsteps2d = py::cast<int>(kwargs["optsteps2d"]);
+      mp.optsteps2d = py::cast<int>(kwargs.attr("pop")("optsteps2d"));
     if(kwargs.contains("opterrpow"))
-      mp.opterrpow = py::cast<double>(kwargs["opterrpow"]);
+      mp.opterrpow = py::cast<double>(kwargs.attr("pop")("opterrpow"));
     if(kwargs.contains("blockfill"))
-      mp.blockfill = py::cast<bool>(kwargs["blockfill"]);
+      mp.blockfill = py::cast<bool>(kwargs.attr("pop")("blockfill"));
     if(kwargs.contains("filldist"))
-      mp.filldist = py::cast<double>(kwargs["filldist"]);
+      mp.filldist = py::cast<double>(kwargs.attr("pop")("filldist"));
     if(kwargs.contains("safety"))
-      mp.safety = py::cast<double>(kwargs["safety"]);
+      mp.safety = py::cast<double>(kwargs.attr("pop")("safety"));
     if(kwargs.contains("relinnersafety"))
-      mp.relinnersafety = py::cast<double>(kwargs["relinnersafety"]);
+      mp.relinnersafety = py::cast<double>(kwargs.attr("pop")("relinnersafety"));
     if(kwargs.contains("uselocalh"))
-      mp.uselocalh = py::cast<bool>(kwargs["uselocalh"]);
+      mp.uselocalh = py::cast<bool>(kwargs.attr("pop")("uselocalh"));
     if(kwargs.contains("grading"))
-      mp.grading = py::cast<double>(kwargs["grading"]);
+      mp.grading = py::cast<double>(kwargs.attr("pop")("grading"));
     if(kwargs.contains("delaunay"))
-      mp.delaunay = py::cast<bool>(kwargs["delaunay"]);
+      mp.delaunay = py::cast<bool>(kwargs.attr("pop")("delaunay"));
     if(kwargs.contains("maxh"))
-      mp.maxh = py::cast<double>(kwargs["maxh"]);
+      mp.maxh = py::cast<double>(kwargs.attr("pop")("maxh"));
     if(kwargs.contains("minh"))
-      mp.minh = py::cast<double>(kwargs["minh"]);
+      mp.minh = py::cast<double>(kwargs.attr("pop")("minh"));
     if(kwargs.contains("meshsizefilename"))
-      mp.meshsizefilename = py::cast<string>(kwargs["meshsizefilename"]);
+      mp.meshsizefilename = py::cast<string>(kwargs.attr("pop")("meshsizefilename"));
     if(kwargs.contains("startinsurface"))
-      mp.startinsurface = py::cast<bool>(kwargs["startinsurface"]);
+      mp.startinsurface = py::cast<bool>(kwargs.attr("pop")("startinsurface"));
     if(kwargs.contains("checkoverlap"))
-      mp.checkoverlap = py::cast<bool>(kwargs["checkoverlap"]);
+      mp.checkoverlap = py::cast<bool>(kwargs.attr("pop")("checkoverlap"));
     if(kwargs.contains("checkoverlappingboundary"))
-      mp.checkoverlappingboundary = py::cast<bool>(kwargs["checkoverlappingboundary"]);
+      mp.checkoverlappingboundary = py::cast<bool>(kwargs.attr("pop")("checkoverlappingboundary"));
     if(kwargs.contains("checkchartboundary"))
-      mp.checkchartboundary = py::cast<bool>(kwargs["checkchartboundary"]);
+      mp.checkchartboundary = py::cast<bool>(kwargs.attr("pop")("checkchartboundary"));
     if(kwargs.contains("curvaturesafety"))
-      mp.curvaturesafety = py::cast<double>(kwargs["curvaturesafety"]);
+      mp.curvaturesafety = py::cast<double>(kwargs.attr("pop")("curvaturesafety"));
     if(kwargs.contains("segmentsperedge"))
-      mp.segmentsperedge = py::cast<double>(kwargs["segmentsperedge"]);
+      mp.segmentsperedge = py::cast<double>(kwargs.attr("pop")("segmentsperedge"));
     if(kwargs.contains("parthread"))
-      mp.parthread = py::cast<bool>(kwargs["parthread"]);
+      mp.parthread = py::cast<bool>(kwargs.attr("pop")("parthread"));
     if(kwargs.contains("elsizeweight"))
-      mp.elsizeweight = py::cast<double>(kwargs["elsizeweight"]);
+      mp.elsizeweight = py::cast<double>(kwargs.attr("pop")("elsizeweight"));
     if(kwargs.contains("perfstepsstart"))
-      mp.perfstepsstart = py::cast<int>(kwargs["perfstepsstart"]);
+      mp.perfstepsstart = py::cast<int>(kwargs.attr("pop")("perfstepsstart"));
     if(kwargs.contains("perfstepsend"))
-      mp.perfstepsend = py::cast<int>(kwargs["perfstepsend"]);
+      mp.perfstepsend = py::cast<int>(kwargs.attr("pop")("perfstepsend"));
     if(kwargs.contains("giveuptol2d"))
-      mp.giveuptol2d = py::cast<int>(kwargs["giveuptol2d"]);
+      mp.giveuptol2d = py::cast<int>(kwargs.attr("pop")("giveuptol2d"));
     if(kwargs.contains("giveuptol"))
-      mp.giveuptol = py::cast<int>(kwargs["giveuptol"]);
+      mp.giveuptol = py::cast<int>(kwargs.attr("pop")("giveuptol"));
     if(kwargs.contains("maxoutersteps"))
-      mp.maxoutersteps = py::cast<int>(kwargs["maxoutersteps"]);
+      mp.maxoutersteps = py::cast<int>(kwargs.attr("pop")("maxoutersteps"));
     if(kwargs.contains("starshapeclass"))
-      mp.starshapeclass = py::cast<int>(kwargs["starshapeclass"]);
+      mp.starshapeclass = py::cast<int>(kwargs.attr("pop")("starshapeclass"));
     if(kwargs.contains("baseelnp"))
-      mp.baseelnp = py::cast<int>(kwargs["baseelnp"]);
+      mp.baseelnp = py::cast<int>(kwargs.attr("pop")("baseelnp"));
     if(kwargs.contains("sloppy"))
-      mp.sloppy = py::cast<int>(kwargs["sloppy"]);
+      mp.sloppy = py::cast<int>(kwargs.attr("pop")("sloppy"));
     if(kwargs.contains("badellimit"))
-      mp.badellimit = py::cast<double>(kwargs["badellimit"]);
+      mp.badellimit = py::cast<double>(kwargs.attr("pop")("badellimit"));
     if(kwargs.contains("check_impossible"))
-      mp.check_impossible = py::cast<bool>(kwargs["check_impossible"]);
+      mp.check_impossible = py::cast<bool>(kwargs.attr("pop")("check_impossible"));
     if(kwargs.contains("only3D_domain_nr"))
-      mp.only3D_domain_nr = py::cast<int>(kwargs["only3D_domain_nr"]);
+      mp.only3D_domain_nr = py::cast<int>(kwargs.attr("pop")("only3D_domain_nr"));
     if(kwargs.contains("secondorder"))
-      mp.secondorder = py::cast<bool>(kwargs["secondorder"]);
+      mp.secondorder = py::cast<bool>(kwargs.attr("pop")("secondorder"));
     if(kwargs.contains("elementorder"))
-      mp.elementorder = py::cast<int>(kwargs["elementorder"]);
+      mp.elementorder = py::cast<int>(kwargs.attr("pop")("elementorder"));
     if(kwargs.contains("quad"))
-      mp.quad = py::cast<bool>(kwargs["quad"]);
+      mp.quad = py::cast<bool>(kwargs.attr("pop")("quad"));
     if(kwargs.contains("try_hexes"))
-      mp.try_hexes = py::cast<bool>(kwargs["try_hexes"]);
+      mp.try_hexes = py::cast<bool>(kwargs.attr("pop")("try_hexes"));
     if(kwargs.contains("inverttets"))
-      mp.inverttets = py::cast<bool>(kwargs["inverttets"]);
+      mp.inverttets = py::cast<bool>(kwargs.attr("pop")("inverttets"));
     if(kwargs.contains("inverttrigs"))
-      mp.inverttrigs = py::cast<bool>(kwargs["inverttrigs"]);
+      mp.inverttrigs = py::cast<bool>(kwargs.attr("pop")("inverttrigs"));
     if(kwargs.contains("autozrefine"))
-      mp.autozrefine = py::cast<bool>(kwargs["autozrefine"]);
+      mp.autozrefine = py::cast<bool>(kwargs.attr("pop")("autozrefine"));
+    if(kwargs.size())
+    {
+      if(throw_if_not_all_parsed)
+        throw Exception(string("Not all kwargs given to GenerateMesh could be parsed:") + string(py::str(kwargs)));
+      mp.geometrySpecificParameters = CreateFlagsFromKwArgs(kwargs);
+    }
   }
 } // namespace netgen
+
+#endif // NETGEN_MESHING_PYTHON_MESH_HPP
+ 

libsrc/stlgeom/meshstlsurface.cpp

@@ -13,15 +13,16 @@
 namespace netgen
 {
 
-static void STLFindEdges (STLGeometry & geom,
+static void STLFindEdges (STLGeometry & geom, Mesh & mesh,
-			  class Mesh & mesh)
+                          const MeshingParameters& mparam,
+                          const STLParameters& stlparam)
 {
   double h = mparam.maxh;
 
   // mark edge points:
   //int ngp = geom.GetNP();
 
-  geom.RestrictLocalH(mesh, h);
+  geom.RestrictLocalH(mesh, h, stlparam);
   
   PushStatusF("Mesh Lines");
 
@@ -229,18 +230,19 @@ static void STLFindEdges (STLGeometry & geom,
 
 
 
-void STLSurfaceMeshing1 (STLGeometry & geom, class Mesh & mesh,
+void STLSurfaceMeshing1 (STLGeometry & geom, class Mesh & mesh, const MeshingParameters& mparam,
-			 int retrynr);
+			 int retrynr, const STLParameters& stlparam);
 
 
-int STLSurfaceMeshing (STLGeometry & geom, class Mesh & mesh)
+int STLSurfaceMeshing (STLGeometry & geom, class Mesh & mesh, const MeshingParameters& mparam,
+                       const STLParameters& stlparam)
 {
   PrintFnStart("Do Surface Meshing");
 
   geom.PrepareSurfaceMeshing();
 
   if (mesh.GetNSeg() == 0)
-    STLFindEdges (geom, mesh);
+    STLFindEdges (geom, mesh, mparam, stlparam);
 
   int nopen;
   int outercnt = 20;
@@ -272,7 +274,7 @@ int STLSurfaceMeshing (STLGeometry & geom, class Mesh & mesh)
 	      if (multithread.terminate) { return MESHING3_TERMINATE; }
 
 	      trialcnt++;
-	      STLSurfaceMeshing1 (geom, mesh, trialcnt);
+	      STLSurfaceMeshing1 (geom, mesh, mparam, trialcnt, stlparam);
 
 	      mesh.FindOpenSegments();
 	      nopen = mesh.GetNOpenSegments();
@@ -526,8 +528,10 @@ int STLSurfaceMeshing (STLGeometry & geom, class Mesh & mesh)
 
 
 void STLSurfaceMeshing1 (STLGeometry & geom,
-			 class Mesh & mesh,
+			 Mesh & mesh,
-			 int retrynr)
+                         const MeshingParameters& mparam,
+			 int retrynr,
+                         const STLParameters& stlparam)
 {
   static int timer1 = NgProfiler::CreateTimer ("STL surface meshing1");
   static int timer1a = NgProfiler::CreateTimer ("STL surface meshing1a");
@@ -740,8 +744,8 @@ void STLSurfaceMeshing1 (STLGeometry & geom,
 
 
 void STLSurfaceOptimization (STLGeometry & geom,
-			     class Mesh & mesh,
+			     Mesh & mesh,
-			     MeshingParameters & meshparam)
+			     const MeshingParameters & mparam)
 {
   PrintFnStart("optimize STL Surface");
 
@@ -749,12 +753,12 @@ void STLSurfaceOptimization (STLGeometry & geom,
 
   optmesh.SetFaceIndex (0);
   optmesh.SetImproveEdges (0);
-  optmesh.SetMetricWeight (meshparam.elsizeweight);
+  optmesh.SetMetricWeight (mparam.elsizeweight);
 
-  PrintMessage(5,"optimize string = ", meshparam.optimize2d, " elsizew = ", meshparam.elsizeweight);
+  PrintMessage(5,"optimize string = ", mparam.optimize2d, " elsizew = ", mparam.elsizeweight);
 
-  for (int i = 1; i <= meshparam.optsteps2d; i++)
+  for (int i = 1; i <= mparam.optsteps2d; i++)
-    for (size_t j = 1; j <= meshparam.optimize2d.length(); j++)
+    for (size_t j = 1; j <= mparam.optimize2d.length(); j++)
       {
 	if (multithread.terminate)
 	  break;
@@ -762,7 +766,7 @@ void STLSurfaceOptimization (STLGeometry & geom,
 	//(*testout) << "optimize, before, step = " << meshparam.optimize2d[j-1] << mesh.Point (3679) << endl;
 
 	mesh.CalcSurfacesOfNode();
-	switch (meshparam.optimize2d[j-1])
+	switch (mparam.optimize2d[j-1])
 	  {
 	  case 's': 
 	    {

libsrc/stlgeom/python_stl.cpp

@@ -17,6 +17,118 @@ namespace netgen
   extern shared_ptr<NetgenGeometry> ng_geometry;
 }
 
+static string stlparameter_description = R"delimiter(
+STL Specific Meshing Parameters
+-------------------------------
+
+yangle: float =
+  Angle for edge detection
+
+contyangle: float =
+  Edges continue if angle > contyangle
+
+edgecornerangle: float =
+  Angle of geometry edge at which the mesher should set a point.
+
+)delimiter";
+
+void CreateSTLParametersFromKwargs(STLParameters& stlparam, py::dict kwargs)
+{
+  if(kwargs.contains("yangle"))
+    stlparam.yangle = py::cast<double>(kwargs.attr("pop")("yangle"));
+  if(kwargs.contains("contyangle"))
+    stlparam.contyangle = py::cast<double>(kwargs.attr("pop")("contyangle"));
+  if(kwargs.contains("edgecornerangle"))
+    stlparam.edgecornerangle = py::cast<double>(kwargs.attr("pop")("edgecornerangle"));
+  if(kwargs.contains("chartangle"))
+    stlparam.chartangle = py::cast<double>(kwargs.attr("pop")("chartangle"));
+  if(kwargs.contains("outerchartangle"))
+    stlparam.outerchartangle = py::cast<double>(kwargs.attr("pop")("outerchartangle"));
+  if(kwargs.contains("usesearchtree"))
+    stlparam.usesearchtree = py::cast<int>(kwargs.attr("pop")("usesearchtree"));
+  if(kwargs.contains("resthatlasfac"))
+  {
+    auto val = kwargs.attr("pop")("resthatlasfac");
+    if(val.is_none())
+      stlparam.resthatlasenable = false;
+    else
+    {
+      stlparam.resthatlasenable = true;
+      stlparam.resthatlasfac = py::cast<double>(val);
+    }
+  }
+  if(kwargs.contains("atlasminh"))
+    stlparam.atlasminh = py::cast<double>(kwargs.attr("pop")("atlasminh"));
+  if(kwargs.contains("resthsurfcurvfac"))
+  {
+    auto val = kwargs.attr("pop")("resthsurfcurvfac");
+    if(val.is_none())
+      stlparam.resthsurfcurvenable = false;
+    else
+    {
+      stlparam.resthsurfcurvenable = true;
+      stlparam.resthsurfcurvfac = py::cast<double>(val);
+    }
+  }
+  if(kwargs.contains("resthchartdistfac"))
+  {
+    auto val = kwargs.attr("pop")("resthchartdistfac");
+    if(val.is_none())
+      stlparam.resthchartdistenable = false;
+    else
+    {
+      stlparam.resthchartdistenable = true;
+      stlparam.resthchartdistfac = py::cast<double>(val);
+    }
+  }
+  if(kwargs.contains("resthcloseedgefac"))
+  {
+    auto val = kwargs.attr("pop")("resthcloseedgefac");
+    if(val.is_none())
+      stlparam.resthcloseedgeenable = false;
+    else
+    {
+      stlparam.resthcloseedgeenable = true;
+      stlparam.resthcloseedgefac = py::cast<double>(val);
+    }
+  }
+  if(kwargs.contains("resthedgeanglefac"))
+  {
+    auto val = kwargs.attr("pop")("resthedgeanglefac");
+    if(val.is_none())
+      stlparam.resthedgeangleenable = false;
+    else
+    {
+      stlparam.resthedgeangleenable = true;
+      stlparam.resthedgeanglefac = py::cast<double>(val);
+    }
+  }
+  if(kwargs.contains("resthsurfmeshcurvfac"))
+  {
+    auto val = kwargs.attr("pop")("resthsurfmeshcurvfac");
+    if(val.is_none())
+      stlparam.resthsurfmeshcurvenable = false;
+    else
+    {
+      stlparam.resthsurfmeshcurvenable = true;
+      stlparam.resthsurfmeshcurvfac = py::cast<double>(val);
+    }
+  }
+  if(kwargs.contains("resthlinelengthfac"))
+  {
+    auto val = kwargs.attr("pop")("resthlinelengthfac");
+    if(val.is_none())
+      stlparam.resthlinelengthenable = false;
+    else
+    {
+      stlparam.resthlinelengthenable = true;
+      stlparam.resthlinelengthfac = py::cast<double>(val);
+    }
+  }
+  if(kwargs.contains("recalc_h_opt"))
+    stlparam.recalc_h_opt = py::cast<bool>(kwargs.attr("pop")("recalc_h_opt"));
+}
+
 
 DLL_HEADER void ExportSTL(py::module & m)
 {
@@ -82,20 +194,27 @@ DLL_HEADER void ExportSTL(py::module & m)
                              MeshingParameters* pars, py::kwargs kwargs)
                          {
                            MeshingParameters mp;
-                           if(pars) mp = *pars;
+                           STLParameters stlparam;
+                           { py::gil_scoped_acquire aq;
+                             if(pars)
                              {
-                             py::gil_scoped_acquire aq;
+                               auto mp_flags = pars->geometrySpecificParameters;
-                             CreateMPfromKwargs(mp, kwargs);
+                               auto mp_kwargs = CreateDictFromFlags(mp_flags);
+                               CreateSTLParametersFromKwargs(stlparam, mp_kwargs);
+                               mp = *pars;
+                             }
+                             CreateSTLParametersFromKwargs(stlparam, kwargs);
+                             CreateMPfromKwargs(mp, kwargs); // this will throw if any kwargs are not passed
                            }
                            auto mesh = make_shared<Mesh>();
-                           SetGlobalMesh(mesh);
                            mesh->SetGeometry(geo);
                            ng_geometry = geo;
-                           geo->GenerateMesh(mesh,mp);
+                           SetGlobalMesh(mesh);
+                           STLMeshingDummy(geo.get(), mesh, mp, stlparam);
                            return mesh;
                          }, py::arg("mp") = nullptr,
       py::call_guard<py::gil_scoped_release>(),
-      meshingparameter_description.c_str())
+         (meshingparameter_description + stlparameter_description).c_str())
     ;
   m.def("LoadSTLGeometry", [] (const string & filename)
                            {

libsrc/stlgeom/stlgeom.cpp

@@ -13,15 +13,17 @@ int usechartnormal = 1;
 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 void STLMeshing (STLGeometry & geom,
-		 Mesh & mesh)
+		 Mesh & mesh,
+                 const MeshingParameters& mparam,
+                 const STLParameters& stlpar)
 {
   geom.Clear();
-  geom.BuildEdges();
+  geom.BuildEdges(stlpar);
-  geom.MakeAtlas(mesh);
+  geom.MakeAtlas(mesh, mparam, stlpar);
   if (multithread.terminate) { return; }
   geom.CalcFaceNums();
   geom.AddFaceEdges();
-  geom.LinkEdges();
+  geom.LinkEdges(stlpar);
 
   mesh.ClearFaceDescriptors();
   for (int i = 1; i <= geom.GetNOFaces(); i++)
@@ -93,9 +95,11 @@ void STLGeometry :: Save (string filename) const
 
 
 
+DLL_HEADER extern STLParameters stlparam;
 int STLGeometry :: GenerateMesh (shared_ptr<Mesh> & mesh, MeshingParameters & mparam)
 {
-  return STLMeshingDummy (this, mesh, mparam);
+  STLParameters stlpar = stlparam;
+  return STLMeshingDummy (this, mesh, mparam, stlpar);
 }
 
 
@@ -132,7 +136,7 @@ void STLGeometry :: STLInfo(double* data)
   data[7] = cons;
 }
 
-void STLGeometry :: MarkNonSmoothNormals()
+void STLGeometry :: MarkNonSmoothNormals(const STLParameters& stlparam)
 {
 
   PrintFnStart("Mark Non-Smooth Normals");
@@ -169,13 +173,13 @@ void STLGeometry :: MarkNonSmoothNormals()
 
 }
 
-void STLGeometry :: SmoothNormals()
+void STLGeometry :: SmoothNormals(const STLParameters& stlparam)
 {
   multithread.terminate = 0;
 
   //  UseExternalEdges();
 
-  BuildEdges();
+  BuildEdges(stlparam);
 
 
   DenseMatrix m(3), hm(3);
@@ -1240,13 +1244,13 @@ void STLGeometry :: ClearEdges()
 
 }
 
-void STLGeometry :: STLDoctorBuildEdges()
+void STLGeometry :: STLDoctorBuildEdges(const STLParameters& stlparam)
 {
   //  if (!trigsconverted) {return;}
   ClearEdges();
 
   meshlines.SetSize(0);
-  FindEdgesFromAngles();
+  FindEdgesFromAngles(stlparam);
 }
 
 void STLGeometry :: DeleteExternalEdgeAtSelected()
@@ -1737,7 +1741,7 @@ void STLGeometry :: InitMarkedTrigs()
     }
 }
 
-void STLGeometry :: MarkDirtyTrigs()
+void STLGeometry :: MarkDirtyTrigs(const STLParameters& stlparam)
 {
   PrintFnStart("mark dirty trigs");
   int i,j;
@@ -1813,12 +1817,12 @@ double STLGeometry :: CalcTrigBadness(int i)
 
 }
 
-void STLGeometry :: GeomSmoothRevertedTrigs()
+void STLGeometry :: GeomSmoothRevertedTrigs(const STLParameters& stlparam)
 {
   //double revertedangle = stldoctor.smoothangle/180.*M_PI;
   double fact = stldoctor.dirtytrigfact;
 
-  MarkRevertedTrigs();
+  MarkRevertedTrigs(stlparam);
 
   int i, j, k, l, p;
 
@@ -1860,13 +1864,13 @@ void STLGeometry :: GeomSmoothRevertedTrigs()
 	    }
 	}
     }
-  MarkRevertedTrigs();
+  MarkRevertedTrigs(stlparam);
 }
 
-void STLGeometry :: MarkRevertedTrigs()
+void STLGeometry :: MarkRevertedTrigs(const STLParameters& stlparam)
 {
   int i,j;
-  if (edgesperpoint.Size() != GetNP()) {BuildEdges();}
+  if (edgesperpoint.Size() != GetNP()) {BuildEdges(stlparam);}
 
   PrintFnStart("mark reverted trigs");
 
@@ -1906,11 +1910,11 @@ void STLGeometry :: MarkRevertedTrigs()
 
 }
 
-void STLGeometry :: SmoothDirtyTrigs()
+void STLGeometry :: SmoothDirtyTrigs(const STLParameters& stlparam)
 {
   PrintFnStart("smooth dirty trigs");
 
-  MarkDirtyTrigs();
+  MarkDirtyTrigs(stlparam);
 
   int i,j;
   int changed = 1;
@@ -1953,7 +1957,7 @@ void STLGeometry :: SmoothDirtyTrigs()
   calcedgedataanglesnew = 1;
 
 
-  MarkDirtyTrigs();
+  MarkDirtyTrigs(stlparam);
 
   int cnt = 0;
   for (i = 1; i <= GetNT(); i++)
@@ -2360,12 +2364,12 @@ int STLGeometry :: IsEdgeNum(int ap1, int ap2)
 }
 
 
-void STLGeometry :: BuildEdges()
+void STLGeometry :: BuildEdges(const STLParameters& stlparam)
 {
   //PrintFnStart("build edges");
   edges.SetSize(0);
   meshlines.SetSize(0);
-  FindEdgesFromAngles();
+  FindEdgesFromAngles(stlparam);
 }
 
 void STLGeometry :: UseExternalEdges()
@@ -2487,7 +2491,7 @@ void STLGeometry :: CalcEdgeDataAngles()
   PrintMessage (5,"calc edge data angles ... done");
 }
 
-void STLGeometry :: FindEdgesFromAngles()
+void STLGeometry :: FindEdgesFromAngles(const STLParameters& stlparam)
 {
   //  PrintFnStart("find edges from angles");
 
@@ -2714,7 +2718,7 @@ void STLGeometry :: AddFaceEdges()
   
 }
 
-void STLGeometry :: LinkEdges()
+void STLGeometry :: LinkEdges(const STLParameters& stlparam)
 {
   PushStatusF("Link Edges");
   PrintMessage(5,"have now ", GetNE(), " edges with yellow angle = ", stlparam.yangle, " degree");
@@ -3131,7 +3135,7 @@ int IsInArray(int n, const NgArray<int>& ia)
 }
 */
 
-void STLGeometry :: AddConeAndSpiralEdges()
+void STLGeometry :: AddConeAndSpiralEdges(const STLParameters& stlparam)
 {
   PrintMessage(5,"have now ", GetNE(), " edges with yellow angle = ", stlparam.yangle, " degree");
 

libsrc/stlgeom/stlgeom.hpp

@@ -40,7 +40,7 @@ namespace netgen
   }
   */
   
-  extern DLL_HEADER MeshingParameters mparam;
+// extern DLL_HEADER MeshingParameters mparam;
   
 
 
@@ -184,20 +184,20 @@ namespace netgen
     STLGeometry();
     virtual ~STLGeometry();
 
-    void DoArchive(Archive& ar)
+    void DoArchive(Archive& ar) override
     {
       STLTopology::DoArchive(ar);
     }
 
     void Clear();
 
-    virtual void Save (string filename) const;
+    virtual void Save (string filename) const override;
 
 
 	DLL_HEADER void STLInfo(double* data);
     //stldoctor:
-	DLL_HEADER void SmoothNormals();
+	DLL_HEADER void SmoothNormals(const STLParameters& stlparam);
-	DLL_HEADER void MarkNonSmoothNormals();
+	DLL_HEADER void MarkNonSmoothNormals(const STLParameters& stlparam);
 
 	DLL_HEADER void CalcEdgeData();
 	DLL_HEADER void CalcEdgeDataAngles();
@@ -251,7 +251,7 @@ namespace netgen
 	DLL_HEADER void AddClosedLinesToExternalEdges();
 	DLL_HEADER void AddLongLinesToExternalEdges();
 	DLL_HEADER void AddAllNotSingleLinesToExternalEdges();
-	DLL_HEADER void STLDoctorBuildEdges();
+	DLL_HEADER void STLDoctorBuildEdges(const STLParameters& stlparam);
 	DLL_HEADER void AddExternalEdgesFromGeomLine();
 	DLL_HEADER void DeleteDirtyExternalEdges();
 	DLL_HEADER void DeleteExternalEdgeAtSelected();
@@ -292,10 +292,10 @@ namespace netgen
 	DLL_HEADER int Vicinity(int trig) const;
 
 	DLL_HEADER void InitMarkedTrigs();
-	DLL_HEADER void MarkDirtyTrigs();
+	DLL_HEADER void MarkDirtyTrigs(const STLParameters& stlparam);
-	DLL_HEADER void SmoothDirtyTrigs();
+	DLL_HEADER void SmoothDirtyTrigs(const STLParameters& stlparam);
-	DLL_HEADER void GeomSmoothRevertedTrigs();
+	DLL_HEADER void GeomSmoothRevertedTrigs(const STLParameters& stlparam);
-	DLL_HEADER void MarkRevertedTrigs();
+	DLL_HEADER void MarkRevertedTrigs(const STLParameters& stlparam);
 	DLL_HEADER double CalcTrigBadness(int i);
 	DLL_HEADER int IsMarkedTrig(int trig) const;
 	DLL_HEADER void SetMarkedTrig(int trig, int num);
@@ -330,8 +330,8 @@ namespace netgen
     ///
 
     ///ReadTriangle->STLTriangle, initialise some important variables, always after load!!!
-    virtual void InitSTLGeometry (const NgArray<STLReadTriangle> & readtrigs);
+    virtual void InitSTLGeometry (const NgArray<STLReadTriangle> & readtrigs) override;
-    virtual void TopologyChanged(); //do some things, if topology changed!
+    virtual void TopologyChanged() override; //do some things, if topology changed!
     int CheckGeometryOverlapping();
 
     //get NO edges per point
@@ -353,18 +353,18 @@ namespace netgen
 
     ///Build EdgeSegments
     void ClearEdges();
-    void BuildEdges();
+    void BuildEdges(const STLParameters& stlparam);
     void BuildEdgesPerPoint();
     void UseExternalEdges();
 
 
-    void FindEdgesFromAngles();
+    void FindEdgesFromAngles(const STLParameters& stlparam);
     void CalcFaceNums();
     int GetNOBodys();
     int GetNOFaces() {return facecnt;}
-    void LinkEdges();
+    void LinkEdges(const STLParameters& stlparam);
 
-    void AddConeAndSpiralEdges();
+    void AddConeAndSpiralEdges(const STLParameters& stlparam);
     void AddFaceEdges(); //each face should have at least one starting edge (outherwise it won't be meshed)
 
     void GetDirtyChartTrigs(int chartnum, STLChart& chart, const NgArray<int>& outercharttrigs, 
@@ -382,7 +382,7 @@ namespace netgen
 
 
     //make charts with regions of a max. angle
-    void MakeAtlas(class Mesh & mesh);
+    void MakeAtlas(class Mesh & mesh, const MeshingParameters& mparam, const STLParameters& stlparam);
 
     //outerchartspertrig, sorted!
     int GetOCPTSize() const {return outerchartspertrig.Size();};
@@ -450,17 +450,16 @@ namespace netgen
     int LineEndPointsSet() const {return lineendpoints.Size() == GetNP();}
     void ClearLineEndPoints();
 
-	DLL_HEADER void RestrictLocalH(class Mesh & mesh, double gh);
+    DLL_HEADER void RestrictLocalH(class Mesh & mesh, double gh, const STLParameters& stlparam);
-    void RestrictLocalHCurv(class Mesh & mesh, double gh);
+    void RestrictLocalHCurv(class Mesh & mesh, double gh, const STLParameters& stlparam);
     void RestrictHChartDistOneChart(int chartnum, NgArray<int>& acttrigs, class Mesh & mesh, 
-				    double gh, double fact, double minh);
+				    double gh, double fact, double minh, const STLParameters& stlparam);
 
     friend class MeshingSTLSurface;
 
+    int GenerateMesh (shared_ptr<Mesh> & mesh, MeshingParameters & mparam) override;
     
-    virtual int GenerateMesh (shared_ptr<Mesh> & mesh, MeshingParameters & mparam);
+    virtual const Refinement & GetRefinement () const override;
-    
-    virtual const Refinement & GetRefinement () const;
   };
  
 
@@ -468,7 +467,8 @@ namespace netgen
 
 
 
-  extern int STLMeshingDummy (STLGeometry* stlgeometry, shared_ptr<Mesh> & mesh, MeshingParameters & mparam);
+extern int STLMeshingDummy (STLGeometry* stlgeometry, shared_ptr<Mesh> & mesh, const MeshingParameters & mparam,
+                            const STLParameters& stlpar);
 
 
 }

libsrc/stlgeom/stlgeomchart.cpp

@@ -17,7 +17,7 @@ int chartdebug = 0;
 
 
 
-void STLGeometry :: MakeAtlas(Mesh & mesh)
+void STLGeometry :: MakeAtlas(Mesh & mesh, const MeshingParameters& mparam, const STLParameters& stlparam)
 {
   // int timer1 = NgProfiler::CreateTimer ("makeatlas");
   /*
@@ -128,7 +128,7 @@ void STLGeometry :: MakeAtlas(Mesh & mesh)
 
       SetThreadPercent(100.0 * workedarea / atlasarea);
 
-      STLChart * chart = new STLChart(this);
+      STLChart * chart = new STLChart(this, stlparam);
       atlas.Append(chart);
 
       // *testout << "Chart " << atlas.Size() << endl;
@@ -520,7 +520,7 @@ void STLGeometry :: MakeAtlas(Mesh & mesh)
       // char key;
       // cin >> key;
       //calculate an estimate meshsize, not to produce too large outercharts, with factor 2 larger!
-      RestrictHChartDistOneChart(chartnum, chartdistacttrigs, mesh, h, 0.5, atlasminh);
+      RestrictHChartDistOneChart(chartnum, chartdistacttrigs, mesh, h, 0.5, atlasminh, stlparam);
       // NgProfiler::Print(stdout);
       // NgProfiler::StopTimer (timere2);      
       
@@ -572,7 +572,7 @@ void STLGeometry :: MakeAtlas(Mesh & mesh)
   mesh.SetMinimalH(mparam.minh);
   
   
-  AddConeAndSpiralEdges();
+  AddConeAndSpiralEdges(stlparam);
   
   PrintMessage(5,"Make Atlas finished");
 

libsrc/stlgeom/stlgeommesh.cpp

@@ -705,7 +705,7 @@ int STLGeometry :: ProjectNearest(Point<3> & p3d) const
 
 	
 //Restrict local h due to curvature for make atlas
-void STLGeometry :: RestrictLocalHCurv(class Mesh & mesh, double gh)
+void STLGeometry :: RestrictLocalHCurv(class Mesh & mesh, double gh, const STLParameters& stlparam)
 {
   PushStatusF("Restrict H due to surface curvature");
 
@@ -810,7 +810,7 @@ void STLGeometry :: RestrictLocalHCurv(class Mesh & mesh, double gh)
 
 }
   //restrict local h due to near edges and due to outer chart distance
-void STLGeometry :: RestrictLocalH(class Mesh & mesh, double gh)
+void STLGeometry :: RestrictLocalH(class Mesh & mesh, double gh, const STLParameters& stlparam)
 {
   
   //bei jedem Dreieck alle Nachbardreiecke vergleichen, und, fallskein Kante dazwischen,
@@ -1077,7 +1077,7 @@ void STLGeometry :: RestrictLocalH(class Mesh & mesh, double gh)
 	  if (multithread.terminate)
 	    {PopStatus(); return;}
 
-	  RestrictHChartDistOneChart(i, acttrigs, mesh, gh, 1., 0.);
+	  RestrictHChartDistOneChart(i, acttrigs, mesh, gh, 1., 0., stlparam);
 	}
       
       PopStatus();
@@ -1117,7 +1117,8 @@ void STLGeometry :: RestrictLocalH(class Mesh & mesh, double gh)
 }
 
 void STLGeometry :: RestrictHChartDistOneChart(int chartnum, NgArray<int>& acttrigs, 
-					       class Mesh & mesh, double gh, double fact, double minh)
+					       class Mesh & mesh, double gh, double fact, double minh,
+                                               const STLParameters& stlparam)
 {
   static int timer1 = NgProfiler::CreateTimer ("restrictH OneChart 1");
   static int timer2 = NgProfiler::CreateTimer ("restrictH OneChart 2");
@@ -1345,7 +1346,8 @@ void STLGeometry :: RestrictHChartDistOneChart(int chartnum, NgArray<int>& acttr
 }
 
 
-int STLMeshingDummy (STLGeometry* stlgeometry, shared_ptr<Mesh> & mesh, MeshingParameters & mparam)
+int STLMeshingDummy (STLGeometry* stlgeometry, shared_ptr<Mesh> & mesh, const MeshingParameters & mparam,
+                     const STLParameters& stlparam)
 {
   if (mparam.perfstepsstart > mparam.perfstepsend) return 0;
 
@@ -1372,7 +1374,7 @@ int STLMeshingDummy (STLGeometry* stlgeometry, shared_ptr<Mesh> & mesh, MeshingP
   
       //mesh->DeleteMesh();
  
-      STLMeshing (*stlgeometry, *mesh);
+      STLMeshing (*stlgeometry, *mesh, mparam, stlparam);
 
       stlgeometry->edgesfound = 1;
       stlgeometry->surfacemeshed = 0;
@@ -1399,7 +1401,7 @@ int STLMeshingDummy (STLGeometry* stlgeometry, shared_ptr<Mesh> & mesh, MeshingP
 	}
 
       success = 0;
-      int retval = STLSurfaceMeshing (*stlgeometry, *mesh);
+      int retval = STLSurfaceMeshing (*stlgeometry, *mesh, mparam, stlparam);
       if (retval == MESHING3_OK)
 	{
 	  PrintMessage(3,"Success !!!!");
@@ -1471,13 +1473,14 @@ int STLMeshingDummy (STLGeometry* stlgeometry, shared_ptr<Mesh> & mesh, MeshingP
 	      mesh -> LoadLocalMeshSize (mparam.meshsizefilename);	      
 	      mesh -> CalcLocalHFromSurfaceCurvature (mparam.grading, 
 						      stlparam.resthsurfmeshcurvfac);
-	      mparam.optimize2d = "cmsmSm";
+              MeshingParameters mpar = mparam;
-	      STLSurfaceOptimization (*stlgeometry, *mesh, mparam);
+	      mpar.optimize2d = "cmsmSm";
+	      STLSurfaceOptimization (*stlgeometry, *mesh, mpar);
 #ifdef STAT_STREAM
 	      (*statout) << GetTime() << " & ";
 #endif
 
-	      mparam.Render();
+	      mpar.Render();
 	    }
 	  stlgeometry->surfaceoptimized = 1;
 	}

libsrc/stlgeom/stlpkg.cpp

@@ -21,6 +21,8 @@ namespace netgen
 {
   DLL_HEADER extern shared_ptr<NetgenGeometry>  ng_geometry;
   DLL_HEADER extern shared_ptr<Mesh> mesh;
+  DLL_HEADER extern MeshingParameters mparam;
+  DLL_HEADER extern STLParameters stlparam;
 
   static VisualSceneSTLGeometry vsstlgeom;
   static VisualSceneSTLMeshing vsstlmeshing;
@@ -243,15 +245,15 @@ namespace netgen
 	  }
 	else if (strcmp (argv[1], "markdirtytrigs") == 0)
 	  {
-	    stlgeometry->MarkDirtyTrigs();
+	    stlgeometry->MarkDirtyTrigs(stlparam);
 	  }
 	else if (strcmp (argv[1], "smoothdirtytrigs") == 0)
 	  {
-	    stlgeometry->SmoothDirtyTrigs();
+	    stlgeometry->SmoothDirtyTrigs(stlparam);
 	  }
 	else if (strcmp (argv[1], "smoothrevertedtrigs") == 0)
 	  {
-	    stlgeometry->GeomSmoothRevertedTrigs();
+	    stlgeometry->GeomSmoothRevertedTrigs(stlparam);
 	  }
 	else if (strcmp (argv[1], "invertselectedtrig") == 0)
 	  {
@@ -306,11 +308,11 @@ namespace netgen
 	  }
 	else if (strcmp (argv[1], "smoothnormals") == 0)
 	  {
-	    stlgeometry->SmoothNormals();
+	    stlgeometry->SmoothNormals(stlparam);
 	  }
 	else if (strcmp (argv[1], "marknonsmoothnormals") == 0)
 	  {
-	    stlgeometry->MarkNonSmoothNormals();
+	    stlgeometry->MarkNonSmoothNormals(stlparam);
 	  }
 	else if (strcmp (argv[1], "addexternaledge") == 0)
 	  {
@@ -359,7 +361,7 @@ namespace netgen
 	  }
 	else if (strcmp (argv[1], "buildedges") == 0)
 	  {
-	    stlgeometry->STLDoctorBuildEdges();
+	    stlgeometry->STLDoctorBuildEdges(stlparam);
 	  }
 	else if (strcmp (argv[1], "confirmedge") == 0)
 	  {
@@ -526,7 +528,7 @@ namespace netgen
 	mesh -> SetLocalH (stlgeometry->GetBoundingBox().PMin() - Vec3d(10, 10, 10),
 			   stlgeometry->GetBoundingBox().PMax() + Vec3d(10, 10, 10),
 			   mparam.grading);
-	stlgeometry -> RestrictLocalH(*mesh, mparam.maxh);
+	stlgeometry -> RestrictLocalH(*mesh, mparam.maxh, stlparam);
 
 	if (stlparam.resthsurfmeshcurvenable)
 	  mesh -> CalcLocalHFromSurfaceCurvature (mparam.grading, 

libsrc/stlgeom/stltool.cpp

@@ -607,7 +607,8 @@ STLTopEdge :: STLTopEdge (int p1, int p2, int trig1, int trig2)
 //+++++++++++++++++++   STL CHART   +++++++++++++++++++++++++++++++
 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
-STLChart :: STLChart(STLGeometry * ageometry)
+STLChart :: STLChart(STLGeometry * ageometry, const STLParameters& astlparam)
+    : geometry(ageometry), stlparam(astlparam)
 {
   // charttrigs = new NgArray<int> (0,0);
   // outertrigs = new NgArray<int> (0,0);
@@ -1462,7 +1463,6 @@ void STLParameters :: Print (ostream & ost) const
 }
 
 
+DLL_HEADER extern STLParameters stlparam;
 STLParameters stlparam;
-
-
 }

libsrc/stlgeom/stltool.hpp

@@ -38,6 +38,7 @@ extern void FIOWriteString(ostream& ios, char* str, int len);
 typedef NgArray <int> * ArrayINTPTR;
 
 class STLGeometry;
+class STLParameters;
 
 class STLChart
 {
@@ -49,11 +50,12 @@ private:
 
   NgArray<twoint> olimit; //outer limit of outer chart
   NgArray<twoint> ilimit; //outer limit of inner chart
+  const STLParameters& stlparam;
 
 
 public:
   
-  STLChart(STLGeometry * ageometry);
+  STLChart(STLGeometry * ageometry, const STLParameters& astlparam);
   ~STLChart();
   void AddChartTrig(int i);
   void AddOuterTrig(int i);
@@ -227,64 +229,67 @@ DLL_HEADER extern STLDoctorParams stldoctor;
 
 
 
-class STLParameters
+// TODO change enable flag to optional parameters
+class DLL_HEADER STLParameters
 {
 public:
   /// angle for edge detection
-  double yangle;
+  double yangle = 30.;
   double contyangle; //edges continued with contyangle
   /// angle of geometry edge at which the mesher should set a point
-  double edgecornerangle;
+  double edgecornerangle = 60.;
   /// angle inside on chart
-  double chartangle;
+  double chartangle = 15.;
   /// angle for overlapping parts of char
-  double outerchartangle;
+  double outerchartangle = 70.;
   /// 0 .. no, 1 .. local, (2 .. global)
   int usesearchtree;
   ///
   double resthatlasfac; 
-  int resthatlasenable;
+  bool resthatlasenable;
   double atlasminh;
 
-  double resthsurfcurvfac; 
+  double resthsurfcurvfac = 1.; 
-  int resthsurfcurvenable;
+  bool resthsurfcurvenable = false;
 
-  double resthchartdistfac;
+  double resthchartdistfac = 1.5;
-  int resthchartdistenable;
+  bool resthchartdistenable = true;
 
-  double resthcloseedgefac;
+  double resthcloseedgefac = 2.;
-  int resthcloseedgeenable;
+  bool resthcloseedgeenable = true;
   
-  double resthedgeanglefac;
+  double resthedgeanglefac = 1.;
-  int resthedgeangleenable;
+  bool resthedgeangleenable = false;
   
-  double resthsurfmeshcurvfac;
+  double resthsurfmeshcurvfac = 2.;
-  int resthsurfmeshcurvenable;
+  bool resthsurfmeshcurvenable = false;
   
-  double resthlinelengthfac;
+  double resthlinelengthfac = 0.5;
-  int resthlinelengthenable;
+  bool resthlinelengthenable = true;
 
   ///
-  int recalc_h_opt;
+  bool recalc_h_opt = true;
   ///
   STLParameters();
   ///
   void Print (ostream & ost) const;
 };
 
-DLL_HEADER extern STLParameters stlparam;
-
 
 void STLMeshing (STLGeometry & geom,
-		 class Mesh & mesh);
+		 Mesh & mesh,
+                 const MeshingParameters& mparam,
+                 const STLParameters& stlpar);
 
 
 int STLSurfaceMeshing (STLGeometry & geom,
-			class Mesh & mesh);
+                       Mesh & mesh,
+                       const MeshingParameters& mparam,
+                       const STLParameters& stlpar);
 
 void STLSurfaceOptimization (STLGeometry & geom,
-			     class Mesh & mesh,
+			     Mesh & mesh,
-			     class MeshingParameters & mparam);
+			     const MeshingParameters & mparam);
 
 
 

ng/netgenpy.cpp

@@ -23,6 +23,7 @@ void DLL_HEADER ExportNgOCC(py::module &m);
 
 PYBIND11_MODULE(libngpy, ngpy)
 {
+  py::module::import("pyngcore");
     py::module meshing = ngpy.def_submodule("_meshing", "pybind meshing module");
     ExportNetgenMeshing(meshing);
     py::module csg = ngpy.def_submodule("_csg", "pybind csg module");

nglib/nglib.cpp

@@ -30,6 +30,8 @@ namespace netgen {
    extern void MeshFromSpline2D (SplineGeometry2d & geometry,
                                  shared_ptr<Mesh> & mesh, 
                                  MeshingParameters & mp);
+   extern MeshingParameters mparam;
+   DLL_HEADER extern STLParameters stlparam;
 }
 
 
@@ -667,7 +669,7 @@ namespace nglib
         }
       */
 
-      STLMeshing (*stlgeometry, *me);
+      STLMeshing (*stlgeometry, *me, mparam, stlparam);
 
       stlgeometry->edgesfound = 1;
       stlgeometry->surfacemeshed = 0;
@@ -709,7 +711,7 @@ namespace nglib
       stlgeometry->surfaceoptimized = 0;
       stlgeometry->volumemeshed = 0;
       */  
-      int retval = STLSurfaceMeshing (*stlgeometry, *me);
+      int retval = STLSurfaceMeshing (*stlgeometry, *me, mparam, stlparam);
       if (retval == MESHING3_OK)
       {
          (*mycout) << "Success !!!!" << endl;

python/meshing.py

@@ -1,22 +1,66 @@
 from .libngpy._meshing import *
 
 class _MeshsizeObject:
-    pass
+    @property
+    def very_coarse(self):
+        return MeshingParameters(curvaturesafety=1,
+                                 segmentsperedge=0.3,
+                                 grading=0.7,
+                                 resthsurfcurvfac=0.25,
+                                 resthchartdistfac=0.8,
+                                 resthlinelengthfac=0.2,
+                                 resthcloseedgefac=0.5,
+                                 resthminedgelen=0.002,
+                                 resthedgeanglefac=0.25,
+                                 resthsurfmeshcurvfac=1.)
+    @property
+    def coarse(self):
+        return MeshingParameters(curvaturesafety=1.5,
+                                 segmentsperedge=0.5,
+                                 grading=0.5,
+                                 resthsurfcurvfac=0.5,
+                                 resthchartdistfac=1,
+                                 resthlinelengthfac=0.35,
+                                 resthcloseedgefac=1,
+                                 resthminedgelen=0.02,
+                                 resthedgeanglefac=0.5,
+                                 resthsurfmeshcurvfac=1.5)
+    @property
+    def moderate(self):
+        return MeshingParameters(curvaturesafety=2,
+                                 segmentsperedge=1,
+                                 grading=0.3,
+                                 resthsurfcurvfac=1.,
+                                 resthchartdistfac=1.5,
+                                 resthlinelengthfac=0.5,
+                                 resthcloseedgefac=2,
+                                 resthminedgelen=0.2,
+                                 resthedgeanglefac=1,
+                                 resthsurfmeshcurvfac=2.)
+    @property
+    def fine(self):
+        return MeshingParameters(curvaturesafety=3,
+                                 segmentsperedge=2,
+                                 grading=0.2,
+                                 resthsurfcurvfac=1.5,
+                                 resthchartdistfac=2,
+                                 resthlinelengthfac=1.5,
+                                 resthcloseedgefac=3.5,
+                                 resthminedgelen=1.,
+                                 resthedgeanglefac=1.5,
+                                 resthsurfmeshcurvfac=3.)
+
+    @property
+    def very_fine(self):
+        return  MeshingParameters(curvaturesafety=5,
+                                  segmentsperedge=3,
+                                  grading=0.1,
+                                  resthsurfcurvfac=3,
+                                  resthchartdistfac=5,
+                                  resthlinelengthfac=3,
+                                  resthcloseedgefac=5,
+                                  resthminedgelen=2.,
+                                  resthedgeanglefac=3.,
+                                  resthsurfmeshcurvfac=5.)
 
 meshsize = _MeshsizeObject()
-
-meshsize.very_coarse = MeshingParameters(curvaturesafety=1,
-                                         segmentsperedge=0.3,
-                                         grading=0.7)
-meshsize.coarse = MeshingParameters(curvaturesafety=1.5,
-                                    segmentsperedge=0.5,
-                                    grading=0.5)
-meshsize.moderate = MeshingParameters(curvaturesafety=2,
-                                      segmentsperedge=1,
-                                      grading=0.3)
-meshsize.fine = MeshingParameters(curvaturesafety=3,
-                                  segmentsperedge=2,
-                                  grading=0.2)
-meshsize.very_fine = MeshingParameters(curvaturesafety=5,
-                                       segmentsperedge=3,
-                                       grading=0.1)

tests/pytest/test_savemesh.py

@@ -28,7 +28,7 @@ def CreateGeo():
 def test_BBNDsave():
     mesh = CreateGeo().GenerateMesh(maxh=0.4,perfstepsend = meshing.MeshingStep.MESHSURFACE)
     for i in range(2):
-        mesh.GenerateVolumeMesh(only3D_domain=i+1,maxh=0.4)
+        mesh.GenerateVolumeMesh(only3D_domain_nr=i+1,maxh=0.4)
     mesh.SetGeometry(None)
     mesh.Save("test.vol")
     mesh2 = meshing.Mesh()