fluidcad 0.0.2

package/lib/dist/oc/constraints/curve/tangent-line-solver.js

@@ -0,0 +1,83 @@
+import { Vertex } from "../../../common/vertex.js";
+import { filterSolutionsByFiniteExtent, getQualifiedCurve } from "../constraint-helpers.js";
+import { Convert } from "../../convert.js";
+import { getOC } from "../../init.js";
+import { Geometry } from "../../geometry.js";
+export class CurveTangentLineSolver {
+    getTangentLines(plane, shape1, shape2, mustTouch) {
+        let solutions;
+        if (shape1.shape instanceof Vertex || shape2.shape instanceof Vertex) {
+            const [vertex] = [shape1, shape2].filter(s => s.shape instanceof Vertex);
+            const [otherShape] = [shape1, shape2].filter(s => s !== vertex);
+            if (otherShape instanceof Vertex) {
+                // todo: create a line between the two points and return it as the single tangent solution
+                return [];
+            }
+            solutions = this.getPointCurveTangent(plane, vertex.shape, otherShape);
+        }
+        else {
+            solutions = this.getCurveCurveTangent(plane, shape1, shape2);
+        }
+        if (mustTouch) {
+            solutions = filterSolutionsByFiniteExtent(solutions, shape1.shape, shape2.shape, plane);
+        }
+        return this.solutionsToEdges(solutions, plane);
+    }
+    getPointCurveTangent(plane, vertex, circleShape) {
+        const oc = getOC();
+        const tolerance = oc.Precision.Angular();
+        const [pln, disposePln] = Convert.toGpPln(plane);
+        const [pnt, disposePnt] = Convert.toGpPnt2d(vertex.toPoint2D());
+        const curve = this.getCurve(circleShape.shape);
+        const qualifiedGeometry = getQualifiedCurve(pln, curve, circleShape.qualifier);
+        const solver = new oc.Geom2dGcc_Lin2d2Tan(qualifiedGeometry, pnt, tolerance);
+        disposePnt();
+        const solutions = this.getSolutions(solver);
+        disposePln();
+        return solutions;
+    }
+    getCurveCurveTangent(plane, shape1, shape2) {
+        const oc = getOC();
+        const tolerance = oc.Precision.Angular();
+        const [pln, disposePln] = Convert.toGpPln(plane);
+        const curve1 = this.getCurve(shape1.shape);
+        const curve2 = this.getCurve(shape2.shape);
+        const qualifiedGeometry1 = getQualifiedCurve(pln, curve1, shape1.qualifier);
+        const qualifiedGeometry2 = getQualifiedCurve(pln, curve2, shape2.qualifier);
+        const solver = new oc.Geom2dGcc_Lin2d2Tan(qualifiedGeometry1, qualifiedGeometry2, tolerance);
+        const solutions = this.getSolutions(solver);
+        disposePln();
+        return solutions;
+    }
+    getSolutions(solver) {
+        const oc = getOC();
+        const solutions = [];
+        if (solver.IsDone()) {
+            for (let i = 1; i <= solver.NbSolutions(); i++) {
+                const pnt1 = new oc.gp_Pnt2d();
+                const pnt2 = new oc.gp_Pnt2d();
+                solver.Tangency1(i, 0, 0, pnt1);
+                solver.Tangency2(i, 0, 0, pnt2);
+                solutions.push({ tangentPoint1: pnt1, tangentPoint2: pnt2 });
+            }
+        }
+        return solutions;
+    }
+    solutionsToEdges(solutions, plane) {
+        return solutions.map(solution => {
+            const worldPnt1 = plane.localToWorld(Convert.toPoint2D(solution.tangentPoint1, true));
+            const worldPnt2 = plane.localToWorld(Convert.toPoint2D(solution.tangentPoint2, true));
+            const line = Geometry.makeSegment(worldPnt1, worldPnt2);
+            return Geometry.makeEdge(line);
+        });
+    }
+    getCurve(shape) {
+        const oc = getOC();
+        const adaptor = new oc.BRepAdaptor_Curve(shape.getShape());
+        const curve = adaptor.Curve();
+        const handle = curve.Curve();
+        curve.delete();
+        adaptor.delete();
+        return handle;
+    }
+}

package/lib/dist/oc/constraints/curve-constraint-solver.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/dist/oc/constraints/curve-constraint-solver.js

@@ -0,0 +1,2 @@
+getQualifiedGeometry;
+export {};

package/lib/dist/oc/constraints/geometric/geometric-constraint-solver.d.ts

@@ -0,0 +1,12 @@
+import { Edge } from "../../../common/edge.js";
+import { QualifiedShape } from "../../../features/2d/constraints/qualified-geometry.js";
+import { Plane } from "../../../math/plane.js";
+import { ConstraintSolver } from "../constraint-solver.js";
+export declare class GeometricConstraintSolver extends ConstraintSolver {
+    getTangentLines(plane: Plane, shape1: QualifiedShape, shape2: QualifiedShape, mustTouch: boolean): Edge[];
+    getTangentCircles(plane: Plane, shape1: QualifiedShape, shape2: QualifiedShape, radius: number, mustTouch: boolean): Edge[];
+    getTangentArcs(plane: Plane, shape1: QualifiedShape, shape2: QualifiedShape, radius: number, mustTouch: boolean): {
+        edges: Edge[];
+        endTangent: import("../../../math/point.js").Point2D | null;
+    };
+}

package/lib/dist/oc/constraints/geometric/geometric-constraint-solver.js

@@ -0,0 +1,17 @@
+import { ConstraintSolver } from "../constraint-solver.js";
+import { GeometricTangentCircleSolver } from "./tangent-circle-solver.js";
+import { GeometricTangentLineSolver } from "./tangent-line-solver.js";
+export class GeometricConstraintSolver extends ConstraintSolver {
+    getTangentLines(plane, shape1, shape2, mustTouch) {
+        const tangentLineSolver = new GeometricTangentLineSolver();
+        return tangentLineSolver.getTangentLines(plane, shape1, shape2, mustTouch);
+    }
+    getTangentCircles(plane, shape1, shape2, radius, mustTouch) {
+        const tangentCircleSolver = new GeometricTangentCircleSolver();
+        return tangentCircleSolver.getTangentCircles(plane, shape1, shape2, radius, mustTouch);
+    }
+    getTangentArcs(plane, shape1, shape2, radius, mustTouch) {
+        const solver = new GeometricTangentCircleSolver();
+        return solver.getTangentArcs(plane, shape1, shape2, radius, mustTouch);
+    }
+}

package/lib/dist/oc/constraints/geometric/tangent-circle-solver.d.ts

@@ -0,0 +1,21 @@
+import { Edge } from "../../../common/edge.js";
+import { QualifiedShape } from "../../../features/2d/constraints/qualified-geometry.js";
+import { Plane } from "../../../math/plane.js";
+import { TangentCircleSolver } from "../constraint-solver.js";
+import { Point2D } from "../../../math/point.js";
+export declare class GeometricTangentCircleSolver implements TangentCircleSolver {
+    getTangentCircles(plane: Plane, shape1: QualifiedShape, shape2: QualifiedShape, radius: number, mustTouch: boolean): Edge[];
+    getTangentArcs(plane: Plane, shape1: QualifiedShape, shape2: QualifiedShape, radius: number, mustTouch: boolean): {
+        edges: Edge[];
+        endTangent: Point2D | null;
+    };
+    private isLine;
+    private getLineLineTangent;
+    private getLineCircleTangent;
+    private getPointLineTangent;
+    private getPointPointCircleTangent;
+    private getPointCircleTangent;
+    private getCircleCircleTangent;
+    private getSolutions;
+    private getShapeGeometry;
+}

package/lib/dist/oc/constraints/geometric/tangent-circle-solver.js

@@ -0,0 +1,220 @@
+import { Vertex } from "../../../common/vertex.js";
+import { calculateTangent, filterSolutionsByFiniteExtent, getQualifiedGeometry, toArcEdges, toCircleEdges } from "../constraint-helpers.js";
+import { Convert } from "../../convert.js";
+import { getOC } from "../../init.js";
+export class GeometricTangentCircleSolver {
+    getTangentCircles(plane, shape1, shape2, radius, mustTouch) {
+        const isVertex1 = shape1.shape instanceof Vertex;
+        const isVertex2 = shape2.shape instanceof Vertex;
+        let solutions;
+        if (isVertex1 && isVertex2) {
+            solutions = this.getPointPointCircleTangent(plane, shape1.shape, shape2.shape, radius);
+        }
+        else if (isVertex1 || isVertex2) {
+            const vertex = isVertex1 ? shape1 : shape2;
+            const other = isVertex1 ? shape2 : shape1;
+            if (this.isLine(other.shape)) {
+                solutions = this.getPointLineTangent(plane, vertex.shape, other, radius);
+            }
+            else {
+                solutions = this.getPointCircleTangent(plane, vertex.shape, other, radius);
+            }
+        }
+        else {
+            const isLine1 = this.isLine(shape1.shape);
+            const isLine2 = this.isLine(shape2.shape);
+            if (isLine1 && isLine2) {
+                solutions = this.getLineLineTangent(plane, shape1, shape2, radius);
+            }
+            else if (isLine1) {
+                solutions = this.getLineCircleTangent(plane, shape1, shape2, radius);
+            }
+            else if (isLine2) {
+                solutions = this.getLineCircleTangent(plane, shape2, shape1, radius);
+            }
+            else {
+                solutions = this.getCircleCircleTangent(plane, shape1, shape2, radius);
+            }
+        }
+        if (mustTouch) {
+            solutions = filterSolutionsByFiniteExtent(solutions, shape1.shape, shape2.shape, plane);
+        }
+        const edges = toCircleEdges(solutions, plane);
+        for (const solution of solutions) {
+            solution.center.delete();
+            solution.tangentPoint1.delete();
+            solution.tangentPoint2.delete();
+        }
+        return edges;
+    }
+    getTangentArcs(plane, shape1, shape2, radius, mustTouch) {
+        const isVertex1 = shape1.shape instanceof Vertex;
+        const isVertex2 = shape2.shape instanceof Vertex;
+        let solutions;
+        if (isVertex1 && isVertex2) {
+            solutions = this.getPointPointCircleTangent(plane, shape1.shape, shape2.shape, radius);
+        }
+        else if (isVertex1 || isVertex2) {
+            const vertex = isVertex1 ? shape1 : shape2;
+            const other = isVertex1 ? shape2 : shape1;
+            if (this.isLine(other.shape)) {
+                solutions = this.getPointLineTangent(plane, vertex.shape, other, radius);
+            }
+            else {
+                solutions = this.getPointCircleTangent(plane, vertex.shape, other, radius);
+            }
+        }
+        else {
+            const isLine1 = this.isLine(shape1.shape);
+            const isLine2 = this.isLine(shape2.shape);
+            if (isLine1 && isLine2) {
+                solutions = this.getLineLineTangent(plane, shape1, shape2, radius);
+            }
+            else if (isLine1) {
+                solutions = this.getLineCircleTangent(plane, shape1, shape2, radius);
+            }
+            else if (isLine2) {
+                solutions = this.getLineCircleTangent(plane, shape2, shape1, radius);
+            }
+            else {
+                solutions = this.getCircleCircleTangent(plane, shape1, shape2, radius);
+            }
+        }
+        if (mustTouch) {
+            solutions = filterSolutionsByFiniteExtent(solutions, shape1.shape, shape2.shape, plane);
+        }
+        const edges = toArcEdges(solutions, plane);
+        const endTangent = calculateTangent(solutions);
+        for (const solution of solutions) {
+            solution.center.delete();
+            solution.tangentPoint1.delete();
+            solution.tangentPoint2.delete();
+        }
+        return {
+            edges,
+            endTangent
+        };
+    }
+    isLine(shape) {
+        const oc = getOC();
+        const adaptor = new oc.BRepAdaptor_Curve(shape.getShape());
+        const result = adaptor.GetType() === oc.GeomAbs_CurveType.GeomAbs_Line;
+        adaptor.delete();
+        return result;
+    }
+    getLineLineTangent(plane, lineShape1, lineShape2, radius) {
+        const oc = getOC();
+        const tolerance = oc.Precision.Angular();
+        const [pln, disposePln] = Convert.toGpPln(plane);
+        const lineGeometry1 = this.getShapeGeometry(lineShape1.shape);
+        const lineGeometry2 = this.getShapeGeometry(lineShape2.shape);
+        const qualifiedLine1 = getQualifiedGeometry(pln, lineGeometry1, lineShape1.qualifier);
+        const qualifiedLine2 = getQualifiedGeometry(pln, lineGeometry2, lineShape2.qualifier);
+        const solver = new oc.GccAna_Circ2d2TanRad(qualifiedLine1, qualifiedLine2, radius, tolerance);
+        const solutions = this.getSolutions(solver, plane);
+        disposePln();
+        return solutions;
+    }
+    getLineCircleTangent(plane, lineShape, circleShape, radius) {
+        const oc = getOC();
+        const tolerance = oc.Precision.Angular();
+        const [pln, disposePln] = Convert.toGpPln(plane);
+        const lineGeometry = this.getShapeGeometry(lineShape.shape);
+        const circleGeometry = this.getShapeGeometry(circleShape.shape);
+        const qualifiedLine = getQualifiedGeometry(pln, lineGeometry, lineShape.qualifier);
+        const qualifiedCircle = getQualifiedGeometry(pln, circleGeometry, circleShape.qualifier);
+        const solver = new oc.GccAna_Circ2d2TanRad(qualifiedCircle, qualifiedLine, radius, tolerance);
+        const solutions = this.getSolutions(solver, plane);
+        disposePln();
+        return solutions;
+    }
+    getPointLineTangent(plane, vertex, lineShape, radius) {
+        const oc = getOC();
+        const tolerance = oc.Precision.Angular();
+        const [pln, disposePln] = Convert.toGpPln(plane);
+        const [pnt, disposePnt] = Convert.toGpPnt2d(vertex.toPoint2D());
+        const geometry = this.getShapeGeometry(lineShape.shape);
+        const qualifiedGeometry = getQualifiedGeometry(pln, geometry, lineShape.qualifier);
+        const solver = new oc.GccAna_Circ2d2TanRad(qualifiedGeometry, pnt, radius, tolerance);
+        disposePnt();
+        const solutions = this.getSolutions(solver, plane);
+        disposePln();
+        return solutions;
+    }
+    getPointPointCircleTangent(plane, vertex1, vertex2, radius) {
+        const oc = getOC();
+        const tolerance = oc.Precision.Angular();
+        const [pnt1, disposePnt1] = Convert.toGpPnt2d(vertex1.toPoint2D());
+        const [pnt2, disposePnt2] = Convert.toGpPnt2d(vertex2.toPoint2D());
+        const solver = new oc.GccAna_Circ2d2TanRad(pnt1, pnt2, radius, tolerance);
+        disposePnt1();
+        disposePnt2();
+        const solutions = this.getSolutions(solver, plane);
+        return solutions;
+    }
+    getPointCircleTangent(plane, vertex, circleShape, radius) {
+        const oc = getOC();
+        const tolerance = oc.Precision.Angular();
+        const [pln, disposePln] = Convert.toGpPln(plane);
+        const [pnt, disposePnt] = Convert.toGpPnt2d(vertex.toPoint2D());
+        const geometry = this.getShapeGeometry(circleShape.shape);
+        const qualifiedGeometry = getQualifiedGeometry(pln, geometry, circleShape.qualifier);
+        const solver = new oc.GccAna_Circ2d2TanRad(qualifiedGeometry, pnt, radius, tolerance);
+        disposePnt();
+        const solutions = this.getSolutions(solver, plane);
+        disposePln();
+        return solutions;
+    }
+    getCircleCircleTangent(plane, shape1, shape2, radius) {
+        const oc = getOC();
+        const tolerance = oc.Precision.Angular();
+        const [pln, disposePln] = Convert.toGpPln(plane);
+        const geometry1 = this.getShapeGeometry(shape1.shape);
+        const geometry2 = this.getShapeGeometry(shape2.shape);
+        const qualifiedGeometry1 = getQualifiedGeometry(pln, geometry1, shape1.qualifier);
+        const qualifiedGeometry2 = getQualifiedGeometry(pln, geometry2, shape2.qualifier);
+        const solver = new oc.GccAna_Circ2d2TanRad(qualifiedGeometry1, qualifiedGeometry2, radius, tolerance);
+        const solutions = this.getSolutions(solver, plane);
+        disposePln();
+        return solutions;
+    }
+    getSolutions(solver, plane) {
+        const oc = getOC();
+        const solutions = [];
+        if (solver.IsDone()) {
+            for (let i = 1; i <= solver.NbSolutions(); i++) {
+                const circ2d = solver.ThisSolution(i);
+                const radius = circ2d.Radius();
+                const pnt1 = new oc.gp_Pnt2d();
+                const pnt2 = new oc.gp_Pnt2d();
+                solver.Tangency1(i, 0, 0, pnt1);
+                solver.Tangency2(i, 0, 0, pnt2);
+                solutions.push({
+                    center: circ2d.Location(),
+                    radius: radius,
+                    tangentPoint1: pnt1,
+                    tangentPoint2: pnt2
+                });
+            }
+        }
+        return solutions;
+    }
+    getShapeGeometry(shape) {
+        const oc = getOC();
+        const adaptor = new oc.BRepAdaptor_Curve(shape.getShape());
+        const type = adaptor.GetType();
+        let geometry;
+        if (type === oc.GeomAbs_CurveType.GeomAbs_Line) {
+            geometry = adaptor.Line();
+        }
+        else if (type === oc.GeomAbs_CurveType.GeomAbs_Circle) {
+            geometry = adaptor.Circle();
+        }
+        else {
+            adaptor.delete();
+            throw new Error('Unsupported shape type for tangent line solver');
+        }
+        adaptor.delete();
+        return geometry;
+    }
+}

package/lib/dist/oc/constraints/geometric/tangent-line-solver.d.ts

@@ -0,0 +1,19 @@
+import { Edge } from "../../../common/edge.js";
+import { Shape } from "../../../common/shape.js";
+import { ConstraintQualifier } from "../../../features/2d/constraints/qualified-geometry.js";
+import { Plane } from "../../../math/plane.js";
+import { TangentLineSolver } from "../constraint-solver.js";
+export declare class GeometricTangentLineSolver implements TangentLineSolver {
+    getTangentLines(plane: Plane, shape1: {
+        shape: Shape;
+        qualifier: ConstraintQualifier;
+    }, shape2: {
+        shape: Shape;
+        qualifier: ConstraintQualifier;
+    }, mustTouch: boolean): Edge[];
+    private getPointCircleTangent;
+    private getCircleCircleTangent;
+    private getSolutions;
+    private solutionsToEdges;
+    private getShapeGeometry;
+}

package/lib/dist/oc/constraints/geometric/tangent-line-solver.js

@@ -0,0 +1,92 @@
+import { Vertex } from "../../../common/vertex.js";
+import { filterSolutionsByFiniteExtent, getQualifiedGeometry } from "../constraint-helpers.js";
+import { Convert } from "../../convert.js";
+import { getOC } from "../../init.js";
+import { Geometry } from "../../geometry.js";
+export class GeometricTangentLineSolver {
+    getTangentLines(plane, shape1, shape2, mustTouch) {
+        let solutions;
+        if (shape1.shape instanceof Vertex || shape2.shape instanceof Vertex) {
+            const [vertex] = [shape1, shape2].filter(s => s.shape instanceof Vertex);
+            const [otherShape] = [shape1, shape2].filter(s => s !== vertex);
+            if (otherShape instanceof Vertex) {
+                // todo: create a line between the two points and return it as the single tangent solution
+                return [];
+            }
+            solutions = this.getPointCircleTangent(plane, vertex.shape, otherShape);
+        }
+        else {
+            solutions = this.getCircleCircleTangent(plane, shape1, shape2);
+        }
+        if (mustTouch) {
+            solutions = filterSolutionsByFiniteExtent(solutions, shape1.shape, shape2.shape, plane);
+        }
+        return this.solutionsToEdges(solutions, plane);
+    }
+    getPointCircleTangent(plane, vertex, circleShape) {
+        const oc = getOC();
+        const tolerance = oc.Precision.Angular();
+        const [pln, disposePln] = Convert.toGpPln(plane);
+        const [pnt, disposePnt] = Convert.toGpPnt2d(vertex.toPoint2D());
+        const geometry = this.getShapeGeometry(circleShape.shape);
+        const qualifiedGeometry = getQualifiedGeometry(pln, geometry, circleShape.qualifier);
+        const solver = new oc.GccAna_Lin2d2Tan(qualifiedGeometry, pnt, tolerance);
+        disposePnt();
+        const solutions = this.getSolutions(solver);
+        disposePln();
+        return solutions;
+    }
+    getCircleCircleTangent(plane, shape1, shape2) {
+        const oc = getOC();
+        const tolerance = oc.Precision.Angular();
+        const [pln, disposePln] = Convert.toGpPln(plane);
+        const geometry1 = this.getShapeGeometry(shape1.shape);
+        const geometry2 = this.getShapeGeometry(shape2.shape);
+        const qualifiedGeometry1 = getQualifiedGeometry(pln, geometry1, shape1.qualifier);
+        const qualifiedGeometry2 = getQualifiedGeometry(pln, geometry2, shape2.qualifier);
+        const solver = new oc.GccAna_Lin2d2Tan(qualifiedGeometry1, qualifiedGeometry2, tolerance);
+        const solutions = this.getSolutions(solver);
+        disposePln();
+        return solutions;
+    }
+    getSolutions(solver) {
+        const oc = getOC();
+        const solutions = [];
+        if (solver.IsDone()) {
+            for (let i = 1; i <= solver.NbSolutions(); i++) {
+                const pnt1 = new oc.gp_Pnt2d();
+                const pnt2 = new oc.gp_Pnt2d();
+                solver.Tangency1(i, 0, 0, pnt1);
+                solver.Tangency2(i, 0, 0, pnt2);
+                solutions.push({ tangentPoint1: pnt1, tangentPoint2: pnt2 });
+            }
+        }
+        return solutions;
+    }
+    solutionsToEdges(solutions, plane) {
+        return solutions.map(solution => {
+            const worldPnt1 = plane.localToWorld(Convert.toPoint2D(solution.tangentPoint1, true));
+            const worldPnt2 = plane.localToWorld(Convert.toPoint2D(solution.tangentPoint2, true));
+            const line = Geometry.makeSegment(worldPnt1, worldPnt2);
+            return Geometry.makeEdge(line);
+        });
+    }
+    getShapeGeometry(shape) {
+        const oc = getOC();
+        const adaptor = new oc.BRepAdaptor_Curve(shape.getShape());
+        const type = adaptor.GetType();
+        let geometry;
+        if (type === oc.GeomAbs_CurveType.GeomAbs_Line) {
+            geometry = adaptor.Line();
+        }
+        else if (type === oc.GeomAbs_CurveType.GeomAbs_Circle) {
+            geometry = adaptor.Circle();
+        }
+        else {
+            adaptor.delete();
+            throw new Error('Unsupported shape type for tangent line solver');
+        }
+        adaptor.delete();
+        return geometry;
+    }
+}

package/lib/dist/oc/constraints/geometric-constraint-solver.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/dist/oc/constraints/geometric-constraint-solver.js

@@ -0,0 +1,5 @@
+getQualifiedGeometry;
+getQualifiedGeometry;
+getQualifiedGeometry;
+getQualifiedGeometry;
+export {};

package/lib/dist/oc/convert.d.ts

@@ -0,0 +1,42 @@
+import type { gp_Pnt, gp_Pnt2d, gp_Vec, gp_Dir, gp_Ax1, gp_Ax2, gp_Ax3, gp_Pln, gp_Trsf, gp_Quaternion } from "occjs-wrapper";
+import { Point, Point2D } from "../math/point.js";
+import { Vector3d } from "../math/vector3d.js";
+import { Axis } from "../math/axis.js";
+import { Plane } from "../math/plane.js";
+import { CoordinateSystem } from "../math/coordinate-system.js";
+import { Matrix4 } from "../math/matrix4.js";
+import { Quaternion } from "../math/quaternion.js";
+export type Disposable<T> = [T, () => void];
+export declare class Convert {
+    static toGpPnt(point: Point): Disposable<gp_Pnt>;
+    static toPoint(gpPnt: gp_Pnt, deleteSource?: boolean): Point;
+    static toGpPnt2d(point: Point2D): Disposable<gp_Pnt2d>;
+    static toPoint2D(gpPnt2d: gp_Pnt2d, deleteSource?: boolean): Point2D;
+    static toGpPntFrom2D(point: Point2D): Disposable<gp_Pnt>;
+    static toPoint2DFromGpPnt(gpPnt: gp_Pnt, deleteSource?: boolean): Point2D;
+    static toGpVec(vector: Vector3d): Disposable<gp_Vec>;
+    static toVector3d(gpVec: gp_Vec, deleteSource?: boolean): Vector3d;
+    static toGpDir(vector: Vector3d): Disposable<gp_Dir>;
+    static toVector3dFromGpDir(gpDir: gp_Dir, deleteSource?: boolean): Vector3d;
+    static toGpVecFromPoint(point: Point): Disposable<gp_Vec>;
+    static toVector3dFromGpPnt(gpPnt: gp_Pnt, deleteSource?: boolean): Vector3d;
+    static toGpAx1(axis: Axis): Disposable<gp_Ax1>;
+    static toAxis(gpAx1: gp_Ax1, deleteSource?: boolean): Axis;
+    static toGpAx2(cs: CoordinateSystem): Disposable<gp_Ax2>;
+    static toCoordinateSystem(gpAx2: gp_Ax2, deleteSource?: boolean): CoordinateSystem;
+    static toGpAx3(cs: CoordinateSystem): Disposable<gp_Ax3>;
+    static toCoordinateSystemFromGpAx3(gpAx3: gp_Ax3, deleteSource?: boolean): CoordinateSystem;
+    static toGpPln(plane: Plane): Disposable<gp_Pln>;
+    static toPlane(gpPln: gp_Pln, deleteSource?: boolean): Plane;
+    static toGpTrsf(matrix: Matrix4): Disposable<gp_Trsf>;
+    static toMatrix4(gpTrsf: gp_Trsf, deleteSource?: boolean): Matrix4;
+    static toGpQuaternion(quaternion: Quaternion): Disposable<gp_Quaternion>;
+    static toQuaternion(gpQuaternion: gp_Quaternion, deleteSource?: boolean): Quaternion;
+    static toGpTrsfTranslation(dx: number, dy: number, dz: number): Disposable<gp_Trsf>;
+    static toGpTrsfTranslationVec(vector: Vector3d): Disposable<gp_Trsf>;
+    static toGpTrsfRotation(axis: Axis, angle: number): Disposable<gp_Trsf>;
+    static toGpTrsfScale(center: Point, factor: number): Disposable<gp_Trsf>;
+    static toGpTrsfMirrorPoint(point: Point): Disposable<gp_Trsf>;
+    static toGpTrsfMirrorAxis(axis: Axis): Disposable<gp_Trsf>;
+    static toGpTrsfMirrorPlane(plane: Plane): Disposable<gp_Trsf>;
+}