Merge branch 'netgen-matthias' into 'master'

Netgen matthias

Several enhancements of the Python interface:
- Cone in csg
- Set/Get transparency and visibility of top level objects
- Set background color (useful to display csg objects in opengl windows created with python)

Changes in cpp code (and python interface):
- Boundary layers with different heights/materials

See merge request !1

libsrc/csg/python_csg.cpp

@@ -251,6 +251,12 @@ DLL_HEADER void ExportCSG()
                                       Solid * sol = new Solid (sp);
                                       return make_shared<SPSolid> (sol);
                                     }));
+  bp::def ("Cone", FunctionPointer([](Point<3> a, Point<3> b, double ra, double rb)
+                                       {
+                                         Cone * cyl = new Cone (a, b, ra, rb);
+                                         Solid * sol = new Solid (cyl);
+                                         return make_shared<SPSolid> (sol);
+                                       }));
   bp::def ("Cylinder", FunctionPointer([](Point<3> a, Point<3> b, double r)
                                        {
                                          Cylinder * cyl = new Cylinder (a, b, r);
@@ -350,11 +356,48 @@ DLL_HEADER void ExportCSG()
                   }
                 delete bcname;
               }
+            return tlonr;
 
           }),
          (bp::arg("self"), bp::arg("solid"), bp::arg("bcmod")=bp::list())
          )
 
+    .def("CloseSurfaces", FunctionPointer
+         ([] (CSGeometry & self, shared_ptr<SPSolid> s1, shared_ptr<SPSolid> s2, bp::list aslices )
+          {
+            Array<int> si1, si2;
+            s1->GetSolid()->GetSurfaceIndices (si1);
+            s2->GetSolid()->GetSurfaceIndices (si2);
+            cout << "surface ids1 = " << si1 << endl;
+            cout << "surface ids2 = " << si2 << endl;
+
+            Flags flags;
+
+            try
+            {
+                int n = bp::len(aslices);
+                Array<double> slices(n);
+                for(int i=0; i<n; i++)
+                {
+                    slices[i]= bp::extract<double>(aslices[i])();
+                }
+                flags.SetFlag("slices", slices);
+            }
+            catch( bp::error_already_set const & ) {
+                cout << "caught python error:" << endl;
+                PyErr_Print();
+            }
+
+            const TopLevelObject * domain = nullptr;
+            self.AddIdentification
+              (new CloseSurfaceIdentification
+               (self.GetNIdentifications()+1, self,
+                self.GetSurface (si1[0]), self.GetSurface (si2[0]),
+                domain,
+                flags));
+          }),
+         (bp::arg("self"), bp::arg("solid1"), bp::arg("solid2"), bp::arg("slices"))
+         )
     .def("CloseSurfaces", FunctionPointer
          ([] (CSGeometry & self, shared_ptr<SPSolid> s1, shared_ptr<SPSolid> s2, int reflevels)
           {
@@ -375,7 +418,36 @@ DLL_HEADER void ExportCSG()
           }),
          (bp::arg("self"), bp::arg("solid1"), bp::arg("solid2"), bp::arg("reflevels")=2)
          )
-          
+    .def("GetTransparent", FunctionPointer
+         ([] (CSGeometry & self, int tlonr)
+          {
+            return self.GetTopLevelObject(tlonr)->GetTransparent();
+          }),
+         (bp::arg("self"), bp::arg("tlonr"))
+         )
+    .def("SetTransparent", FunctionPointer
+         ([] (CSGeometry & self, int tlonr, bool transparent)
+          {
+            self.GetTopLevelObject(tlonr)->SetTransparent(transparent);
+          }),
+         (bp::arg("self"), bp::arg("tlonr"), bp::arg("transparent"))
+         )
+
+    .def("GetVisible", FunctionPointer
+         ([] (CSGeometry & self, int tlonr)
+          {
+            return self.GetTopLevelObject(tlonr)->GetVisible();
+          }),
+         (bp::arg("self"), bp::arg("tlonr"))
+         )
+    .def("SetVisible", FunctionPointer
+         ([] (CSGeometry & self, int tlonr, bool visible)
+          {
+            self.GetTopLevelObject(tlonr)->SetVisible(visible);
+          }),
+         (bp::arg("self"), bp::arg("tlonr"), bp::arg("visible"))
+         )
+
     .add_property ("ntlo", &CSGeometry::GetNTopLevelObjects)
     ;
 

libsrc/csg/vscsg.cpp

@@ -503,6 +503,8 @@ DLL_HEADER void ExportCSGVis()
 		.def("Draw", &VisualSceneGeometry::DrawScene)
 		;
 
+    bp::def("SetBackGroundColor", &VisualSceneGeometry::SetBackGroundColor);
+
 	bp::def("VS", FunctionPointer
 		([](CSGeometry & geom)
 	{

libsrc/meshing/boundarylayer.cpp

@@ -155,6 +155,7 @@ namespace netgen
       int prismlayers = blp.prismlayers;
       double hfirst = blp.hfirst;
       double growthfactor = blp.growthfactor;
+      Array<double> heights (blp.heights);
 
       bool grow_edges = false; // grow layer at edges
       
@@ -179,13 +180,20 @@ namespace netgen
 
           double layerht = hfirst;
           
-          if(growthfactor == 1)
+          if(heights.Size()>0)
             {
-              layerht = layer * hfirst;
+              layerht = heights[layer-1];
             }
           else
             {
-              layerht = hfirst*(pow(growthfactor,(layer+1)) - 1)/(growthfactor - 1);
+              if(growthfactor == 1)
+                {
+                  layerht = layer * hfirst;
+                }
+              else
+                {
+                  layerht = hfirst*(pow(growthfactor,(layer+1)) - 1)/(growthfactor - 1);
+                }
             }
           
          cout << "Layer Height = " << layerht << endl;
@@ -510,7 +518,10 @@ namespace netgen
                  Element el(types[classify]);
                  for (int i = 0; i < 6; i++)
                    el[i] = nums[vertices[classify][i]];
-                 el.SetIndex(blp.new_matnr);
+                   if(blp.new_matnrs.Size() > 0)
+                      el.SetIndex(blp.new_matnrs[layer-1]);
+                   else
+                      el.SetIndex(blp.new_matnr);
                  // cout << "el = " << el << endl;
                  if (classify != 0)
                    mesh.AddVolumeElement(el);

libsrc/meshing/boundarylayer.hpp

@@ -13,6 +13,8 @@ class BoundaryLayerParameters
 public:
   // parameters by Philippose ..
   Array<int> surfid;
+  Array<double> heights;
+  Array<double> new_matnrs;
   int prismlayers = 1;
   int bulk_matnr = 1;
   int new_matnr = 1;

libsrc/meshing/python_mesh.cpp

@@ -338,6 +338,37 @@ DLL_HEADER void ExportNetgenMeshing()
            }))
 
     .def ("BoundaryLayer", FunctionPointer 
+          ([](Mesh & self, int bc, bp::list thicknesses, int volnr, bp::list materials)
+           {
+             int n = bp::len(thicknesses);
+             BoundaryLayerParameters blp;
+
+             for (int i = 1; i <= self.GetNFD(); i++)
+               if (self.GetFaceDescriptor(i).BCProperty() == bc)
+                   blp.surfid.Append (i);
+
+             cout << "add layer at surfaces: " << blp.surfid << endl;
+
+             blp.prismlayers = n;
+             blp.growthfactor = 1.0;
+
+             // find max domain nr
+             int maxind = 0;
+             for (ElementIndex ei = 0; ei < self.GetNE(); ei++)
+               maxind = max (maxind, self[ei].GetIndex());
+             cout << "maxind = " << maxind << endl;
+             for ( int i=0; i<n; i++ )
+               {
+                 blp.heights.Append( bp::extract<double>(thicknesses[i])()) ;
+                 blp.new_matnrs.Append( maxind+1+i );
+                 self.SetMaterial (maxind+1+i, bp::extract<string>(materials[i])().c_str());
+               }
+             blp.bulk_matnr = volnr;
+             GenerateBoundaryLayer (self, blp);
+           }
+           ))
+
+    .def ("BoundaryLayer", FunctionPointer
           ([](Mesh & self, int bc, double thickness, int volnr, string material)
            {
              BoundaryLayerParameters blp;

python/csg.py

@@ -14,6 +14,7 @@ if __platform.startswith('win'):
 
 
 CSGeometry.VS = csgvis.VS
+SetBackGroundColor = csgvis.SetBackGroundColor
 del csgvis
 
 def VS (obj):