fluidcad 0.0.2

package/lib/dist/features/cut-base.js

@@ -0,0 +1,312 @@
+import { SceneObject } from "../common/scene-object.js";
+import { LazySelectionSceneObject } from "./lazy-scene-object.js";
+import { normalizePoint2D } from "../helpers/normalize.js";
+import { FaceOps } from "../oc/face-ops.js";
+import { FaceMaker2 } from "../oc/face-maker2.js";
+import { EdgeOps } from "../oc/edge-ops.js";
+import { Explorer } from "../oc/explorer.js";
+import { FaceFilterBuilder } from "../filters/face/face-filter.js";
+import { EdgeFilterBuilder } from "../filters/edge/edge-filter.js";
+import { ShapeFilter } from "../filters/filter.js";
+export class CutBase extends SceneObject {
+    _extrudable = null;
+    _draft;
+    _endOffset;
+    _picking = false;
+    _pickPoints = [];
+    constructor(extrudable) {
+        super();
+        this._extrudable = extrudable ?? null;
+    }
+    get extrudable() {
+        return this._extrudable;
+    }
+    draft(value) {
+        this._draft = value;
+        return this;
+    }
+    endOffset(value) {
+        this._endOffset = value;
+        return this;
+    }
+    getDraft() {
+        const draft = this._draft;
+        if (!draft) {
+            return null;
+        }
+        return draft instanceof Array ? draft : [draft, draft];
+    }
+    getEndOffset() {
+        return this._endOffset;
+    }
+    pick(...points) {
+        this._picking = true;
+        this._pickPoints = points.map(p => normalizePoint2D(p));
+        return this;
+    }
+    isPicking() {
+        return this._picking;
+    }
+    getPickPoints() {
+        return this._pickPoints;
+    }
+    resolvePickedFaces(plane) {
+        if (!this.isPicking()) {
+            return null;
+        }
+        const sketchShapes = this.extrudable.getGeometries();
+        const cells = FaceMaker2.getRegions(sketchShapes, plane, false);
+        if (cells.length === 0) {
+            return [];
+        }
+        const pickPoints = this.getPickPoints();
+        const selectedCells = [];
+        for (const cell of cells) {
+            let isSelected = false;
+            let pickPoint = null;
+            for (const lazyPt of pickPoints) {
+                const pt2d = lazyPt.asPoint2D();
+                const pt3d = plane.localToWorld(pt2d);
+                if (FaceOps.isPointInsideFace(pt3d, cell)) {
+                    isSelected = true;
+                    pickPoint = [pt2d.x, pt2d.y];
+                    break;
+                }
+            }
+            if (isSelected) {
+                cell.markAsMetaShape('pick-region-selected');
+                cell.metaData = { pickPoint };
+                selectedCells.push(cell);
+            }
+            else {
+                cell.markAsMetaShape('pick-region');
+            }
+            this.addShape(cell);
+            for (const edge of cell.getEdges()) {
+                edge.markAsMetaShape('pick-edge');
+                this.addShape(edge);
+            }
+        }
+        return selectedCells;
+    }
+    removeMetaShapes(removedBy) {
+        for (const shape of this.getAddedShapes()) {
+            if (shape.isMetaShape()) {
+                this.removeShape(shape, removedBy);
+            }
+        }
+    }
+    clean(allObjects) {
+        if (!this.isPicking()) {
+            return;
+        }
+        const lastObject = allObjects[allObjects.length - 1];
+        if (lastObject !== this) {
+            this.removeMetaShapes(lastObject);
+        }
+    }
+    /**
+     * Classifies edges and faces from cleaned result shapes by comparing with
+     * original stock shapes. Edges/faces not present in stock are "section" geometry
+     * created by the cut. Section edges are further classified by signed distance
+     * from the cut plane into start, end, and internal groups.
+     */
+    classifyCutResult(stockShapes, cleanedShapes, plane, cutDistance) {
+        // Collect stock edge midpoints for geometric comparison
+        const stockEdgeMidpoints = [];
+        for (const stock of stockShapes) {
+            const edges = Explorer.findEdgesWrapped(stock);
+            for (const edge of edges) {
+                stockEdgeMidpoints.push(EdgeOps.getEdgeMidPoint(edge));
+            }
+        }
+        const tolerance = 1e-6;
+        const isStockEdge = (edge) => {
+            const mid = EdgeOps.getEdgeMidPoint(edge);
+            return stockEdgeMidpoints.some(sm => Math.abs(mid.x - sm.x) < tolerance &&
+                Math.abs(mid.y - sm.y) < tolerance &&
+                Math.abs(mid.z - sm.z) < tolerance);
+        };
+        // Find section edges from cleaned result (edges not in stock)
+        const sectionEdges = [];
+        const sectionEdgeSet = new Set();
+        for (const shape of cleanedShapes) {
+            const edges = Explorer.findEdgesWrapped(shape);
+            for (const edge of edges) {
+                if (!isStockEdge(edge)) {
+                    sectionEdges.push(edge);
+                    sectionEdgeSet.add(edge);
+                }
+            }
+        }
+        // Internal faces: faces where ALL edges are section edges (not from stock).
+        // Modified stock faces (e.g., top face with holes) still have stock edges
+        // on their outer boundary, so they are correctly excluded.
+        const internalFaces = [];
+        for (const shape of cleanedShapes) {
+            const faces = Explorer.findFacesWrapped(shape);
+            for (const f of faces) {
+                const faceEdges = f.getEdges();
+                if (faceEdges.length > 0 && faceEdges.every(e => !isStockEdge(e))) {
+                    internalFaces.push(f);
+                }
+            }
+        }
+        // Classify section edges by signed distance from cut plane
+        const startEdges = [];
+        const endEdges = [];
+        const internalEdges = [];
+        if (plane && sectionEdges.length > 0) {
+            const isThroughAll = cutDistance === 0;
+            const dists = sectionEdges.map(edge => ({
+                edge,
+                d: plane.signedDistanceToPoint(EdgeOps.getEdgeMidPoint(edge))
+            }));
+            const startDist = isThroughAll ? Math.max(...dists.map(e => e.d)) : 0;
+            const endDist = isThroughAll ? Math.min(...dists.map(e => e.d)) : -cutDistance;
+            const distTolerance = 1e-4;
+            for (const { edge, d } of dists) {
+                if (Math.abs(d - startDist) < distTolerance) {
+                    startEdges.push(edge);
+                }
+                else if (Math.abs(d - endDist) < distTolerance) {
+                    endEdges.push(edge);
+                }
+                else {
+                    internalEdges.push(edge);
+                }
+            }
+        }
+        this.setState('section-edges', sectionEdges);
+        this.setState('start-edges', startEdges);
+        this.setState('end-edges', endEdges);
+        this.setState('internal-edges', internalEdges);
+        this.setState('internal-faces', internalFaces);
+    }
+    syncWith(other) {
+        this._draft = other._draft;
+        this._endOffset = other._endOffset;
+        this._fusionScope = other.getFusionScope();
+        this._picking = other._picking;
+        this._pickPoints = other._pickPoints;
+        return this;
+    }
+    compareTo(other) {
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (this._fusionScope !== other._fusionScope
+            || this._endOffset !== other._endOffset) {
+            return false;
+        }
+        if (this._picking !== other._picking) {
+            return false;
+        }
+        if (this._pickPoints.length !== other._pickPoints.length) {
+            return false;
+        }
+        for (let i = 0; i < this._pickPoints.length; i++) {
+            if (!this._pickPoints[i].compareTo(other._pickPoints[i])) {
+                return false;
+            }
+        }
+        let thisDraft = this._draft || [0, 0];
+        let otherDraft = other._draft || [0, 0];
+        thisDraft = this._draft instanceof Array ? this._draft : [this._draft, this._draft];
+        otherDraft = other._draft instanceof Array ? other._draft : [other._draft, other._draft];
+        if (thisDraft[0] !== otherDraft[0] || thisDraft[1] !== otherDraft[1]) {
+            return false;
+        }
+        return true;
+    }
+    startEdges(...args) {
+        const suffix = this.buildSuffix('start-edges', args);
+        return new LazySelectionSceneObject(`${this.generateUniqueName(suffix)}`, (parent) => {
+            const edges = parent.getState('start-edges') || [];
+            const transform = parent.getTransform();
+            const originalEdges = transform
+                ? (this.getState('start-edges') || [])
+                : null;
+            return this.resolveEdges(edges, args, transform, originalEdges);
+        }, this);
+    }
+    endEdges(...args) {
+        const suffix = this.buildSuffix('end-edges', args);
+        return new LazySelectionSceneObject(`${this.generateUniqueName(suffix)}`, (parent) => {
+            const edges = parent.getState('end-edges') || [];
+            const transform = parent.getTransform();
+            const originalEdges = transform
+                ? (this.getState('end-edges') || [])
+                : null;
+            return this.resolveEdges(edges, args, transform, originalEdges);
+        }, this);
+    }
+    internalEdges(...args) {
+        const suffix = this.buildSuffix('internal-edges', args);
+        return new LazySelectionSceneObject(`${this.generateUniqueName(suffix)}`, (parent) => {
+            const edges = parent.getState('internal-edges') || [];
+            const transform = parent.getTransform();
+            const originalEdges = transform
+                ? (this.getState('internal-edges') || [])
+                : null;
+            return this.resolveEdges(edges, args, transform, originalEdges);
+        }, this);
+    }
+    internalFaces(...args) {
+        const suffix = this.buildSuffix('internal-faces', args);
+        return new LazySelectionSceneObject(`${this.generateUniqueName(suffix)}`, (parent) => {
+            const faces = parent.getState('internal-faces') || [];
+            const transform = parent.getTransform();
+            const originalFaces = transform
+                ? (this.getState('internal-faces') || [])
+                : null;
+            return this.resolveFaces(faces, args, transform, originalFaces);
+        }, this);
+    }
+    buildSuffix(prefix, args) {
+        if (args.length === 0) {
+            return prefix;
+        }
+        const key = args.map(a => typeof a === 'number' ? a : 'f').join('-');
+        return `${prefix}-${key}`;
+    }
+    resolveEdges(shapes, args, transform = null, originalShapes = null) {
+        if (args.length === 0) {
+            return shapes;
+        }
+        if (args.every(a => typeof a === 'number')) {
+            const indices = args;
+            let filters = indices.map(i => new EdgeFilterBuilder().atIndex(i, shapes, originalShapes));
+            if (transform) {
+                filters = filters.map(f => f.transform(transform));
+            }
+            return new ShapeFilter(shapes, ...filters).apply();
+        }
+        let filters = args.filter(a => a instanceof EdgeFilterBuilder);
+        if (transform) {
+            filters = filters.map(f => f.transform(transform));
+        }
+        return new ShapeFilter(shapes, ...filters).apply();
+    }
+    resolveFaces(shapes, args, transform = null, originalShapes = null) {
+        if (args.length === 0) {
+            return shapes;
+        }
+        if (args.every(a => typeof a === 'number')) {
+            const indices = args;
+            let filters = indices.map(i => new FaceFilterBuilder().atIndex(i, shapes, originalShapes));
+            if (transform) {
+                filters = filters.map(f => f.transform(transform));
+            }
+            return new ShapeFilter(shapes, ...filters).apply();
+        }
+        let filters = args.filter(a => a instanceof FaceFilterBuilder);
+        if (transform) {
+            filters = filters.map(f => f.transform(transform));
+        }
+        return new ShapeFilter(shapes, ...filters).apply();
+    }
+    getType() {
+        return "cut";
+    }
+}

package/lib/dist/features/cut-symmetric.d.ts

@@ -0,0 +1,23 @@
+import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
+import { Extrudable } from "../helpers/types.js";
+import { CutBase } from "./cut-base.js";
+export declare class CutSymmetric extends CutBase {
+    distance: number;
+    constructor(distance: number, extrudable?: Extrudable);
+    build(context: BuildSceneObjectContext): void;
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
+    compareTo(other: CutSymmetric): boolean;
+    edges(...indices: number[]): SceneObject;
+    getType(): string;
+    serialize(): {
+        extrudable: any;
+        distance: number;
+        symmetric: boolean;
+        draft: [number, number];
+        endOffset: number;
+        fusionScope: import("./extrude-options.js").FusionScope;
+        picking: true;
+        pickPoints: number[][];
+    };
+}

package/lib/dist/features/cut-symmetric.js

@@ -0,0 +1,119 @@
+import { BooleanOps } from "../oc/boolean-ops.js";
+import { ShapeOps } from "../oc/shape-ops.js";
+import { ExtrudeOps } from "../oc/extrude-ops.js";
+import { ExtrudeThroughAll } from "./infinite-extrude.js";
+import { LazySelectionSceneObject } from "./lazy-scene-object.js";
+import { CutBase } from "./cut-base.js";
+import { FaceMaker2 } from "../oc/face-maker2.js";
+export class CutSymmetric extends CutBase {
+    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 scope = this.resolveFusionScope(context.getSceneObjects());
+        const sceneObjects = new Map();
+        for (const obj of scope) {
+            const shapes = obj.getShapes({ excludeMeta: false }, 'solid');
+            if (shapes.length === 0) {
+                continue;
+            }
+            sceneObjects.set(obj, shapes);
+        }
+        let toolShapes;
+        const isThroughAll = this.distance === 0;
+        if (isThroughAll && !pickedFaces) {
+            const extrudeThroughAll = new ExtrudeThroughAll(this.extrudable, true, false);
+            toolShapes = extrudeThroughAll.build();
+        }
+        else {
+            const faces = pickedFaces ?? FaceMaker2.getRegions(this.extrudable.getGeometries(), plane);
+            const effectiveDistance = isThroughAll ? 10000 : this.distance;
+            const vec = plane.normal.multiply(effectiveDistance);
+            const translateVec = vec.multiply(-0.5);
+            toolShapes = [];
+            for (const face of faces) {
+                const { solid: rawSolid } = ExtrudeOps.makePrismFromVec(face, vec);
+                const solid = ShapeOps.translateShape(ShapeOps.cleanShape(rawSolid), translateVec);
+                toolShapes.push(solid);
+            }
+        }
+        this.extrudable.removeShapes(this);
+        const shapeObjectMap = new Map();
+        for (const [obj, shapes] of sceneObjects) {
+            for (const shape of shapes) {
+                shapeObjectMap.set(shape, obj);
+            }
+        }
+        const stock = Array.from(shapeObjectMap.keys());
+        const cutResult = BooleanOps.cutMultiShape(stock, toolShapes, plane, this.distance);
+        const cleanedShapes = [];
+        for (const shape of stock) {
+            const list = cutResult.modified(shape);
+            if (list.length) {
+                for (const newShape of list) {
+                    const s = ShapeOps.cleanShape(newShape);
+                    this.addShape(s);
+                    cleanedShapes.push(s);
+                }
+                const obj = shapeObjectMap.get(shape);
+                obj.removeShape(shape, this);
+            }
+        }
+        this.classifyCutResult(stock, cleanedShapes, plane, this.distance);
+    }
+    getDependencies() {
+        return this.extrudable ? [this.extrudable] : [];
+    }
+    createCopy(remap) {
+        const extrudable = this.extrudable
+            ? (remap.get(this.extrudable) || this.extrudable)
+            : undefined;
+        return new CutSymmetric(this.distance, extrudable).syncWith(this);
+    }
+    compareTo(other) {
+        if (!(other instanceof CutSymmetric)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (this.distance !== other.distance) {
+            return false;
+        }
+        return true;
+    }
+    edges(...indices) {
+        const suffix = indices.length > 0 ? `section-edges-${indices.join('-')}` : 'section-edges';
+        return new LazySelectionSceneObject(`${this.getOrder()}-cut-symmetric-${suffix}`, (parent) => {
+            const edges = parent.getState('section-edges') || [];
+            if (indices.length === 0) {
+                return edges;
+            }
+            return indices.filter(i => i >= 0 && i < edges.length).map(i => edges[i]);
+        }, this);
+    }
+    getType() {
+        return "cut-symmetric";
+    }
+    serialize() {
+        return {
+            extrudable: this.extrudable.serialize(),
+            distance: this.distance,
+            symmetric: true,
+            draft: this.getDraft(),
+            endOffset: this.getEndOffset(),
+            fusionScope: this.getFusionScope(),
+            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/cut-two-distances.d.ts

@@ -0,0 +1,24 @@
+import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
+import { Extrudable } from "../helpers/types.js";
+import { CutBase } from "./cut-base.js";
+export declare class CutTwoDistances extends CutBase {
+    distance1: number;
+    distance2: number;
+    constructor(distance1: number, distance2: number, extrudable?: Extrudable);
+    build(context: BuildSceneObjectContext): void;
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
+    compareTo(other: CutTwoDistances): boolean;
+    edges(...indices: number[]): SceneObject;
+    getUniqueType(): string;
+    serialize(): {
+        extrudable: any;
+        distance1: number;
+        distance2: number;
+        draft: [number, number];
+        endOffset: number;
+        fusionScope: import("./extrude-options.js").FusionScope;
+        picking: true;
+        pickPoints: number[][];
+    };
+}

package/lib/dist/features/cut-two-distances.js

@@ -0,0 +1,110 @@
+import { Extruder } from "./simple-extruder.js";
+import { BooleanOps } from "../oc/boolean-ops.js";
+import { ShapeOps } from "../oc/shape-ops.js";
+import { LazySelectionSceneObject } from "./lazy-scene-object.js";
+import { CutBase } from "./cut-base.js";
+import { FaceMaker2 } from "../oc/face-maker2.js";
+export class CutTwoDistances extends CutBase {
+    distance1;
+    distance2;
+    constructor(distance1, distance2, extrudable) {
+        super(extrudable);
+        this.distance1 = distance1;
+        this.distance2 = distance2;
+    }
+    build(context) {
+        const plane = this.extrudable.getPlane();
+        const pickedFaces = this.resolvePickedFaces(plane);
+        if (pickedFaces !== null && pickedFaces.length === 0) {
+            return;
+        }
+        const scope = this.resolveFusionScope(context.getSceneObjects());
+        const sceneObjects = new Map();
+        for (const obj of scope) {
+            const shapes = obj.getShapes({}, 'solid');
+            if (shapes.length === 0) {
+                continue;
+            }
+            sceneObjects.set(obj, shapes);
+        }
+        const faces = pickedFaces ?? FaceMaker2.getRegions(this.extrudable.getGeometries(), plane);
+        // Positive distance = reverse normal direction, negate before passing to Extruder
+        const extruder1 = new Extruder(faces, plane, -this.distance1, this.getDraft(), this.getEndOffset());
+        const extrusions1 = extruder1.extrude();
+        const extruder2 = new Extruder(faces, plane, this.distance2, this.getDraft(), this.getEndOffset());
+        const extrusions2 = extruder2.extrude();
+        const all = [...extrusions1, ...extrusions2];
+        const { result: toolShapes } = BooleanOps.fuse(all);
+        this.extrudable.removeShapes(this);
+        const shapeObjectMap = new Map();
+        for (const [obj, shapes] of sceneObjects) {
+            for (const shape of shapes) {
+                shapeObjectMap.set(shape, obj);
+            }
+        }
+        const stock = Array.from(shapeObjectMap.keys());
+        const cutResult = BooleanOps.cutMultiShape(stock, toolShapes, plane, this.distance1);
+        const cleanedShapes = [];
+        for (const shape of stock) {
+            const list = cutResult.modified(shape);
+            if (list.length) {
+                for (const newShape of list) {
+                    const s = ShapeOps.cleanShape(newShape);
+                    this.addShape(s);
+                    cleanedShapes.push(s);
+                }
+                const obj = shapeObjectMap.get(shape);
+                obj.removeShape(shape, this);
+            }
+        }
+        this.classifyCutResult(stock, cleanedShapes, plane, this.distance1);
+    }
+    getDependencies() {
+        return this.extrudable ? [this.extrudable] : [];
+    }
+    createCopy(remap) {
+        const extrudable = this.extrudable
+            ? (remap.get(this.extrudable) || this.extrudable)
+            : undefined;
+        return new CutTwoDistances(this.distance1, this.distance2, extrudable).syncWith(this);
+    }
+    compareTo(other) {
+        if (!(other instanceof CutTwoDistances)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (this.distance1 !== other.distance1 || this.distance2 !== other.distance2) {
+            return false;
+        }
+        return true;
+    }
+    edges(...indices) {
+        const suffix = indices.length > 0 ? `section-edges-${indices.join('-')}` : 'section-edges';
+        return new LazySelectionSceneObject(`${this.getOrder()}-cut-two-distances-${suffix}`, (parent) => {
+            const edges = parent.getState('section-edges') || [];
+            if (indices.length === 0) {
+                return edges;
+            }
+            return indices.filter(i => i >= 0 && i < edges.length).map(i => edges[i]);
+        }, this);
+    }
+    getUniqueType() {
+        return 'cut-by-two-distances';
+    }
+    serialize() {
+        return {
+            extrudable: this.extrudable.serialize(),
+            distance1: this.distance1,
+            distance2: this.distance2,
+            draft: this.getDraft(),
+            endOffset: this.getEndOffset(),
+            fusionScope: this.getFusionScope(),
+            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/cut.d.ts

@@ -0,0 +1,27 @@
+import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
+import { ExtrudeOptions } from "./extrude-options.js";
+import { Extrudable } from "../helpers/types.js";
+export interface CutOptions extends ExtrudeOptions {
+}
+export type CutDirection = 'normal' | 'reversed' | 'symmetric';
+export type CutRotation = {
+    x?: number;
+    y?: number;
+};
+export declare class Cut extends SceneObject {
+    private extrudable;
+    distance: number;
+    options: CutOptions;
+    isThroughAll: boolean;
+    constructor(extrudable: Extrudable, distance: number, options?: CutOptions);
+    build(context: BuildSceneObjectContext): void;
+    clone(): SceneObject[];
+    compareTo(other: Cut): boolean;
+    getType(): string;
+    serialize(): {
+        extrudable: any;
+        distance: number;
+        isThroughAll: boolean;
+        options: CutOptions;
+    };
+}