Tessellator | Dynamic dimension meshing

src/app/launcher.cpp

@@ -1,7 +1,7 @@
 #include "launcher.h"
 #include "vtkIO.h"
 
-#include "meshers/StructuredMesher.h"
+#include "meshers/StaircaseMesher.h"
 #include "utils/GridTools.h"
 
 #include <boost/program_options.hpp>
@@ -85,7 +85,7 @@ int launcher(int argc, const char* argv[])
     Mesh mesh = readMesh(inputFilename);
 
     // Mesh
-    meshlib::meshers::StructuredMesher mesher{mesh};
+    meshlib::meshers::StaircaseMesher mesher{mesh};
     Mesh resultMesh = mesher.mesh();
 
     std::filesystem::path outputFolder = getFolder(inputFilename);

src/core/Collapser.cpp

@@ -11,8 +11,15 @@ namespace core {
 
 using namespace utils;
 
-Collapser::Collapser(const Mesh& in, int decimalPlaces)
-{    
+Collapser::Collapser(const Mesh& in, int decimalPlaces, const std::vector<Element::Type>& dimensionPolicy)
+{
+    if (dimensionPolicy.size() == 0) {
+        dimensionPolicy_ = std::vector<Element::Type>(in.groups.size(), Element::Type::Surface);
+    }
+    else {
+        dimensionPolicy_ = dimensionPolicy;
+    }
+
     mesh_ = in;
     double factor = std::pow(10.0, decimalPlaces);
     for (auto& v : mesh_.coordinates) {
@@ -23,7 +30,7 @@ Collapser::Collapser(const Mesh& in, int decimalPlaces)
     RedundancyCleaner::cleanCoords(mesh_);
 
     collapseDegenerateElements(mesh_, 0.4 / (factor * factor));
-    RedundancyCleaner::removeOverlappedDimensionOneAndLowerElementsAndEquivalentSurfaces(mesh_);
+    RedundancyCleaner::removeOverlappedElementsByDimension(mesh_, dimensionPolicy_);
     utils::meshTools::checkNoNullAreasExist(mesh_);
 }
 

src/core/Collapser.h

@@ -7,12 +7,14 @@ namespace core {
 
 class Collapser {
 public:
-	Collapser(const Mesh&, int decimalPlaces);
+	Collapser(const Mesh&, int decimalPlaces, const std::vector<Element::Type>& dimensionPolicy = {});
 
 	Mesh getMesh() const { return mesh_; }
 
 private:
 	Mesh mesh_;
+	std::vector<Element::Type> dimensionPolicy_;
+
 	void collapseDegenerateElements(Mesh& m, const double& areaThreshold);
 };
 

src/core/Slicer.cpp

@@ -39,14 +39,14 @@ void orient(const Coordinates& coords,
 }
 
 
-Slicer::Slicer(const Mesh& input, const SlicerOptions& opts) : 
+Slicer::Slicer(const Mesh& input, const std::vector<Element::Type>& dimensionPolicy, const SlicerOptions& opts) :
     GridTools(input.grid),
     opts_(opts)
 {
     // Ensures that all coordinates have a fixed number of decimal places.
     Mesh collapsed = input;
     collapsed.coordinates = absoluteToRelative(collapsed.coordinates);
-    collapsed = Collapser{ collapsed, opts_.initialCollapsingDecimalPlaces }.getMesh();
+    collapsed = Collapser{ collapsed, opts_.initialCollapsingDecimalPlaces, dimensionPolicy }.getMesh();
     collapsed.coordinates = relativeToAbsolute(collapsed.coordinates);
 
     // Slices.

src/core/Slicer.h

@@ -22,7 +22,7 @@ class Slicer : public utils::GridTools {
     typedef std::vector<PlaneAlignedPolyline> PlaneAlignedPolylines;
     typedef std::vector<Coordinate> PolylineV;
 
-    Slicer(const Mesh&, const SlicerOptions& opts = SlicerOptions());
+    Slicer(const Mesh&, const std::vector<Element::Type>& dimensionPolicy = {}, const SlicerOptions& opts = SlicerOptions());
     Mesh getMesh() const { return mesh_; };
 
 
@@ -31,6 +31,7 @@ class Slicer : public utils::GridTools {
 private:
     std::mutex writingCoordinates_;
     std::mutex writingElements_;
+
     Mesh mesh_;
     SlicerOptions opts_;
 

src/meshers/CMakeLists.txt

@@ -2,7 +2,7 @@ message(STATUS "Creating build system for tessellator-meshers")
 
 add_library(tessellator-meshers
     "MesherBase.cpp"
-    "StructuredMesher.cpp"
+    "StaircaseMesher.cpp"
     "OffgridMesher.cpp"
     "ConformalMesher.cpp"
 )

src/meshers/StructuredMesher.cpp → src/meshers/StaircaseMesher.cpp

@@ -1,4 +1,4 @@
-#include "StructuredMesher.h"
+#include "StaircaseMesher.h"
 
 #include <iostream>
 
@@ -17,7 +17,7 @@ using namespace utils;
 using namespace core;
 using namespace meshTools;
 
-StructuredMesher::StructuredMesher(const Mesh& inputMesh, int decimalPlacesInCollapser) :
+StaircaseMesher::StaircaseMesher(const Mesh& inputMesh, int decimalPlacesInCollapser) :
     MesherBase(inputMesh),
     decimalPlacesInCollapser_(decimalPlacesInCollapser)
 {
@@ -30,14 +30,14 @@ StructuredMesher::StructuredMesher(const Mesh& inputMesh, int decimalPlacesInCol
     log("Surface mesh built succesfully.", 1);
 }
 
-Mesh StructuredMesher::buildSurfaceMesh(const Mesh& inputMesh, const Mesh & volumeSurface)
+Mesh StaircaseMesher::buildSurfaceMesh(const Mesh& inputMesh, const Mesh & volumeSurface)
 {
     auto resultMesh = buildMeshFilteringElements(inputMesh, isNotTetrahedron);
     mergeMesh(resultMesh, volumeSurface);
     return resultMesh;
 }
 
-void StructuredMesher::process(Mesh& mesh) const
+void StaircaseMesher::process(Mesh& mesh) const
 {
 
     const auto slicingGrid{ buildSlicingGrid(originalGrid_, enlargedGrid_) };
@@ -47,14 +47,16 @@ void StructuredMesher::process(Mesh& mesh) const
         return;
     }
 
+    auto dimensions = getHighestDimensionByGroup(mesh);
+
     log("Slicing.", 1);
     mesh.grid = slicingGrid;
-    mesh = Slicer{ mesh }.getMesh();
+    mesh = Slicer{ mesh, dimensions }.getMesh();
 
     logNumberOfTriangles(countMeshElementsIf(mesh, isTriangle));
 
     log("Collapsing.", 1);
-    mesh = Collapser(mesh, decimalPlacesInCollapser_).getMesh();
+    mesh = Collapser(mesh, decimalPlacesInCollapser_, dimensions).getMesh();
 
     logNumberOfTriangles(countMeshElementsIf(mesh, isTriangle));
 
@@ -65,7 +67,7 @@ void StructuredMesher::process(Mesh& mesh) const
     logNumberOfLines(countMeshElementsIf(mesh, isLine));
 
     log("Removing repeated and overlapping elements.", 1);   
-    RedundancyCleaner::removeOverlappedDimensionOneAndLowerElementsAndEquivalentSurfaces(mesh);
+    RedundancyCleaner::removeOverlappedElementsByDimension(mesh, dimensions);
 
     logNumberOfQuads(countMeshElementsIf(mesh, isQuad));
     logNumberOfLines(countMeshElementsIf(mesh, isLine));
@@ -82,7 +84,7 @@ void StructuredMesher::process(Mesh& mesh) const
 }
 
 
-Mesh StructuredMesher::mesh() const
+Mesh StaircaseMesher::mesh() const
 {
     return surfaceMesh_;
 }

src/meshers/StructuredMesher.h → src/meshers/StaircaseMesher.h

@@ -5,10 +5,10 @@
 
 namespace meshlib::meshers {
 
-class StructuredMesher : public MesherBase {
+class StaircaseMesher : public MesherBase {
 public:
-	StructuredMesher(const Mesh& in, int decimalPlacesInCollapser = 4);
-	virtual ~StructuredMesher() = default;
+	StaircaseMesher(const Mesh& in, int decimalPlacesInCollapser = 4);
+	virtual ~StaircaseMesher() = default;
 	Mesh mesh() const;
 
 private:

src/utils/MeshTools.cpp

@@ -22,6 +22,24 @@ std::size_t countMeshElementsIf(const Mesh& mesh, std::function<bool(const Eleme
     return res;
 }
 
+std::vector<Element::Type> getHighestDimensionByGroup(const Mesh& mesh) {
+    std::vector<Element::Type> highestDimensions;
+
+    highestDimensions.reserve(mesh.groups.size());
+
+    for (auto & group : mesh.groups) {
+        auto highestValue = Element::Type::None;
+        for (auto& element : group.elements) {
+            if (highestValue < element.type) {
+                highestValue = element.type;
+            }
+        }
+        highestDimensions.push_back(highestValue);
+    }
+
+    return highestDimensions;
+}
+
 Mesh duplicateCoordinatesUsedByDifferentGroups(const Mesh& mesh)
 {
     Mesh res = mesh;

src/utils/MeshTools.h

@@ -21,6 +21,7 @@ static bool isTetrahedron(const Element& e) { return e.isTetrahedron(); }
 static bool isNotTetrahedron(const Element& e) { return !e.isTetrahedron(); }
 
 std::size_t countMeshElementsIf(const Mesh& mesh, std::function<bool(const Element&)> countFilter);
+std::vector<Element::Type> getHighestDimensionByGroup(const Mesh& mesh);
 
 Mesh buildMeshFilteringElements(
 	const Mesh& in, std::function<bool(const Element&)> filter);