chili3d 0.6.1 → 0.6.3

package/cpp/src/geometry.cpp

@@ -1,204 +0,0 @@
-// 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

@@ -1,330 +0,0 @@
-// 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);
-}