ThatOpen · beachtom · Jan 12, 2026 · Mar 1, 2025 · Mar 1, 2025 · Mar 5, 2025
diff --git a/package-lock.json b/package-lock.json
diff --git a/src/cpp/test/dumpToThree.h b/src/cpp/test/dumpToThree.h
@@ -4,6 +4,7 @@
 
 #pragma once 
 
+#include <fstream>
 #include <vector>
 #include <string>
 #include <sstream>
@@ -25,7 +26,7 @@ namespace webifc::dump
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>DumpCurveToHtml</title>
+    <title>IFC Geometry Viewer</title>
     <style>
         body { margin: 0; overflow: hidden; }
         canvas { display: block; }
@@ -47,7 +48,7 @@ namespace webifc::dump
         const controls = new THREE.OrbitControls(camera, renderer.domElement);
         controls.enableDamping = true;
         controls.dampingFactor = 0.05;
-        controls.screenSpacePanning = true; // Allow panning in XY plane
+        controls.screenSpacePanning = true;
         controls.minDistance = 1;
         controls.maxDistance = 500;
         controls.mouseButtons = {
@@ -57,21 +58,34 @@ namespace webifc::dump
         };
         controls.enablePan = true;
         controls.panSpeed = 0.5;
-        controls.up = new THREE.Vector3(0, 0, 1); // Ensure Z is up for rotations
-        const ambientLight = new THREE.AmbientLight(0xffffff, 0.5);
+        controls.up = new THREE.Vector3(0, 0, 1);
+
+        // Lighting setup
+        const ambientLight = new THREE.AmbientLight(0xffffff, 0.4); // Soft ambient light
         scene.add(ambientLight);
-        const directionalLight = new THREE.DirectionalLight(0xffffff, 0.5);
-        directionalLight.position.set(1, 1, 1);
-        scene.add(directionalLight);
+        const directionalLight1 = new THREE.DirectionalLight(0xffffff, 0.6); // Primary light
+        directionalLight1.position.set(1, 1, 1).normalize();
+        scene.add(directionalLight1);
+        const directionalLight2 = new THREE.DirectionalLight(0xffffff, 0.4); // Secondary light to reduce shadows
+        directionalLight2.position.set(-1, -1, 1).normalize();
+        scene.add(directionalLight2);
 
         const objData = "{}";
-        const blackMaterial = new THREE.LineBasicMaterial({ color: 0x000000, linewidth: 2 });
-        const grayMaterial = new THREE.LineBasicMaterial({ color: 0x888888, linewidth: 2 });
+        const meshMaterial = new THREE.MeshStandardMaterial({ 
+            color: 0x888888, 
+            roughness: 0.7, 
+            metalness: 0.1, 
+            side: THREE.DoubleSide ,
+opacity: 0.7
+        });
+        const lineMaterial = new THREE.LineBasicMaterial({ color: 0x000000, linewidth: 2 });
+        const edgeMaterial = new THREE.LineBasicMaterial({ color: 0x333333, linewidth: 2 });
 
-        // Parse OBJ data manually to create individual line segments
+        // Parse OBJ data for vertices, lines, and faces
         function parseOBJ(objText) {
             const vertices = [];
             const lines = [];
+            const faces = [];
             const linesArray = objText.split('\n');
             linesArray.forEach(line => {
                 line = line.trim();
@@ -80,37 +94,70 @@ namespace webifc::dump
                     vertices.push(new THREE.Vector3(parts[0], parts[1], parts[2]));
                 } else if (line.startsWith('l ')) {
                     const indices = line.split(/\s+/).slice(1).map(i => parseInt(i) - 1);
-                    lines.push(indices);
+                    if (indices.length >= 2) {
+                        lines.push(indices);
+                    }
+                } else if (line.startsWith('f ')) {
+                    const indices = line.split(/\s+/).slice(1).map(part => parseInt(part.split('/')[0]) - 1);
+                    if (indices.length >= 3) {
+                        faces.push(indices.slice(0, 3)); // Only triangles
+                    }
                 }
             });
-            return { vertices, lines };
+            return { vertices, lines, faces };
         }
 
-        // Create individual Line objects for each segment
-        const { vertices, lines } = parseOBJ(objData);
+        // Create mesh if faces exist
+        const { vertices, lines, faces } = parseOBJ(objData);
+        if (faces.length > 0) {
+            const geometry = new THREE.BufferGeometry();
+            const positions = new Float32Array(vertices.length * 3);
+            const indices = new Uint32Array(faces.length * 3);
+            vertices.forEach((v, i) => {
+                positions[i * 3] = v.x;
+                positions[i * 3 + 1] = v.y;
+                positions[i * 3 + 2] = v.z;
+            });
+            faces.forEach((f, i) => {
+                indices[i * 3] = f[0];
+                indices[i * 3 + 1] = f[1];
+                indices[i * 3 + 2] = f[2];
+            });
+            geometry.setAttribute('position', new THREE.BufferAttribute(positions, 3));
+            geometry.setIndex(new THREE.BufferAttribute(indices, 1));
+            geometry.computeVertexNormals();
+            const mesh = new THREE.Mesh(geometry, meshMaterial);
+            scene.add(mesh);
+
+            // Add wireframe lines for triangle edges
+            const edges = new THREE.EdgesGeometry(geometry, 1); // Threshold angle of 1 degree
+            const edgeLines = new THREE.LineSegments(edges, edgeMaterial);
+            scene.add(edgeLines);
+        }
+
+        // Create lines if lines exist
         lines.forEach((lineIndices, index) => {
             const geometry = new THREE.BufferGeometry().setFromPoints([
                 vertices[lineIndices[0]],
                 vertices[lineIndices[1]]
             ]);
-            const material = (index % 2 === 0) ? blackMaterial : grayMaterial;
-            const line = new THREE.Line(geometry, material);
+            const line = new THREE.Line(geometry, lineMaterial);
             scene.add(line);
         });
 
-        // Compute bounding box from vertices
+        // Compute bounding box
         const box = new THREE.Box3();
         vertices.forEach(vertex => box.expandByPoint(vertex));
         const minPoint = box.min;
         const center = box.getCenter(new THREE.Vector3());
 
-        // Add XY grid (10x10 lines, 10m spacing, 100x100m total) in XY plane at Z=0, positioned at minPoint
+        // Add XY grid (100x100m, 10m spacing) at Z=min
         const grid = new THREE.GridHelper(100, 10, 0x888888, 0x888888);
-        grid.rotation.x = -Math.PI / 2; // Rotate grid to lie in XY plane with Z up
-        grid.position.set(minPoint.x, minPoint.y, minPoint.z); // Position at min point
+        grid.rotation.x = -Math.PI / 2;
+        grid.position.set(minPoint.x, minPoint.y, minPoint.z);
         scene.add(grid);
 
-        // Add coordinate axes (X: red, Y: green, Z: blue, 200m length), positioned at minPoint
+        // Add coordinate axes (X: red, Y: green, Z: blue, 200m length)
         const axesGroup = new THREE.Group();
         axesGroup.position.set(minPoint.x, minPoint.y, minPoint.z);
         const axesMaterialX = new THREE.LineBasicMaterial({ color: 0xff0000 });
@@ -133,13 +180,24 @@ namespace webifc::dump
         axesGroup.add(zAxis);
         scene.add(axesGroup);
 
-        // Zoom to the bounding box
+        // Zoom to bounding box
         const size = box.getSize(new THREE.Vector3());
-        const maxDim = Math.max(size.x, size.y, size.z);
+        let maxDim = Math.max(size.x, size.y, size.z);
+        if (maxDim < 0.0001) {
+            maxDim = 1; // Prevent division by zero
+        }
+        const aspect = window.innerWidth / window.innerHeight;
         const fov = camera.fov * (Math.PI / 180);
-        let cameraDistance = maxDim / Math.tan(fov / 2);
+        const fovHorizontal = 2 * Math.atan(Math.tan(fov / 2) * aspect);
+        const maxDimHorizontal = Math.max(size.x, size.y);
+        let cameraDistance = Math.max(
+            maxDim / Math.tan(fov / 2),
+            maxDimHorizontal / Math.tan(fovHorizontal / 2)
+        );
         cameraDistance *= 1.1; // Padding
-        camera.position.set(center.x, center.y, center.z + cameraDistance);
+        cameraDistance = Math.max(cameraDistance, camera.near * 1.1);
+        const offset = cameraDistance / Math.sqrt(3);
+        camera.position.set(center.x + offset, center.y + offset, center.z + offset);
         camera.lookAt(center);
         controls.target.copy(center);
 
@@ -464,7 +522,7 @@ namespace webifc::dump
         return obj.str();
     }
 
-    inline std::string ToObjThree(const webifc::geometry::IfcGeometry& geom, size_t& offset, glm::dmat4 transform, double inputScale = 1.0)
+    inline std::string ToObjThree(const webifc::geometry::IfcGeometry& geom, size_t& offset, const glm::dmat4& transform, double inputScale = 1.0)
     {
         std::stringstream obj;
         double scale = inputScale;
@@ -521,7 +579,8 @@ namespace webifc::dump
     {
         size_t offset = 0;
         std::ofstream out(path.c_str());
-        out << ToObjThree(geom, offset, glm::dmat4(1), inputScale);
+        glm::dmat4 mat(1);
+        out << ToObjThree(geom, offset, mat, inputScale);
     }
 
     inline std::string ToObjThree(webifc::geometry::IfcGeometry& geom, size_t& offset, glm::dmat4 transform = glm::dmat4(1))
@@ -548,17 +607,49 @@ namespace webifc::dump
         std::string complete;
         for (auto& geom : mesh.geometries)
         {
-            auto flatGeom = processor.GetGeometry(geom.geometryExpressID);
+            webifc::geometry::IfcGeometry flatGeom = processor.GetGeometry(geom.geometryExpressID);
             glm::dmat4 trans = mat * geom.transformation;
             complete += ToObjThree(flatGeom, offset, trans);
         }
         return complete;
     }
 
-    inline void DumpIfcGeometryThree(webifc::geometry::IfcGeometry& geom, std::string filename)
+    // Modified makeThreeJSViewer for IfcGeometry (triangle mesh)
+    inline std::string makeThreeJSViewer(const std::vector<webifc::geometry::IfcGeometry>& vecGeom, double inputScale = 1.0)
     {
+        std::stringstream obj;
         size_t offset = 0;
-        writeFile(filename, ToObjThree(geom, offset));
+        glm::dmat4 mat(1);
+        for (const webifc::geometry::IfcGeometry& geom : vecGeom)
+        {
+            obj << ToObjThree(geom, offset, mat, inputScale);
+        }
+
+        // Escape OBJ data for embedding
+        std::string objData = obj.str();
+        std::string escapedObjData;
+        for (char c : objData)
+        {
+            if (c == '\n') escapedObjData += "\\n";
+            else if (c == '"') escapedObjData += "\\\"";
+            else escapedObjData += c;
+        }
+
+        // Embed in HTML template
+        std::string html = THREE_JS_VIEWER_TEMPLATE;
+        size_t pos = html.find(R"({})");
+        if (pos != std::string::npos)
+        {
+            html.replace(pos, 2, escapedObjData);
+        }
+
+        return html;
+    }
+
+    inline void DumpIfcGeometryThree(std::vector<webifc::geometry::IfcGeometry> vecGeom, std::string filename, double epsNormal = 1e-8, double epsDist = 1e-6, double inputScale = 1.0)
+    {
+        std::string viewer = makeThreeJSViewer(vecGeom, inputScale);
+        writeFile(filename, viewer);
     }
 
     inline void DumpFlatMeshThree(webifc::geometry::IfcFlatMesh& mesh, webifc::geometry::IfcGeometryProcessor& processor, std::string filename)

diff --git a/src/cpp/web-ifc/geometry/IfcGeometryLoader.cpp b/src/cpp/web-ifc/geometry/IfcGeometryLoader.cpp
@@ -193,16 +193,17 @@ namespace webifc::geometry
           double length = glm::distance(point1, previousPoint);
           sumLength += length;
 
+          if (sumLength > maxDistance)
+          {
+              break;
+          }
+
           if (sumLength >= minDistance)
           {
               glm::dmat4 result = BasisCurve.getPlacementAtDistance(sumLength, IfcCurve::CurvePlacementMode::TangentAsZAxis);
               mapPlacements.insert({ sumLength, result });
           }
-
-          if (sumLength > maxDistance)
-          {
-              break;
-          }
+
           previousPoint = point1;
       }
 
@@ -2204,7 +2205,8 @@ namespace webifc::geometry
             }
         }
         curve.arcSegments.push_back(curve.points.size());
-        const int numPointsCurrentArc = _circleSegments;
+        int numPointsCurrentArc = _circleSegments;
+        numPointsCurrentArc = std::max(numPointsCurrentArc, 4);
         double deltaAngle = openingAngleRad / (numPointsCurrentArc - 1);
         double angle = startRad;
         std::vector<glm::dvec3> points;
@@ -2328,8 +2330,6 @@ namespace webifc::geometry
         }
         break;
     }
-
-
     case schema::IFCGRADIENTCURVE:
     {
         // IfcGradientCurve -----------------------------------------------------------
@@ -3488,6 +3488,7 @@ namespace webifc::geometry
         for (uint32_t i = 0; i < profile.curve.points.size(); i++)
         {
           profile.curve.points[i] = transformation * glm::dvec3(profile.curve.points[i].x, profile.curve.points[i].y, 1);
+          profile.curve.points[i].z = 0;
         }
       }
       else

diff --git a/src/cpp/web-ifc/geometry/IfcGeometryProcessor.cpp b/src/cpp/web-ifc/geometry/IfcGeometryProcessor.cpp
@@ -6,6 +6,7 @@
 
 #if defined(DEBUG_DUMP_SVG) || defined(DUMP_CSG_MESHES)
 #include "../../test/io_helpers.h"
+#include "../../test/dumpToThree.h"
 #endif
 
 #include "IfcGeometryProcessor.h"
@@ -193,6 +194,7 @@ namespace webifc::geometry
 
                 for (auto relVoidExpressID : relVoidsIt->second)
                 {
+
                     IfcComposedMesh voidGeom = GetMesh(relVoidExpressID);
                     auto flatVoidMesh = flatten(voidGeom, _expressIDToGeometry, normalizeMat);
                     voidGeoms.insert(voidGeoms.end(), flatVoidMesh.begin(), flatVoidMesh.end());
@@ -239,6 +241,7 @@ namespace webifc::geometry
             {
                 return mesh;
             }
+
         }
         else
         {
@@ -453,7 +456,7 @@ namespace webifc::geometry
                 }
 
 #ifdef DUMP_CSG_MESHES
-                DumpIfcGeometry(geom, "pbhs.obj");
+                io::DumpIfcGeometry(geom, "pbhs.obj");
 #endif
 
                 // TODO: this is getting problematic.....