Main

.vscode/settings.json

@@ -112,7 +112,8 @@
     "__verbose_abort": "cpp",
     "coroutine": "cpp",
     "expected": "cpp",
-    "source_location": "cpp"
+    "source_location": "cpp",
+    "booleanutils": "cpp"
   },
   "cmake.configureOnOpen": true,
   "C_Cpp.default.configurationProvider": "ms-vscode.cmake-tools",

package.json

@@ -66,7 +66,7 @@
   ],
   "devDependencies": {
     "@types/jest": "^29.5.14",
-    "@types/three": "^0.175.0",
+    "@types/three": "^0.176.0",
     "adm-zip": "^0.5.10",
     "cpy-cli": "^5.0.0",
     "esbuild": "^0.25.0",
@@ -75,7 +75,7 @@
     "make-dir-cli": "^4.0.0",
     "monaco-editor": "^0.52.0",
     "rimraf": "^6.0.0",
-    "three": "^0.175.0",
+    "three": "^0.176.0",
     "ts-jest": "^29.3.2",
     "ts-node": "^10.9.2",
     "typedoc": "^0.28.3",

src/cpp/test/io_helpers.cpp

@@ -160,7 +160,7 @@ namespace webifc::io
 
         for (uint32_t i = 0; i < geom.numFaces; i++)
         {
-            webifc::geometry::Face f = geom.GetFace(i);
+            bimGeometry::Face f = geom.GetFace(i);
             obj << "f " << (f.i0 + 1 + offset) << "// " << (f.i1 + 1 + offset) << "// " << (f.i2 + 1 + offset) << "//\n";
         }
 
@@ -231,7 +231,7 @@ namespace webifc::io
 
         for (uint32_t i = 0; i < geom.numFaces; i++)
         {
-            webifc::geometry::Face f = geom.GetFace(i);
+            bimGeometry::Face f = geom.GetFace(i);
             obj << "f " << (f.i0 + 1 + offset) << "// " << (f.i1 + 1 + offset) << "// " << (f.i2 + 1 + offset) << "//\n";
         }
 

src/cpp/test/web-ifc-test.cpp

@@ -462,7 +462,7 @@ int main()
     // std::string content = ReadFile("C:/Users/qmoya/Desktop/MODELS/15.ifc");
     // std::string content = ReadFile("C:/Users/qmoya/Desktop/MODELS/F_MA_160_ALT3.ifc");
     // std::string content = ReadFile("C:/Users/qmoya/Desktop/MODELS/1256.ifc");
-    std::string content = ReadFile("C:/Users/qmoya/Desktop/MODELS/15.ifc");
+    std::string content = ReadFile("C:/Users/qmoya/Desktop/MODELS/1092_A.ifc");
 
     struct LoaderSettings
     {
@@ -501,8 +501,8 @@ int main()
 
     start = ms();
 
-    SpecificLoadTest(loader, geometryLoader, 211736);
-    // auto meshes = LoadAllTest(loader, geometryLoader, -1);
+    // SpecificLoadTest(loader, geometryLoader, 3994);
+    auto meshes = LoadAllTest(loader, geometryLoader, -1);
     // auto rebars = GetAllRebars(loader, geometryLoader);
     // std::cout << GetLine(loader, 225) << std::endl;
     // auto alignments = GetAlignments(loader, geometryLoader);

src/cpp/wasm/web-ifc-wasm.cpp

@@ -14,13 +14,16 @@
 #include "../version.h"
 #include "../web-ifc/geometry/operations/bim-geometry/extrusion.h"
 #include "../web-ifc/geometry/operations/bim-geometry/sweep.h"
+#include "../web-ifc/geometry/operations/bim-geometry/circularSweep.h"
 #include "../web-ifc/geometry/operations/bim-geometry/revolution.h"
 #include "../web-ifc/geometry/operations/bim-geometry/cylindricalRevolution.h"
 #include "../web-ifc/geometry/operations/bim-geometry/parabola.h"
 #include "../web-ifc/geometry/operations/bim-geometry/clothoid.h"
 #include "../web-ifc/geometry/operations/bim-geometry/arc.h"
 #include "../web-ifc/geometry/operations/bim-geometry/alignment.h"
 #include "../web-ifc/geometry/operations/bim-geometry/utils.h"
+#include "../web-ifc/geometry/operations/bim-geometry/boolean.h"
+#include "../web-ifc/geometry/operations/bim-geometry/Profile.h"
 
 namespace webifc::parsing { 
     void p21encode(std::string_view input, std::ostringstream &output);
@@ -800,6 +803,12 @@ bimGeometry::Sweep CreateSweep()
     return bimGeometry::Sweep();
 }
 
+bimGeometry::CircularSweep CreateCircularSweep()
+{
+    return bimGeometry::CircularSweep();
+}
+
+
 bimGeometry::Revolve CreateRevolution()
 {
     return bimGeometry::Revolve();
@@ -830,6 +839,15 @@ bimGeometry::Alignment CreateAlignment()
     return bimGeometry::Alignment();
 }
 
+bimGeometry::Boolean CreateBoolean()
+{
+    return bimGeometry::Boolean();
+}
+
+bimGeometry::Profile CreateProfile()
+{
+    return bimGeometry::Profile();
+}
 
 EMSCRIPTEN_BINDINGS(my_module) {
 
@@ -842,8 +860,6 @@ EMSCRIPTEN_BINDINGS(my_module) {
         .function("GetSweptDiskSolid", &webifc::geometry::IfcGeometry::GetSweptDiskSolid)
         ;
 
-
-
     emscripten::value_object<glm::dvec4>("dvec4")
         .field("x", &glm::dvec4::x)
         .field("y", &glm::dvec4::y)
@@ -962,19 +978,26 @@ EMSCRIPTEN_BINDINGS(my_module) {
         .function("GetBuffers", &bimGeometry::AABB::GetBuffers)
         .function("SetValues", &bimGeometry::AABB::SetValues)
         ;
-
 
     emscripten::class_<bimGeometry::Extrusion>("Extrusion")
         .constructor<>()
         .function("GetBuffers", &bimGeometry::Extrusion::GetBuffers)
         .function("SetValues", &bimGeometry::Extrusion::SetValues)
+        .function("SetHoles", &bimGeometry::Extrusion::SetHoles)
+        .function("ClearHoles", &bimGeometry::Extrusion::ClearHoles)
         ;
 
     emscripten::class_<bimGeometry::Sweep>("Sweep")
         .constructor<>()
         .function("GetBuffers", &bimGeometry::Sweep::GetBuffers)
         .function("SetValues", &bimGeometry::Sweep::SetValues)
         ;
+
+    emscripten::class_<bimGeometry::CircularSweep>("CircularSweep")
+        .constructor<>()
+        .function("GetBuffers", &bimGeometry::CircularSweep::GetBuffers)
+        .function("SetValues", &bimGeometry::CircularSweep::SetValues)
+        ;
 
     emscripten::class_<bimGeometry::Revolve>("Revolution")
         .constructor<>()
@@ -1011,16 +1034,33 @@ EMSCRIPTEN_BINDINGS(my_module) {
         .function("GetBuffers", &bimGeometry::Alignment::GetBuffers)
         .function("SetValues", &bimGeometry::Alignment::SetValues)
         ;
+
+    emscripten::class_<bimGeometry::Boolean>("BooleanOperator")
+        .constructor<>()
+        .function("GetBuffers", &bimGeometry::Boolean::GetBuffers)
+        .function("SetValues", &bimGeometry::Boolean::SetValues)
+        .function("SetSecond", &bimGeometry::Boolean::SetSecond)
+        .function("clear", &bimGeometry::Boolean::clear)
+        ;
+
+    emscripten::class_<bimGeometry::Profile>("Profile")
+        .constructor<>()
+        .function("GetBuffers", &bimGeometry::Profile::GetBuffers)
+        .function("SetValues", &bimGeometry::Profile::SetValues)
+        ;
 
     emscripten::function("CreateAABB", &CreateAABB);
     emscripten::function("CreateExtrusion", &CreateExtrusion);
     emscripten::function("CreateSweep", &CreateSweep);
+    emscripten::function("CreateCircularSweep", &CreateCircularSweep);
     emscripten::function("CreateRevolution", &CreateRevolution);
     emscripten::function("CreateCylindricalRevolution", &CreateCylindricalRevolution);
     emscripten::function("CreateParabola", &CreateParabola);
     emscripten::function("CreateClothoid", &CreateClothoid);
     emscripten::function("CreateArc", &CreateArc);
     emscripten::function("CreateAlignment", &CreateAlignment);
+    emscripten::function("CreateBooleanOperator", &CreateBoolean);
+    emscripten::function("CreateProfile", &CreateProfile);
     emscripten::function("LoadAllGeometry", &LoadAllGeometry);
     emscripten::function("GetAllCrossSections", &GetAllCrossSections);
     emscripten::function("GetAllAlignments", &GetAllAlignments);

src/cpp/web-ifc/geometry/IfcGeometryLoader.cpp

@@ -2995,16 +2995,16 @@ IfcProfile IfcGeometryLoader::GetProfile(uint32_t expressID) const
   IfcCurve IfcGeometryLoader::GetLocalCurve(uint32_t expressID) const
   {
     spdlog::debug("[GetLocalCurve({})]",expressID);
-    for (uint32_t i = 0; i < LocalcurvesIndices.size(); i++)
+    for (uint32_t i = 0; i < _localcurvesIndices.size(); i++)
     {
-      if (LocalcurvesIndices[i] == expressID)
+      if (_localcurvesIndices[i] == expressID)
       {
-        return LocalCurvesList[i];
+        return _localCurvesList[i];
       }
     }
     IfcCurve curve = GetCurve(expressID, 3, false);
-    LocalcurvesIndices.push_back(expressID);
-    LocalCurvesList.push_back(curve);
+    _localcurvesIndices.push_back(expressID);
+    _localCurvesList.push_back(curve);
     return curve;
   }
 
@@ -3638,8 +3638,9 @@ IfcProfile IfcGeometryLoader::GetProfile(uint32_t expressID) const
         _loader.GetTokenType();
         return _loader.GetDoubleArgument();
       }
-	  spdlog::warn("[ReadLengthMeasure()] Unrecognised type {}", LengthMeasureLabel);
+	  spdlog::warn("[ReadLenghtMeasure()] Unrecognised type {}", LengthMeasureLabel);
     }
+	return 0.0;
   }
 
   std::vector<IfcSegmentIndexSelect> IfcGeometryLoader::ReadCurveIndices() const
@@ -3685,4 +3686,15 @@ IfcProfile IfcGeometryLoader::GetProfile(uint32_t expressID) const
     return result;
   }
 
+  IfcGeometryLoader* IfcGeometryLoader::Clone(const webifc::parsing::IfcLoader &newLoader) const {
+    IfcGeometryLoader * newGeomLoader = new IfcGeometryLoader(newLoader, _schemaManager, _relVoids, _relNests, _relAggregates, _styledItems, _relMaterials, _materialDefinitions, _linearScalingFactor, _squaredScalingFactor, _cubicScalingFactor, _angularScalingFactor, _angleUnits, _circleSegments, _localCurvesList, _localcurvesIndices, _expressIDToPlacement);
+    return newGeomLoader;
+  }
+
+
+  IfcGeometryLoader::IfcGeometryLoader(const webifc::parsing::IfcLoader &loader, const webifc::schema::IfcSchemaManager &schemaManager, const std::unordered_map<uint32_t, std::vector<uint32_t>> &relVoids, const std::unordered_map<uint32_t, std::vector<uint32_t>> &relNests, const std::unordered_map<uint32_t, std::vector<uint32_t>> &relAggregates, const std::unordered_map<uint32_t, std::vector<std::pair<uint32_t, uint32_t>>> &styledItems, const std::unordered_map<uint32_t, std::vector<std::pair<uint32_t, uint32_t>>> &relMaterials, const std::unordered_map<uint32_t, std::vector<std::pair<uint32_t, uint32_t>>> &materialDefinitions, double linearScalingFactor, double squaredScalingFactor, double cubicScalingFactor, double angularScalingFactor, std::string angleUnits, uint16_t circleSegments, std::vector<IfcCurve> &localCurvesList, std::vector<uint32_t> &localcurvesIndices, std::unordered_map<uint32_t, glm::dmat4> expressIDToPlacement) 
+  : _loader(loader),_schemaManager(schemaManager),_relVoids(relVoids),_relNests(relNests),_relAggregates(relAggregates),_styledItems(styledItems),_relMaterials(relMaterials), _materialDefinitions(materialDefinitions), _linearScalingFactor(linearScalingFactor), _squaredScalingFactor(squaredScalingFactor), _cubicScalingFactor(cubicScalingFactor), _angularScalingFactor(angularScalingFactor), _angleUnits(angleUnits), _circleSegments(circleSegments),_localCurvesList(localCurvesList), _localcurvesIndices(localcurvesIndices), _expressIDToPlacement(expressIDToPlacement)
+  {}
+
+
 }

src/cpp/web-ifc/geometry/IfcGeometryLoader.h

@@ -56,7 +56,9 @@ namespace webifc::geometry
     double GetLinearScalingFactor() const;
     std::string GetAngleUnits() const;
     void Clear() const;
+    IfcGeometryLoader* Clone(const webifc::parsing::IfcLoader &loader) const;
   private:
+    IfcGeometryLoader(const webifc::parsing::IfcLoader &loader, const webifc::schema::IfcSchemaManager &schemaManager, const std::unordered_map<uint32_t, std::vector<uint32_t>> &relVoids, const std::unordered_map<uint32_t, std::vector<uint32_t>> &relNests, const std::unordered_map<uint32_t, std::vector<uint32_t>> &relAggregates, const std::unordered_map<uint32_t, std::vector<std::pair<uint32_t, uint32_t>>> &styledItems, const std::unordered_map<uint32_t, std::vector<std::pair<uint32_t, uint32_t>>> &relMaterials, const std::unordered_map<uint32_t, std::vector<std::pair<uint32_t, uint32_t>>> &materialDefinitions, double linearScalingFactor, double squaredScalingFactor, double cubicScalingFactor, double angularScalingFactor, std::string angleUnits, uint16_t circleSegments, std::vector<IfcCurve> &localCurvesList, std::vector<uint32_t> &localcurvesIndices, std::unordered_map<uint32_t, glm::dmat4> expressIDToPlacement);
     IfcCurve GetAlignmentCurve(uint32_t expressID, uint32_t parentExpressID = -1) const;
     IfcProfile GetProfileByLine(uint32_t expressID) const;
     glm::dvec3 GetVertexPoint(uint32_t expressID) const;
@@ -79,8 +81,8 @@ namespace webifc::geometry
     double _angularScalingFactor = 1;
     std::string _angleUnits;
     uint16_t _circleSegments;
-    mutable std::vector<IfcCurve> LocalCurvesList;
-    mutable std::vector<uint32_t> LocalcurvesIndices;
+    mutable std::vector<IfcCurve> _localCurvesList;
+    mutable std::vector<uint32_t> _localcurvesIndices;
     std::unordered_map<uint32_t, std::vector<uint32_t>> PopulateRelVoidsMap();
     std::unordered_map<uint32_t, std::vector<uint32_t>> PopulateRelNestsMap();
     std::unordered_map<uint32_t, std::vector<uint32_t>> PopulateRelAggregatesMap();

src/cpp/web-ifc/geometry/IfcGeometryProcessor.cpp

@@ -1650,7 +1650,7 @@ namespace webifc::geometry
 
     IfcGeometry IfcGeometryProcessor::BoolProcess(const std::vector<IfcGeometry> &firstGeoms, std::vector<IfcGeometry> &secondGeoms, std::string op)
     {
-        return boolEngine.BoolProcess(firstGeoms, secondGeoms, op);
+        return _boolEngine.BoolProcess(firstGeoms, secondGeoms, op);
     }
 
     std::vector<uint32_t> IfcGeometryProcessor::Read2DArrayOfThreeIndices()
@@ -1990,4 +1990,14 @@ namespace webifc::geometry
         return convertToWebIfc(fuzzybools::Subtract(firstEngGeom, secondEngGeom));
     }
 
+    IfcGeometryProcessor * IfcGeometryProcessor::Clone(const webifc::parsing::IfcLoader &newLoader) const {
+        IfcGeometryProcessor *newProcessor = new IfcGeometryProcessor(_settings,_expressIDToGeometry,*_geometryLoader.Clone(newLoader),_transformation, newLoader, _boolEngine, _schemaManager, _isCoordinated, _expressIdCyl, _expressIdRect, _coordinationMatrix, _predefinedCylinder, _predefinedCube);
+        return newProcessor;
+    }
+
+    IfcGeometryProcessor::IfcGeometryProcessor(const IfcGeometrySettings &settings,std::unordered_map<uint32_t, IfcGeometry> expressIDToGeometry,const IfcGeometryLoader &geometryLoader,glm::dmat4 transformation, const parsing::IfcLoader &loader, booleanManager boolEngine, const schema::IfcSchemaManager &schemaManager, bool isCoordinated, uint32_t expressIdCyl, uint32_t expressIdRect, glm::dmat4 coordinationMatrix, IfcGeometry predefinedCylinder, IfcGeometry predefinedCube)
+    : _settings(settings), _expressIDToGeometry(expressIDToGeometry), _geometryLoader(geometryLoader), _transformation(transformation), _loader(loader), _boolEngine(boolEngine), _schemaManager(schemaManager), _isCoordinated(isCoordinated), _expressIdCyl(expressIdCyl), _expressIdRect(expressIdRect), _coordinationMatrix(coordinationMatrix), _predefinedCylinder(predefinedCylinder), _predefinedCube(predefinedCube)
+    {}
+
+
 }

src/cpp/web-ifc/geometry/IfcGeometryProcessor.h

@@ -53,9 +53,12 @@ namespace webifc::geometry
         std::array<double, 16> GetFlatCoordinationMatrix() const;
         glm::dmat4 GetCoordinationMatrix() const;
         void Clear();
-		IfcGeometrySettings _settings;
-
-        protected:
+        IfcGeometryProcessor * Clone(const webifc::parsing::IfcLoader &loader) const;
+
+        private:
+        IfcGeometryProcessor(const IfcGeometrySettings &settings,std::unordered_map<uint32_t, IfcGeometry> expressIDToGeometry,const IfcGeometryLoader &geometryLoader,glm::dmat4 transformation, const parsing::IfcLoader &loader, booleanManager boolEngine, const schema::IfcSchemaManager &schemaManager, bool isCoordinated, uint32_t expressIdCyl, uint32_t expressIdRect, glm::dmat4 coordinationMatrix, IfcGeometry predefinedCylinder, IfcGeometry predefinedCube);
+        IfcGeometrySettings _settings;
+
         std::optional<glm::dvec4> GetStyleItemFromExpressId(uint32_t expressID);
         void AddFaceToGeometry(uint32_t expressID, IfcGeometry &geometry);
         IfcGeometry GetBrep(uint32_t expressID);
@@ -65,16 +68,16 @@ namespace webifc::geometry
         const IfcGeometryLoader _geometryLoader;
         glm::dmat4 _transformation = glm::dmat4(1.0);
         const parsing::IfcLoader &_loader;
-        booleanManager boolEngine;
+        booleanManager _boolEngine;
         const schema::IfcSchemaManager &_schemaManager;
         bool _isCoordinated = false;
-        uint32_t expressIdCyl = 0;
-        uint32_t expressIdRect = 0;
+        uint32_t _expressIdCyl = 0;
+        uint32_t _expressIdRect = 0;
         glm::dmat4 _coordinationMatrix = glm::dmat4(1.0);
         void AddComposedMeshToFlatMesh(IfcFlatMesh &flatMesh, const IfcComposedMesh &composedMesh, const glm::dmat4 &parentMatrix = glm::dmat4(1), const glm::dvec4 &color = glm::dvec4(1, 1, 1, 1), bool hasColor = false);
         std::vector<uint32_t> Read2DArrayOfThreeIndices();
         void ReadIndexedPolygonalFace(uint32_t expressID, std::vector<IfcBound3D> &bounds, const std::vector<glm::dvec3> &points);
-        IfcGeometry predefinedCylinder;
-        IfcGeometry predefinedCube;
+        IfcGeometry _predefinedCylinder;
+        IfcGeometry _predefinedCube;
   };
 }

src/cpp/web-ifc/geometry/operations/bim-geometry/boolean.cpp

@@ -0,0 +1,61 @@
+#include <vector>
+#include <algorithm>
+#include <glm/glm.hpp>
+#include "boolean.h"
+#include "epsilons.h"
+#include "geometry.h"
+#include "utils.h"
+#include "booleanUtils.h"
+
+using Vec = glm::dvec3;
+
+namespace bimGeometry {
+
+    Buffers Boolean::GetBuffers()
+    {
+        Buffers buffers;
+
+        Geometry geom = BoolProcess(geometry, seconds, op);
+
+        for (int r = 0; r < geom.numFaces; r++)
+        {
+            bimGeometry::Face f = geom.GetFace(r);
+            buffers.AddTri(geom.GetPoint(f.i0), geom.GetPoint(f.i1),  geom.GetPoint(f.i2));
+        }
+
+        return buffers;
+    }
+
+    void Boolean::SetValues(std::vector<double> triangles_, std::string op_) {
+        op = op_;
+        geometry = Geometry();
+        for (size_t i = 0; i + 8 < triangles_.size(); i += 9) {
+            geometry.AddFace(
+                glm::dvec3(triangles_[i], triangles_[i + 1], triangles_[i + 2]),
+                glm::dvec3(triangles_[i + 3], triangles_[i + 4], triangles_[i + 5]),
+                glm::dvec3(triangles_[i + 6], triangles_[i + 7], triangles_[i + 8])
+            );
+        }
+        geometry.buildPlanes();
+    }
+
+    void Boolean::SetSecond(std::vector<double> triangles_) {
+        Geometry newGeometry = Geometry();
+        for (size_t i = 0; i + 8 < triangles_.size(); i += 9) {
+            newGeometry.AddFace(
+                glm::dvec3(triangles_[i], triangles_[i + 1], triangles_[i + 2]),
+                glm::dvec3(triangles_[i + 3], triangles_[i + 4], triangles_[i + 5]),
+                glm::dvec3(triangles_[i + 6], triangles_[i + 7], triangles_[i + 8])
+            );
+        }
+        newGeometry.buildPlanes();
+        seconds.push_back(newGeometry);
+    }
+
+    void Boolean::clear()
+    {
+        geometry = Geometry();
+        seconds.clear();
+        op = "";
+    }
+}