fluidcad 0.0.2

package/lib/dist/features/extrude.js

@@ -0,0 +1,182 @@
+import { Extruder } from "./simple-extruder.js";
+import { fuseWithSceneObjects, cutWithSceneObjects } from "../helpers/scene-helpers.js";
+import { ExtrudeBase } from "./extrude-base.js";
+import { FaceMaker2 } from "../oc/face-maker2.js";
+import { BooleanOps } from "../oc/boolean-ops.js";
+import { Explorer } from "../oc/explorer.js";
+import { ExtrudeThroughAll } from "./infinite-extrude.js";
+export class Extrude extends ExtrudeBase {
+    distance;
+    constructor(distance, extrudable) {
+        super(extrudable);
+        this.distance = distance;
+    }
+    build(context) {
+        const plane = this.extrudable.getPlane();
+        const pickedFaces = this.resolvePickedFaces(plane);
+        if (pickedFaces !== null && pickedFaces.length === 0) {
+            return;
+        }
+        const faces = pickedFaces ?? FaceMaker2.getRegions(this.extrudable.getGeometries(), plane, this.getDrill());
+        if (this._operationMode === 'remove') {
+            this.buildRemove(faces, plane, context);
+        }
+        else if (this._symmetric) {
+            this.buildSymmetric(faces, plane, context);
+        }
+        else {
+            this.buildAdd(faces, plane, context);
+        }
+    }
+    buildAdd(faces, plane, context) {
+        const sceneObjects = this.resolveFusionScope(context.getSceneObjects());
+        const extruder = new Extruder(faces, plane, this.distance, this.getDraft(), this.getEndOffset());
+        let extrusions = extruder.extrude();
+        this.setState('start-faces', extruder.getStartFaces());
+        this.setState('end-faces', extruder.getEndFaces());
+        this.setState('side-faces', extruder.getSideFaces());
+        this.setState('internal-faces', extruder.getInternalFaces());
+        this.extrudable.removeShapes(this);
+        if (extrusions.length === 0 || sceneObjects.length === 0) {
+            this.addShapes(extrusions);
+            return;
+        }
+        const fusionResult = fuseWithSceneObjects(sceneObjects, extrusions);
+        for (const modifiedShape of fusionResult.modifiedShapes) {
+            if (!modifiedShape.object) {
+                continue;
+            }
+            modifiedShape.object.removeShape(modifiedShape.shape, this);
+        }
+        this.addShapes(fusionResult.newShapes);
+    }
+    buildSymmetric(faces, plane, context) {
+        const sceneObjects = this.resolveFusionScope(context.getSceneObjects());
+        const extruder1 = new Extruder(faces, plane, this.distance / 2, this.getDraft(), this.getEndOffset());
+        const extrusions1 = extruder1.extrude();
+        const startFaces = extruder1.getEndFaces();
+        const extruder2 = new Extruder(faces, plane, -this.distance / 2, this.getDraft(), this.getEndOffset());
+        const extrusions2 = extruder2.extrude();
+        const endFaces = extruder2.getEndFaces();
+        const preFusionInternalFaces = [
+            ...extruder1.getInternalFaces(),
+            ...extruder2.getInternalFaces(),
+        ];
+        const all = [...extrusions1, ...extrusions2];
+        const { result: extrusions } = BooleanOps.fuse(all);
+        const sideFaces = [];
+        const internalFaces = [];
+        for (const solid of extrusions) {
+            const allFaces = Explorer.findFacesWrapped(solid);
+            for (const f of allFaces) {
+                const isStart = startFaces.some(sf => f.getShape().IsSame(sf.getShape()));
+                const isEnd = endFaces.some(ef => f.getShape().IsSame(ef.getShape()));
+                if (!isStart && !isEnd) {
+                    const isInternal = preFusionInternalFaces.some(pf => f.getShape().IsSame(pf.getShape()));
+                    if (isInternal) {
+                        internalFaces.push(f);
+                    }
+                    else {
+                        sideFaces.push(f);
+                    }
+                }
+            }
+        }
+        this.setState('start-faces', startFaces);
+        this.setState('end-faces', endFaces);
+        this.setState('side-faces', sideFaces);
+        this.setState('internal-faces', internalFaces);
+        this.extrudable.removeShapes(this);
+        if (extrusions.length === 0 || sceneObjects.length === 0) {
+            this.addShapes(extrusions);
+            return;
+        }
+        const fusionResult = fuseWithSceneObjects(sceneObjects, extrusions);
+        for (const modifiedShape of fusionResult.modifiedShapes) {
+            if (!modifiedShape.object) {
+                continue;
+            }
+            modifiedShape.object.removeShape(modifiedShape.shape, this);
+        }
+        this.addShapes(fusionResult.newShapes);
+    }
+    buildRemove(faces, plane, context) {
+        const scope = this.resolveFusionScope(context.getSceneObjects());
+        let toolShapes;
+        const isThroughAll = this.distance === 0;
+        if (this._symmetric) {
+            // Symmetric cut: create tool centered on sketch plane
+            if (isThroughAll) {
+                const extrudeThroughAll = new ExtrudeThroughAll(this.extrudable, true, true);
+                toolShapes = extrudeThroughAll.build();
+            }
+            else {
+                const extruder1 = new Extruder(faces, plane, -this.distance / 2, this.getDraft(), this.getEndOffset());
+                const extrusions1 = extruder1.extrude();
+                const extruder2 = new Extruder(faces, plane, this.distance / 2, this.getDraft(), this.getEndOffset());
+                const extrusions2 = extruder2.extrude();
+                const all = [...extrusions1, ...extrusions2];
+                const { result } = BooleanOps.fuse(all);
+                toolShapes = result;
+            }
+        }
+        else if (isThroughAll) {
+            const extrudeThroughAll = new ExtrudeThroughAll(this.extrudable, false, true);
+            toolShapes = extrudeThroughAll.build();
+        }
+        else {
+            const distance = -this.distance;
+            const extruder = new Extruder(faces, plane, distance, this.getDraft(), this.getEndOffset());
+            toolShapes = extruder.extrude();
+        }
+        this.extrudable.removeShapes(this);
+        cutWithSceneObjects(scope, toolShapes, plane, this.distance, this);
+    }
+    getDependencies() {
+        return this.extrudable ? [this.extrudable] : [];
+    }
+    createCopy(remap) {
+        const extrudable = this.extrudable
+            ? (remap.get(this.extrudable) || this.extrudable)
+            : undefined;
+        return new Extrude(this.distance, extrudable).syncWith(this);
+    }
+    compareTo(other) {
+        if (!(other instanceof Extrude)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (!this.extrudable.compareTo(other.extrudable)) {
+            return false;
+        }
+        if (this.distance !== other.distance) {
+            return false;
+        }
+        return true;
+    }
+    getUniqueType() {
+        if (this._symmetric) {
+            return 'extrude-symmetric';
+        }
+        if (this._operationMode === 'remove') {
+            return 'cut-by-distance';
+        }
+        return 'extrude-by-distance';
+    }
+    serialize() {
+        return {
+            extrudable: this.extrudable.serialize(),
+            distance: this.distance,
+            operationMode: this._operationMode !== 'add' ? this._operationMode : undefined,
+            symmetric: this._symmetric || undefined,
+            draft: this.getDraft(),
+            endOffset: this.getEndOffset(),
+            picking: this.isPicking() || undefined,
+            pickPoints: this.isPicking()
+                ? this._pickPoints.map(p => { const pt = p.asPoint2D(); return [pt.x, pt.y]; })
+                : undefined,
+        };
+    }
+}

package/lib/dist/features/fillet.d.ts

@@ -0,0 +1,24 @@
+import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
+import { Shape } from "../common/shapes.js";
+export declare class Fillet extends SceneObject {
+    private radius;
+    private _targetEdges;
+    constructor(radius: number, ...selections: SceneObject[]);
+    get targetEdges(): SceneObject[];
+    build(context: BuildSceneObjectContext): void;
+    doBuild(sceneObjectsMap: Map<SceneObject, Shape[]>, selections: SceneObject[]): {
+        addedShapes: Shape<import("occjs-wrapper").TopoDS_Shape>[];
+        removedShapes: {
+            shape: Shape;
+            owner: SceneObject;
+        }[];
+    };
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
+    compareTo(other: Fillet): boolean;
+    getType(): string;
+    serialize(): {
+        edges: any[];
+        radius: number;
+    };
+}

package/lib/dist/features/fillet.js

@@ -0,0 +1,125 @@
+import { SceneObject } from "../common/scene-object.js";
+import { FilletOps } from "../oc/fillet-ops.js";
+import { Explorer } from "../oc/explorer.js";
+export class Fillet extends SceneObject {
+    radius;
+    _targetEdges = [];
+    constructor(radius, ...selections) {
+        super();
+        this.radius = radius;
+        this._targetEdges = selections;
+    }
+    get targetEdges() {
+        return this._targetEdges;
+    }
+    build(context) {
+        const selections = this.targetEdges;
+        let sceneObjects;
+        sceneObjects = new Map();
+        for (const obj of context.getSceneObjects()) {
+            const shapes = obj.getShapes({ excludeMeta: false }, 'solid');
+            if (shapes.length === 0) {
+                continue;
+            }
+            sceneObjects.set(obj, shapes);
+        }
+        const { addedShapes, removedShapes } = this.doBuild(sceneObjects, selections);
+        for (const item of removedShapes) {
+            item.owner.removeShape(item.shape, this);
+        }
+        this.addShapes(addedShapes);
+    }
+    doBuild(sceneObjectsMap, selections) {
+        const addedShapes = [];
+        const removedShapes = [];
+        let edges = [];
+        for (const selection of selections) {
+            const allEdgeShapes = selection.getShapes();
+            for (const shape of allEdgeShapes) {
+                if (shape.isEdge()) {
+                    edges.push(shape);
+                }
+                else {
+                    edges.push(...Explorer.findEdgesWrapped(shape));
+                }
+            }
+        }
+        console.log('Fillet: Target edges total count:', edges.length);
+        console.log('Fillet: Scene objects count:', sceneObjectsMap.size);
+        const sceneShapeObjectMap = new Map();
+        for (const [obj, shapes] of sceneObjectsMap.entries()) {
+            if (obj.id === this.parentId) {
+                continue;
+            }
+            for (const shape of shapes) {
+                sceneShapeObjectMap.set(shape, obj);
+            }
+        }
+        const allTargetSceneShapes = Array.from(sceneShapeObjectMap.keys());
+        for (const shape of allTargetSceneShapes) {
+            const solid = shape;
+            const targetEdges = edges.filter(e => solid.hasEdge(e.getShape()));
+            console.log('Fillet: Target edges count:', targetEdges.length);
+            if (!targetEdges.length) {
+                continue;
+            }
+            edges = edges.filter(e => !targetEdges.includes(e));
+            try {
+                const newShape = FilletOps.makeFillet(solid, targetEdges, this.radius);
+                const obj = sceneShapeObjectMap.get(shape);
+                removedShapes.push({ shape: solid, owner: obj });
+                const subShapes = Explorer.findSolidsWrapped(newShape);
+                for (const subShape of subShapes) {
+                    addedShapes.push(subShape);
+                }
+            }
+            catch {
+                console.error("Fillet: Failed to create fillet.");
+                continue;
+            }
+        }
+        for (const selection of selections) {
+            const shapes = selection.getShapes();
+            for (const shape of shapes) {
+                removedShapes.push({ shape, owner: selection });
+            }
+        }
+        return { addedShapes, removedShapes };
+    }
+    getDependencies() {
+        return [...this.targetEdges];
+    }
+    createCopy(remap) {
+        const selections = this.targetEdges.map(s => remap.get(s) || s);
+        return new Fillet(this.radius, ...selections);
+    }
+    compareTo(other) {
+        if (!(other instanceof Fillet)) {
+            return false;
+        }
+        if (this.radius !== other.radius) {
+            return false;
+        }
+        if (this.targetEdges.length !== other.targetEdges.length) {
+            return false;
+        }
+        for (let i = 0; i < this.targetEdges.length; i++) {
+            if (!this.targetEdges[i].compareTo(other.targetEdges[i])) {
+                return false;
+            }
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        return true;
+    }
+    getType() {
+        return "fillet";
+    }
+    serialize() {
+        return {
+            edges: this.targetEdges.map(s => s.serialize()),
+            radius: this.radius
+        };
+    }
+}

package/lib/dist/features/fillet2d.d.ts

@@ -0,0 +1,16 @@
+import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
+import { GeometrySceneObject } from "./2d/geometry.js";
+export declare class Fillet2D extends GeometrySceneObject {
+    private radius;
+    private _targetObjects;
+    constructor(radius: number, ...targets: SceneObject[]);
+    get targetObjects(): GeometrySceneObject[] | null;
+    build(context: BuildSceneObjectContext): void;
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
+    compareTo(other: Fillet2D): boolean;
+    getType(): string;
+    serialize(): {
+        radius: number;
+    };
+}

package/lib/dist/features/fillet2d.js

@@ -0,0 +1,98 @@
+import { Wire } from "../common/wire.js";
+import { GeometrySceneObject } from "./2d/geometry.js";
+import { FilletOps } from "../oc/fillet-ops.js";
+import { Edge } from "../common/edge.js";
+import { WireOps } from "../oc/wire-ops.js";
+export class Fillet2D extends GeometrySceneObject {
+    radius;
+    _targetObjects = null;
+    constructor(radius, ...targets) {
+        super();
+        this.radius = radius;
+        this._targetObjects = targets.length > 0 ? targets : null;
+    }
+    get targetObjects() {
+        return this._targetObjects;
+    }
+    build(context) {
+        let edges = new Map();
+        if (this.targetObjects === null) {
+            edges = this.sketch.getEdgesWithOwner();
+        }
+        else {
+            for (const obj of this.targetObjects) {
+                const wireShapes = obj.getShapes();
+                for (const shape of wireShapes) {
+                    if (shape instanceof Edge) {
+                        edges.set(shape, obj);
+                    }
+                    else if (shape instanceof Wire) {
+                        for (const edge of shape.getEdges()) {
+                            edges.set(edge, obj);
+                        }
+                    }
+                }
+            }
+        }
+        const allEdges = Array.from(edges.keys());
+        const wires = [];
+        const groups = WireOps.groupConnectedEdges(allEdges);
+        for (const group of groups) {
+            const wire = WireOps.makeWireFromEdges(group);
+            wires.push({
+                wire,
+                edges: new Map(group.map(edge => [edge, edges.get(edge)]))
+            });
+        }
+        for (const wireInfo of wires) {
+            const filletedWire = FilletOps.fillet2d(wireInfo.wire, this.sketch.getPlane(), this.radius);
+            const edges = filletedWire.getEdges();
+            for (const edge of edges) {
+                this.addShape(edge);
+            }
+            for (const [edge, owner] of wireInfo.edges) {
+                console.log("Fillet2D: Removing edge from owner", owner.getType(), owner.id);
+                owner.removeShape(edge, this);
+            }
+        }
+    }
+    getDependencies() {
+        return this.targetObjects ? [...this.targetObjects] : [];
+    }
+    createCopy(remap) {
+        const targets = this.targetObjects
+            ? this.targetObjects.map(t => remap.get(t) || t)
+            : [];
+        return new Fillet2D(this.radius, ...targets);
+    }
+    compareTo(other) {
+        if (!(other instanceof Fillet2D)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (this.radius !== other.radius) {
+            return false;
+        }
+        const thisTargets = this.targetObjects || [];
+        const otherTargets = other.targetObjects || [];
+        if (thisTargets.length !== otherTargets.length) {
+            return false;
+        }
+        for (let i = 0; i < thisTargets.length; i++) {
+            if (!thisTargets[i].compareTo(otherTargets[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    getType() {
+        return "fillet2d";
+    }
+    serialize() {
+        return {
+            radius: this.radius
+        };
+    }
+}

package/lib/dist/features/fuse.d.ts

@@ -0,0 +1,10 @@
+import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
+export declare class Fuse extends SceneObject {
+    private _sceneObjects;
+    constructor(...objects: SceneObject[]);
+    get sceneObjects(): SceneObject[];
+    build(context: BuildSceneObjectContext): void;
+    compareTo(other: Fuse): boolean;
+    getType(): string;
+    serialize(): {};
+}

package/lib/dist/features/fuse.js

@@ -0,0 +1,63 @@
+import { SceneObject } from "../common/scene-object.js";
+import { BooleanOps } from "../oc/boolean-ops.js";
+export class Fuse extends SceneObject {
+    _sceneObjects = [];
+    constructor(...objects) {
+        super();
+        this._sceneObjects = objects;
+    }
+    get sceneObjects() {
+        return this._sceneObjects;
+    }
+    build(context) {
+        let sceneObjects = this.sceneObjects;
+        if (sceneObjects?.length === 0) {
+            sceneObjects = context.getSceneObjects();
+        }
+        const objShapeMap = new Map();
+        for (const obj of sceneObjects) {
+            for (const shape of obj.getShapes({}, 'solid')) {
+                objShapeMap.set(shape, obj);
+            }
+        }
+        const allShapes = Array.from(objShapeMap.keys());
+        if (allShapes.length < 2) {
+            return;
+        }
+        const fuseResult = BooleanOps.fuse(allShapes);
+        if (fuseResult.result.length === allShapes.length) {
+            return;
+        }
+        if (!fuseResult.modifiedShapes.length) {
+            return;
+        }
+        for (const shape of fuseResult.modifiedShapes) {
+            const obj = objShapeMap.get(shape);
+            obj.removeShape(shape, this);
+        }
+        this.addShapes(fuseResult.newShapes);
+    }
+    compareTo(other) {
+        if (!(other instanceof Fuse)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (this.sceneObjects.length !== other.sceneObjects.length) {
+            return false;
+        }
+        for (let i = 0; i < this.sceneObjects.length; i++) {
+            if (!this.sceneObjects[i].compareTo(other.sceneObjects[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    getType() {
+        return "fuse";
+    }
+    serialize() {
+        return {};
+    }
+}

package/lib/dist/features/fuse2d.d.ts

@@ -0,0 +1,13 @@
+import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
+import { GeometrySceneObject } from "./2d/geometry.js";
+export declare class Fuse2D extends GeometrySceneObject {
+    private _targetObjects;
+    constructor(...targets: GeometrySceneObject[]);
+    get targetObjects(): GeometrySceneObject[] | null;
+    build(context: BuildSceneObjectContext): void;
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
+    compareTo(other: Fuse2D): boolean;
+    getType(): string;
+    serialize(): {};
+}

package/lib/dist/features/fuse2d.js

@@ -0,0 +1,86 @@
+import { Wire } from "../common/wire.js";
+import { Edge } from "../common/edge.js";
+import { GeometrySceneObject } from "./2d/geometry.js";
+import { BooleanOps } from "../oc/boolean-ops.js";
+import { WireOps } from "../oc/wire-ops.js";
+import { FaceOps } from "../oc/face-ops.js";
+export class Fuse2D extends GeometrySceneObject {
+    _targetObjects = null;
+    constructor(...targets) {
+        super();
+        this._targetObjects = targets.length > 0 ? targets : null;
+    }
+    get targetObjects() {
+        return this._targetObjects;
+    }
+    build(context) {
+        let sourceEdges;
+        if (this._targetObjects === null) {
+            sourceEdges = this.sketch.getGeometriesWithOwner();
+        }
+        else {
+            sourceEdges = new Map();
+            for (const obj of this._targetObjects) {
+                for (const shape of obj.getShapes()) {
+                    if (shape instanceof Edge) {
+                        sourceEdges.set(shape, obj);
+                    }
+                    else if (shape instanceof Wire) {
+                        for (const edge of shape.getEdges()) {
+                            sourceEdges.set(edge, obj);
+                        }
+                    }
+                }
+            }
+        }
+        const allEdges = Array.from(sourceEdges.keys()).filter(edge => edge.isClosed());
+        const wires = allEdges.map(edge => WireOps.makeWireFromEdges([edge]));
+        const faces = wires.map(wire => FaceOps.makeFaceWrapped(wire));
+        const { newShapes } = BooleanOps.fuseFaces(faces);
+        if (newShapes.length === 0) {
+            return;
+        }
+        const newEdges = newShapes.flatMap((face) => face.getEdges());
+        for (const [edge, owner] of sourceEdges) {
+            if (!allEdges.includes(edge)) {
+                continue;
+            }
+            owner.removeShape(edge, this);
+        }
+        this.addShapes(newEdges);
+    }
+    getDependencies() {
+        return this._targetObjects ? [...this._targetObjects] : [];
+    }
+    createCopy(remap) {
+        const targets = this._targetObjects
+            ? this._targetObjects.map(t => remap.get(t) || t)
+            : [];
+        return new Fuse2D(...targets);
+    }
+    compareTo(other) {
+        if (!(other instanceof Fuse2D)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        const thisTargets = this._targetObjects || [];
+        const otherTargets = other._targetObjects || [];
+        if (thisTargets.length !== otherTargets.length) {
+            return false;
+        }
+        for (let i = 0; i < thisTargets.length; i++) {
+            if (!thisTargets[i].compareTo(otherTargets[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    getType() {
+        return "fuse2d";
+    }
+    serialize() {
+        return {};
+    }
+}

package/lib/dist/features/infinite-extrude.d.ts

@@ -0,0 +1,10 @@
+import { Solid } from "../common/shapes.js";
+import { Extrudable } from "../helpers/types.js";
+export declare class ExtrudeThroughAll {
+    extrudable: Extrudable;
+    symmetric: boolean;
+    reversed: boolean;
+    private shapes;
+    constructor(extrudable: Extrudable, symmetric: boolean, reversed: boolean);
+    build(): Solid[];
+}

package/lib/dist/features/infinite-extrude.js

@@ -0,0 +1,44 @@
+import { ExtrudeOps } from "../oc/extrude-ops.js";
+import { FaceMaker2 } from "../oc/face-maker2.js";
+export class ExtrudeThroughAll {
+    extrudable;
+    symmetric;
+    reversed;
+    shapes = null;
+    constructor(extrudable, symmetric, reversed) {
+        this.extrudable = extrudable;
+        this.symmetric = symmetric;
+        this.reversed = reversed;
+    }
+    build() {
+        if (this.shapes) {
+            return this.shapes;
+        }
+        const solids = [];
+        const wires = this.extrudable.getGeometries();
+        const plane = this.extrudable.getPlane();
+        const faces = FaceMaker2.getRegions(wires, plane);
+        console.log("Extruding faces:", faces);
+        let dir = plane.normal;
+        if (this.reversed) {
+            dir = dir.multiply(-1);
+        }
+        if (this.symmetric) {
+            for (const face of faces) {
+                const solid = ExtrudeOps.makePrismSymmetric(face, dir);
+                solids.push(solid);
+                face.dispose();
+            }
+        }
+        else {
+            dir = dir.multiply(100000);
+            for (const face of faces) {
+                const solid = ExtrudeOps.makePrism(face, dir, 1);
+                solids.push(solid);
+                face.dispose();
+            }
+        }
+        this.shapes = solids;
+        return solids;
+    }
+}