chili3d 0.6.1

package/cpp/src/geometry.cpp

@@ -0,0 +1,204 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+#include <GCPnts_AbscissaPoint.hxx>
+#include <GCPnts_UniformAbscissa.hxx>
+#include <GeomAPI_ExtremaCurveCurve.hxx>
+#include <GeomAPI_ProjectPointOnCurve.hxx>
+#include <GeomAPI_ProjectPointOnSurf.hxx>
+#include <GeomLib_IsPlanarSurface.hxx>
+#include <GeomLib_Tool.hxx>
+#include <GeomProjLib.hxx>
+#include <Geom_Curve.hxx>
+#include <Geom_Line.hxx>
+#include <Geom_Surface.hxx>
+#include <Geom_TrimmedCurve.hxx>
+#include <Standard_Handle.hxx>
+#include <gp_Dir.hxx>
+#include <gp_Pnt.hxx>
+#include <optional>
+
+#include "shared.hpp"
+#include "utils.hpp"
+
+using namespace emscripten;
+
+class Curve {
+private:
+    static Vector3Array getPoints(const GCPnts_UniformAbscissa& uniformAbscissa, const Geom_Curve* curve)
+    {
+        std::vector<Vector3> points;
+        for (int i = 1; i <= uniformAbscissa.NbPoints(); i++) {
+            points.push_back(Vector3::fromPnt(curve->Value(uniformAbscissa.Parameter(i))));
+        }
+        return Vector3Array(val::array(points));
+    }
+
+public:
+    static Handle_Geom_Line makeLine(const Vector3& start, const Vector3& dir)
+    {
+        Handle_Geom_Line line = new Geom_Line(Vector3::toPnt(start), Vector3::toDir(dir));
+        return line;
+    }
+
+    static Handle_Geom_TrimmedCurve trim(const Geom_Curve* curve, double start, double end)
+    {
+        Handle_Geom_TrimmedCurve trimmedCurve = new Geom_TrimmedCurve(curve, start, end);
+        return trimmedCurve;
+    }
+
+    static Vector3Array projects(const Geom_Curve* curve, const Vector3& point)
+    {
+        GeomAPI_ProjectPointOnCurve projector(Vector3::toPnt(point), curve);
+        std::vector<Vector3> points;
+        for (int i = 1; i <= projector.NbPoints(); i++) {
+            points.push_back(Vector3::fromPnt(projector.Point(i)));
+        }
+
+        return Vector3Array(val::array(points));
+    }
+
+    static std::optional<ExtremaCCResult> nearestExtremaCC(const Geom_Curve* curve1, const Geom_Curve* curve2)
+    {
+        GeomAPI_ExtremaCurveCurve extrema(curve1, curve2);
+        if (extrema.NbExtrema() == 0) {
+            return std::nullopt;
+        }
+
+        gp_Pnt p1, p2;
+        extrema.NearestPoints(p1, p2);
+        double u1, u2;
+        extrema.LowerDistanceParameters(u1, u2);
+        return ExtremaCCResult { .isParallel = extrema.IsParallel(),
+            .distance = extrema.LowerDistance(),
+            .p1 = Vector3::fromPnt(p1),
+            .p2 = Vector3::fromPnt(p2),
+            .u1 = u1,
+            .u2 = u2 };
+    }
+
+    static Vector3Array uniformAbscissaWithLength(const Geom_Curve* curve, double length)
+    {
+        GeomAdaptor_Curve adaptorCurve(curve);
+        GCPnts_UniformAbscissa uniformAbscissa(adaptorCurve, length);
+        return getPoints(uniformAbscissa, curve);
+    }
+
+    static Vector3Array uniformAbscissaWithCount(const Geom_Curve* curve, int nbPoints)
+    {
+        GeomAdaptor_Curve adaptorCurve(curve);
+        GCPnts_UniformAbscissa uniformAbscissa(adaptorCurve, nbPoints);
+        return getPoints(uniformAbscissa, curve);
+    }
+
+    static ProjectPointResult projectOrNearest(const Geom_Curve* curve, const Vector3& point)
+    {
+        gp_Pnt pnt = Vector3::toPnt(point);
+        return projectOrNearestCP(curve, pnt);
+    }
+
+    static std::optional<double> parameter(const Geom_Curve* curve, const Vector3& point, double maxDistance)
+    {
+        double parameter = 0;
+        gp_Pnt pnt = Vector3::toPnt(point);
+        if (GeomLib_Tool::Parameter(curve, pnt, maxDistance, parameter)) {
+            return parameter;
+        }
+        return std::nullopt;
+    }
+
+    static double curveLength(const Geom_Curve* curve)
+    {
+        GeomAdaptor_Curve adaptorCurve(curve);
+        return GCPnts_AbscissaPoint::Length(adaptorCurve);
+    }
+};
+
+struct SurfaceBounds {
+    double u1;
+    double u2;
+    double v1;
+    double v2;
+};
+
+class Surface {
+public:
+    static Handle_Geom_Curve projectCurve(const Geom_Surface* surface, const Geom_Curve* curve)
+    {
+        return GeomProjLib::Project(curve, surface);
+    }
+
+    static Vector3Array projectPoint(const Geom_Surface* surface, const Vector3& point)
+    {
+        gp_Pnt pnt = Vector3::toPnt(point);
+        GeomAPI_ProjectPointOnSurf projector(pnt, surface);
+        std::vector<gp_Pnt> points;
+        for (size_t i = 0; i < projector.NbPoints(); i++) {
+            points.push_back(projector.Point(i + 1));
+        }
+
+        return Vector3Array(val::array(points.begin(), points.end()));
+    }
+
+    static bool isPlanar(const Geom_Surface* surface)
+    {
+        GeomLib_IsPlanarSurface isPlanarSurface(surface);
+        return isPlanarSurface.IsPlanar();
+    }
+
+    static std::optional<UV> parameters(const Geom_Surface* surface, const Vector3& point, double maxDistance)
+    {
+        double u(0), v(0);
+        gp_Pnt pnt = Vector3::toPnt(point);
+        if (GeomLib_Tool::Parameters(surface, pnt, maxDistance, u, v)) {
+            return UV { .u = u, .v = v };
+        }
+        return std::nullopt;
+    }
+
+    static std::optional<PointAndParameter> nearestPoint(const Geom_Surface* surface, const Vector3& point)
+    {
+        gp_Pnt pnt = Vector3::toPnt(point);
+        GeomAPI_ProjectPointOnSurf projector(pnt, surface);
+        if (projector.IsDone()) {
+            return PointAndParameter { .point = Vector3::fromPnt(projector.NearestPoint()),
+                .parameter = projector.LowerDistance() };
+        }
+        return std::nullopt;
+    }
+
+    static SurfaceBounds bounds(const Geom_Surface* surface)
+    {
+        double u1, u2, v1, v2;
+        surface->Bounds(u1, u2, v1, v2);
+        return SurfaceBounds { .u1 = u1, .u2 = u2, .v1 = v1, .v2 = v2 };
+    }
+};
+
+EMSCRIPTEN_BINDINGS(Geometry)
+{
+    class_<Curve>("Curve")
+        .class_function("makeLine", &Curve::makeLine)
+        .class_function("trim", &Curve::trim, allow_raw_pointers())
+        .class_function("projectOrNearest", &Curve::projectOrNearest, allow_raw_pointers())
+        .class_function("uniformAbscissaWithCount", &Curve::uniformAbscissaWithCount, allow_raw_pointers())
+        .class_function("uniformAbscissaWithLength", &Curve::uniformAbscissaWithLength, allow_raw_pointers())
+        .class_function("nearestExtremaCC", &Curve::nearestExtremaCC, allow_raw_pointers())
+        .class_function("parameter", &Curve::parameter, allow_raw_pointers())
+        .class_function("curveLength", &Curve::curveLength, allow_raw_pointers())
+        .class_function("projects", &Curve::projects, allow_raw_pointers());
+
+    value_object<SurfaceBounds>("SurfaceBounds")
+        .field("u1", &SurfaceBounds::u1)
+        .field("u2", &SurfaceBounds::u2)
+        .field("v1", &SurfaceBounds::v1)
+        .field("v2", &SurfaceBounds::v2);
+
+    class_<Surface>("Surface")
+        .class_function("projectCurve", &Surface::projectCurve, allow_raw_pointers())
+        .class_function("projectPoint", &Surface::projectPoint, allow_raw_pointers())
+        .class_function("isPlanar", &Surface::isPlanar, allow_raw_pointers())
+        .class_function("parameters", &Surface::parameters, allow_raw_pointers())
+        .class_function("nearestPoint", &Surface::nearestPoint, allow_raw_pointers())
+        .class_function("bounds", &Surface::bounds, allow_raw_pointers());
+}

package/cpp/src/mesher.cpp

@@ -0,0 +1,330 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+#include <emscripten/bind.h>
+#include <emscripten/val.h>
+
+#include <BRepAdaptor_Curve.hxx>
+#include <BRepBndLib.hxx>
+#include <BRepLib_ToolTriangulatedShape.hxx>
+#include <BRepMesh_IncrementalMesh.hxx>
+#include <BRepTools.hxx>
+#include <BRep_Tool.hxx>
+#include <GCPnts_TangentialDeflection.hxx>
+#include <Poly_Triangulation.hxx>
+#include <Standard_Handle.hxx>
+#include <TopExp.hxx>
+#include <TopExp_Explorer.hxx>
+#include <TopLoc_Location.hxx>
+#include <TopoDS.hxx>
+#include <TopoDS_Edge.hxx>
+#include <TopoDS_Face.hxx>
+#include <TopoDS_Shape.hxx>
+#include <UnitsMethods.hxx>
+#include <gp_Dir.hxx>
+#include <gp_Pnt.hxx>
+#include <gp_Vec.hxx>
+
+#include "shared.hpp"
+#include "utils.hpp"
+
+using namespace emscripten;
+using namespace std;
+
+const double ANGLE_DEFLECTION = 0.2;
+
+void addPointToPosition(const gp_Pnt& pnt, std::optional<gp_Pnt>& prePnt, std::vector<float>& position)
+{
+    if (prePnt.has_value()) {
+        auto pre = prePnt.value();
+        position.push_back(pre.X());
+        position.push_back(pre.Y());
+        position.push_back(pre.Z());
+
+        position.push_back(pnt.X());
+        position.push_back(pnt.Y());
+        position.push_back(pnt.Z());
+    }
+    prePnt = pnt;
+}
+
+void pointByGCTangential(const TopoDS_Edge& edge, double lineDeflection, std::vector<float>& position)
+{
+    BRepAdaptor_Curve curve(edge);
+    GCPnts_TangentialDeflection pnts(curve, ANGLE_DEFLECTION, lineDeflection);
+
+    std::optional<gp_Pnt> prePnt = std::nullopt;
+    for (int i = 0; i < pnts.NbPoints(); i++) {
+        addPointToPosition(pnts.Value(i + 1), prePnt, position);
+    }
+}
+
+struct EdgeMeshData {
+    NumberArray position;
+    /// @brief start1,count1,start2,count2...
+    NumberArray group;
+    EdgeArray edges;
+};
+
+struct FaceMeshData {
+    NumberArray position;
+    NumberArray normal;
+    NumberArray uv;
+    NumberArray index;
+    /// @brief start1,count1,start2,count2...
+    NumberArray group;
+    FaceArray faces;
+};
+
+struct MeshData {
+    EdgeMeshData edgeMeshData;
+    FaceMeshData faceMeshData;
+};
+
+class EdgeMesher {
+public:
+    double lineDeflection;
+    std::vector<float> position;
+    /// @brief start1,count1,start2,count2...
+    std::vector<size_t> group;
+    std::vector<TopoDS_Edge> edges;
+
+    EdgeMesher(double lineDeflection)
+        : lineDeflection(lineDeflection)
+    {
+    }
+
+    void generateEdgeMesh(const TopoDS_Edge& edge, const Handle(Poly_Triangulation) & triangulation)
+    {
+        auto start = this->position.size() / 3;
+
+        if (triangulation.IsNull()) {
+            pointByGCTangential(edge, this->lineDeflection, this->position);
+        } else {
+            TopLoc_Location location;
+            Handle(Poly_PolygonOnTriangulation) polygon = BRep_Tool::PolygonOnTriangulation(edge, triangulation, location);
+            if (polygon.IsNull()) {
+                pointByGCTangential(edge, this->lineDeflection, this->position);
+            } else {
+                auto trsf = location.Transformation();
+                pointByFaceTriangulation(polygon, triangulation, trsf);
+            }
+        }
+
+        this->group.push_back(start);
+        this->group.push_back(this->position.size() / 3 - start);
+    }
+
+    void pointByFaceTriangulation(const Handle_Poly_PolygonOnTriangulation& polygon,
+        const Handle_Poly_Triangulation& triangulation, const gp_Trsf& transform)
+    {
+        std::optional<gp_Pnt> prePnt = std::nullopt;
+        auto nodeIndex = polygon->Nodes();
+        for (auto i = nodeIndex.Lower(); i <= nodeIndex.Upper(); i++) {
+            auto pnt = triangulation->Node(nodeIndex[i]).Transformed(transform);
+            addPointToPosition(pnt, prePnt, this->position);
+        }
+    }
+};
+
+class FaceMesher {
+public:
+    std::vector<float> position;
+    std::vector<float> normal;
+    std::vector<float> uv;
+    std::vector<size_t> index;
+    /// @brief start1,count1,start2,count2...
+    std::vector<size_t> group;
+    std::vector<TopoDS_Face> faces;
+
+    void generateFaceMesh(const TopoDS_Face& face, const Handle(Poly_Triangulation) & handlePoly, const gp_Trsf& trsf)
+    {
+        if (handlePoly.IsNull()) {
+            return;
+        }
+
+        bool isMirrod = trsf.VectorialPart().Determinant() < 0;
+        auto orientation = face.Orientation();
+        auto groupStart = this->index.size();
+        auto indexStart = this->position.size() / 3;
+
+        this->fillIndex(indexStart, handlePoly, orientation);
+        this->fillPosition(trsf, handlePoly);
+        this->fillNormal(trsf, face, handlePoly, (orientation == TopAbs_REVERSED) ^ isMirrod);
+        this->fillUv(face, handlePoly);
+
+        this->group.push_back(groupStart);
+        this->group.push_back(this->index.size() - groupStart);
+    }
+
+    void fillPosition(const gp_Trsf& transform, const Handle(Poly_Triangulation) & handlePoly)
+    {
+        for (int index = 0; index < handlePoly->NbNodes(); index++) {
+            auto pnt = handlePoly->Node(index + 1).Transformed(transform);
+            this->position.push_back(pnt.X());
+            this->position.push_back(pnt.Y());
+            this->position.push_back(pnt.Z());
+        }
+    }
+
+    void fillNormal(const gp_Trsf& transform, const TopoDS_Face& face, const Handle(Poly_Triangulation) & handlePoly,
+        bool shouldReverse)
+    {
+        BRepLib_ToolTriangulatedShape::ComputeNormals(face, handlePoly);
+        for (int index = 0; index < handlePoly->NbNodes(); index++) {
+            auto normal = handlePoly->Normal(index + 1);
+            if (shouldReverse) {
+                normal.Reverse();
+            }
+            normal = normal.Transformed(transform);
+            this->normal.push_back(normal.X());
+            this->normal.push_back(normal.Y());
+            this->normal.push_back(normal.Z());
+        }
+    }
+
+    void fillIndex(size_t indexStart, const Handle(Poly_Triangulation) & handlePoly,
+        const TopAbs_Orientation& orientation)
+    {
+        for (int index = 0; index < handlePoly->NbTriangles(); index++) {
+            auto v1(1), v2(2), v3(3);
+            if (orientation == TopAbs_REVERSED) {
+                v2 = 3;
+                v3 = 2;
+            }
+
+            auto triangle = handlePoly->Triangle(index + 1);
+            this->index.push_back(triangle.Value(v1) - 1 + indexStart);
+            this->index.push_back(triangle.Value(v2) - 1 + indexStart);
+            this->index.push_back(triangle.Value(v3) - 1 + indexStart);
+        }
+    }
+
+    void fillUv(const TopoDS_Face& face, const Handle(Poly_Triangulation) & handlePoly)
+    {
+        double aUmin, aUmax, aVmin, aVmax, dUmax, dVmax;
+        BRepTools::UVBounds(face, aUmin, aUmax, aVmin, aVmax);
+        dUmax = (aUmax - aUmin);
+        dVmax = (aVmax - aVmin);
+        for (int index = 0; index < handlePoly->NbNodes(); index++) {
+            auto uv = handlePoly->UVNode(index + 1);
+            this->uv.push_back((uv.X() - aUmin) / dUmax);
+            this->uv.push_back((uv.Y() - aVmin) / dVmax);
+        }
+    }
+};
+
+class Mesher {
+    TopoDS_Shape shape;
+    double lineDeflection;
+
+public:
+    Mesher(const TopoDS_Shape& shape, double lineDeflection)
+        : shape(shape)
+    {
+        this->lineDeflection = boundingBoxRatio(shape, lineDeflection);
+    }
+
+    NumberArray edgesMeshPosition()
+    {
+        std::vector<float> position;
+        TopTools_IndexedMapOfShape edgeMap;
+        TopExp::MapShapes(shape, TopAbs_EDGE, edgeMap);
+        for (TopTools_IndexedMapOfShape::Iterator anIt(edgeMap); anIt.More(); anIt.Next()) {
+            TopoDS_Edge edge = TopoDS::Edge(anIt.Value());
+            pointByGCTangential(edge, this->lineDeflection, position);
+        }
+
+        return NumberArray(val::array(position));
+    }
+
+    MeshData mesh()
+    {
+        BRepMesh_IncrementalMesh mesh(shape, lineDeflection, true, ANGLE_DEFLECTION, true);
+
+        std::unordered_map<TopoDS_Face, Handle(Poly_Triangulation)> facePolyMap;
+        auto faceMeshData = meshFaces(facePolyMap);
+        auto edgeMeshData = meshEdges(facePolyMap);
+
+        return MeshData { edgeMeshData, faceMeshData };
+    }
+
+    EdgeMeshData meshEdges(std::unordered_map<TopoDS_Face, Handle_Poly_Triangulation>& facePolyMap)
+    {
+        EdgeMesher mesher(lineDeflection);
+        TopTools_IndexedDataMapOfShapeListOfShape mapEF;
+        TopExp::MapShapesAndAncestors(shape, TopAbs_EDGE, TopAbs_FACE, mapEF);
+        for (int ie = 1; ie <= mapEF.Extent(); ie++) {
+            const TopoDS_Edge& aEdge = TopoDS::Edge(mapEF.FindKey(ie));
+            mesher.edges.push_back(aEdge);
+
+            const TopTools_ListOfShape& aFaces = mapEF(ie);
+            if (aFaces.Extent() < 1) {
+                mesher.generateEdgeMesh(aEdge, nullptr);
+            } else {
+                const TopoDS_Face& face = TopoDS::Face(aFaces.First());
+                auto it = facePolyMap.find(face);
+                if (it != facePolyMap.end()) {
+                    mesher.generateEdgeMesh(aEdge, it->second);
+                } else {
+                    mesher.generateEdgeMesh(aEdge, nullptr);
+                }
+            }
+        }
+
+        return EdgeMeshData { NumberArray(val::array(mesher.position)), NumberArray(val::array(mesher.group)),
+            EdgeArray(val::array(mesher.edges)) };
+    }
+
+    FaceMeshData meshFaces(std::unordered_map<TopoDS_Face, Handle_Poly_Triangulation>& facePolyMap)
+    {
+        FaceMesher mesher;
+        TopTools_IndexedMapOfShape faceMap;
+        TopExp::MapShapes(shape, TopAbs_FACE, faceMap);
+        for (TopTools_IndexedMapOfShape::Iterator anIt(faceMap); anIt.More(); anIt.Next()) {
+            auto face = TopoDS::Face(anIt.Value());
+            mesher.faces.push_back(face);
+            TopLoc_Location location;
+            auto handlePoly = BRep_Tool::Triangulation(face, location);
+            if (!handlePoly.IsNull()) {
+                auto trsf = location.Transformation();
+                mesher.generateFaceMesh(face, handlePoly, trsf);
+                facePolyMap[face] = handlePoly;
+            }
+        }
+
+        return FaceMeshData { NumberArray(val::array(mesher.position)), NumberArray(val::array(mesher.normal)),
+            NumberArray(val::array(mesher.uv)), NumberArray(val::array(mesher.index)),
+            NumberArray(val::array(mesher.group)), FaceArray(val::array(mesher.faces)) };
+    }
+
+    ~Mesher()
+    {
+        BRepTools::Clean(shape, true);
+    }
+};
+
+EMSCRIPTEN_BINDINGS(Mesher)
+{
+    class_<Mesher>("Mesher")
+        .constructor<TopoDS_Shape, double>()
+        .function("mesh", &Mesher::mesh)
+        .function("edgesMeshPosition", &Mesher::edgesMeshPosition);
+
+    class_<EdgeMeshData>("EdgeMeshData")
+        .property("position", &EdgeMeshData::position)
+        .property("group", &EdgeMeshData::group)
+        .property("edges", &EdgeMeshData::edges);
+
+    class_<FaceMeshData>("FaceMeshData")
+        .property("position", &FaceMeshData::position)
+        .property("normal", &FaceMeshData::normal)
+        .property("uv", &FaceMeshData::uv)
+        .property("index", &FaceMeshData::index)
+        .property("group", &FaceMeshData::group)
+        .property("faces", &FaceMeshData::faces);
+
+    class_<MeshData>("MeshData")
+        .property("edgeMeshData", &MeshData::edgeMeshData)
+        .property("faceMeshData", &MeshData::faceMeshData);
+}