Read tetrahedron volume

.gitignore

@@ -14,6 +14,7 @@ src/*.json
 
 .vs/
 .vscode/settings.json
+.vscode/settings.dev.json
 .vscode/launch.json
 .vscode/tasks.json
 

.vscode/settings.dev.json

@@ -8,12 +8,8 @@
   "C_Cpp.intelliSenseEngine": "disabled",
   "clangd.arguments": ["-log=verbose",
                           "-pretty",
-                          "--background-index",
+                          "--background-index", 
                           "--query-driver=/usr/bin/g++"
   ],
-  "clangd.fallbackFlags": ["-std=c++17"],
-	"lldb.showDisassembly": "never",
-	"lldb.launch.preRunCommands": [
-		"settings set target.import-std-module true"
-	]
+  "clangd.fallbackFlags": ["-std=c++17"]
 }

src/app/launcher.cpp

@@ -150,8 +150,9 @@ meshlib::meshers::StaircaseMesherOptions readStaircaseMesherOptions(const nlohma
     }
 
     meshlib::meshers::StaircaseMesherOptions res;
-
-    res.isVolume = isVolume;
+    if (isVolume){
+        res.volumeGroups.insert(0);
+    }
     if (mesherConfig.contains("options") && 
         mesherConfig["options"].contains("compress")) {
         res.compress = mesherConfig["options"]["compress"];
@@ -160,7 +161,7 @@ meshlib::meshers::StaircaseMesherOptions readStaircaseMesherOptions(const nlohma
     return res;
 }
 
-meshlib::meshers::ConformalMesherOptions readConformalMesherOptions(const nlohmann::json& fileData, const std::optional<nlohmann::json>& override)
+meshlib::meshers::ConformalMesherOptions readConformalMesherOptions(const nlohmann::json& fileData, bool isVolume, const std::optional<nlohmann::json>& override)
 {    
     nlohmann::json mesherConfig;
     if (override.has_value()) {
@@ -170,6 +171,9 @@ meshlib::meshers::ConformalMesherOptions readConformalMesherOptions(const nlohma
     }
 
     meshlib::meshers::ConformalMesherOptions res;
+    if (isVolume){
+        res.volumeGroups.insert(0);
+    }
     if (mesherConfig.contains("options")) {
         res.snapperOptions.edgePoints = mesherConfig["options"]["edgePoints"];
         res.snapperOptions.forbiddenLength = mesherConfig["options"]["forbiddenLength"];
@@ -204,7 +208,7 @@ std::unique_ptr<meshlib::meshers::MesherBase> buildMesher(const Mesh& in, const
             readStaircaseMesherOptions(fileData, objDef.isVolume, objDef.mesherOverride)
         });
     } else if (mesherType == meshlib::app::conformal_mesher) {
-        return std::make_unique<meshlib::meshers::ConformalMesher>(meshlib::meshers::ConformalMesher{in, readConformalMesherOptions(fileData, objDef.mesherOverride)});
+        return std::make_unique<meshlib::meshers::ConformalMesher>(meshlib::meshers::ConformalMesher{in, readConformalMesherOptions(fileData, objDef.isVolume, objDef.mesherOverride)});
     } else {
         throw std::runtime_error("Unsupported mesher type");
     }

src/app/vtkIO.cpp

@@ -3,6 +3,7 @@
 #include <vtkCellData.h>
 #include <vtkCellType.h>
 #include <vtkTriangle.h>
+#include <vtkTetra.h>
 #include <vtkQuad.h>
 #include <vtkLine.h>
 #include <vtkVertex.h>
@@ -76,6 +77,7 @@ Element vtkCellToElement(vtkCell* cell)
     vtkVertex* vertex = nullptr;
     vtkLine* line = nullptr;
     vtkTriangle* triangle = nullptr;
+    vtkTetra* tetra = nullptr;
 
     switch (cell->GetCellType()) {
     case VTK_VERTEX:
@@ -102,6 +104,17 @@ Element vtkCellToElement(vtkCell* cell)
         };
         elem.type = meshlib::Element::Type::Surface;
         break;
+
+    case VTK_TETRA:
+        tetra = vtkTetra::SafeDownCast(cell);
+        elem.vertices = {
+            CoordinateId(tetra->GetPointIds()->GetId(0)),
+            CoordinateId(tetra->GetPointIds()->GetId(1)),
+            CoordinateId(tetra->GetPointIds()->GetId(2)),
+            CoordinateId(tetra->GetPointIds()->GetId(3))
+        };
+        elem.type = meshlib::Element::Type::Volume;
+        break;
     }
 
     return elem;
@@ -131,6 +144,7 @@ Mesh vtuToMesh(vtkUnstructuredGrid* vtu)
         }
     } else {
         mesh.groups.resize(1);
+        auto k = vtu->GetNumberOfCells();
         mesh.groups[0].elements.reserve(vtu->GetNumberOfCells());
         for (vtkIdType i = 0; i < vtu->GetNumberOfCells(); i++) {
             mesh.groups[0].elements.push_back(
@@ -169,8 +183,13 @@ vtkSmartPointer<vtkStringArray> toVTKGroupNamesArray(const Mesh& mesh)
     groupNamesArray->SetName("groupNames");
     groupNamesArray->SetNumberOfComponents(1);
 
-    for (const auto& group : mesh.groups) {
-        groupNamesArray->InsertNextValue(group.name.c_str());
+    // for (const auto& group : mesh.groups) {
+    //     groupNamesArray->InsertNextValue(group.name.c_str());
+    // }
+    for (auto g = 0; g < mesh.groups.size(); g++) {
+        for (auto e = 0; e < mesh.groups[g].elements.size(); e++) {
+            groupNamesArray->InsertNextValue( mesh.groups[g].name.c_str() );
+        }
     }
 
     return groupNamesArray;

src/cgal/filler/Filler.cpp

@@ -253,6 +253,29 @@ void sliceAlignedByGrid(
 	);
 }
 
+void sliceAlignedByGridAndRemove(
+	Filler::GridSlices& slices,
+	const Polyhedron& m,
+	const Grid& g,
+	const Priority& priority)
+{
+
+	auto polygons{ buildGridPlanesPolygons(makeFacesCCWOriented(m), g)};
+	const std::array<Axis, 3> axis{ X, Y, Z };
+
+	std::for_each(
+#ifdef TESSELLATOR_EXECUTION_POLICIES
+		std::execution::par,
+#endif
+		axis.begin(), axis.end(),
+		[&](const auto& x) {
+			for (const auto& [i, polygon] : polygons[x]) {
+				slices[x][i].remove(polygon, priority);
+			}
+		}
+	);
+}
+
 Priority Filler::getGroupPriority(const GroupId& gId) const
 {
 	if (gId < groupPriorities_.size()) {
@@ -508,7 +531,8 @@ FillerPolyhedrons buildFillerPolyhedrons(
 Filler::Filler(
 	const Mesh& volumeMesh,
 	const Mesh& surfaceMesh,
-	const std::vector<Priority>& groupPriorities)
+	const std::vector<Priority>& groupPriorities,
+	const FillerMode& fillerMode)
 {
 	utils::meshTools::checkNoNullAreasExist(volumeMesh);
 	utils::meshTools::checkNoNullAreasExist(surfaceMesh);
@@ -547,7 +571,11 @@ Filler::Filler(
 		log("Slicing surfaces", 2);
 		sliceNonAlignedByGrid(slices_, fP.surfaces, grid_, pr, SlicingMode::Surface);
 		log("Slicing aligned", 2);
-		sliceAlignedByGrid(slices_, fP.aligned, grid_, pr);
+		if (fillerMode == FillerMode::insideAndOutside) {
+			sliceAlignedByGrid(slices_, fP.aligned, grid_, pr);
+		} else if (fillerMode == FillerMode::onlyInside){
+			sliceAlignedByGridAndRemove(slices_, fP.aligned, grid_, pr);
+		}
 		log("Building segments arrays", 2);
 		buildSegmentsArray(segmentsArray_, fP.aligned, grid_, pr);
 		buildSegmentsArray(segmentsArray_, fP.volumes, grid_, pr);

src/cgal/filler/Filler.h

@@ -9,17 +9,26 @@
 
 namespace meshlib::cgal::filler {
 
+enum class FillerMode{
+	insideAndOutside,
+	onlyInside
+};
+
+
 class Filler {
-public:
+	public:
 	using Slices = std::map<SliceNumber, Slice>;
 	using GridSlices = std::array<Slices, 3>;
 	using SegmentsArray = std::map<ArrayIndex, Segments>;
 	using GridSegmentsArray = std::array<SegmentsArray, 3>;
-
+
+	FillerMode mode = FillerMode::insideAndOutside;
+
 	Filler(
 		const Mesh& volumeMesh, 
 		const Mesh& surfaceMesh = Mesh(),
-		const std::vector<Priority>& groupPriorities = std::vector<Priority>());
+		const std::vector<Priority>& groupPriorities = std::vector<Priority>(),
+		const FillerMode& mode = FillerMode::insideAndOutside);
 	Filler(const Filler&) = delete;
 	Filler(Filler&&) = default;
 	Filler& operator=(const Filler&) = delete;
@@ -32,7 +41,7 @@ class Filler {
 	FillingState getFillingState(const CellIndex&) const;
 
 	Mesh getMeshFilling() const;
-
+	GridSlices getSlices() const {return slices_;};
 private:
 	GridSlices slices_;
 	GridSegmentsArray segmentsArray_;
@@ -42,6 +51,7 @@ class Filler {
 
 	void mergeGroupsWithSamePriority(Groups& vGroups, Groups& sGroups);
 
+
 };
 
 

src/cgal/filler/Slice.cpp

@@ -183,6 +183,21 @@ void Slice::add(const Polylines2& polylines, const Priority& pr)
 	}
 }
 
+void Slice::remove(const Polylines2& polylines, const Priority& pr)
+{
+	SliceData& sd = data_[pr];
+
+	for (const auto& p : polylines) {
+		if (p.size() == 1) {
+			continue;
+		}
+		auto r{ removeSegmentsContainedInAnyAxis(p) };
+		for (const auto& rr : r){
+			sd.lines.erase(std::find(sd.lines.begin(), sd.lines.end(), rr));
+		}
+	}
+}
+
 FillingState::FillingState(const FillingType& t) :
 	type{ t },
 	priority_{ 0 }
@@ -261,6 +276,18 @@ void Slice::add(const HPolygonSet& polygons, const Priority& pr)
 	removeInSuperiorPriorities(pr);
 }
 
+void Slice::remove(const HPolygonSet& polygons, const Priority& pr)
+{
+	if (polygons.isEmpty()) {
+		return;
+	}
+
+	SliceData& sd = data_[pr];
+	sd.surfaces.difference(polygons);
+
+	removeInSuperiorPriorities(pr);
+}
+
 void Slice::mergeLines(const Slice& lhs)
 {
 	for (const auto& [pr, sd] : lhs.data_) {

src/cgal/filler/Slice.h

@@ -85,8 +85,10 @@ class Slice {
 	FillingState getFillingState(const ArrayIndex&) const;
 
 	void add(const Polylines2&, const Priority&);
+	void remove(const Polylines2&, const Priority&);
 	void addAsPolygon(const Polylines2&, const Priority&);
 	void add(const HPolygonSet&, const Priority&);
+	void remove(const HPolygonSet&, const Priority&);
 	void mergeLines(const Slice& lhs);
 	void buildSearchMap();
 	void buildTriangulations();

src/core/CMakeLists.txt

@@ -10,4 +10,7 @@ add_library(tessellator-core
     "Staircaser.cpp"
 )
 
-target_link_libraries(tessellator-core tessellator-utils)
+target_link_libraries(tessellator-core 
+    tessellator-utils
+    tessellator-cgal
+    CGAL::CGAL)

src/core/Slicer.cpp

@@ -38,7 +38,6 @@ void orient(const Coordinates& coords,
     }
 }
 
-
 Slicer::Slicer(const Mesh& input, const std::vector<Element::Type>& dimensionPolicy, const SlicerOptions& opts) :
     GridTools(input.grid),
     opts_(opts)

src/core/Slicer.h

@@ -24,8 +24,6 @@ class Slicer : public utils::GridTools {
 
     Slicer(const Mesh&, const std::vector<Element::Type>& dimensionPolicy = {}, const SlicerOptions& opts = SlicerOptions());
     Mesh getMesh() const { return mesh_; };
-
-
     static Elements buildTrianglesFromPath(const std::vector<Coordinate>&, const std::vector<CoordinateId>&);
 
 private:
@@ -53,6 +51,11 @@ class Slicer : public utils::GridTools {
         const Cell&, const Coordinate&,
         const Cell&, const Coordinate&) const;
 
+    // IdSet buildGroupIntersectionsWithGridPlanes(
+    //     Coordinates& sCoords,
+    //     const std::vector<Element>& elements);
+
+
 };
 
 }

src/meshers/MesherBaseOptions.h

@@ -7,7 +7,6 @@ namespace meshlib::meshers {
 
 class MesherBaseOptions {
 public:
-    bool isVolume = false;
     std::set<GroupId> volumeGroups{};
 };