fluidcad 0.0.21 → 0.0.23

package/lib/dist/features/trim2d.js

@@ -2,22 +2,35 @@ import { Wire } from "../common/wire.js";
 import { Edge } from "../common/edge.js";
 import { GeometrySceneObject } from "./2d/geometry.js";
 import { EdgeOps } from "../oc/edge-ops.js";
+import { ShapeFilter } from "../filters/filter.js";
 export class Trim2D extends GeometrySceneObject {
-    _points = [];
+    _filters = [];
+    _picking = false;
+    _pickPoints = [];
     constructor() {
         super();
     }
-    points(...ps) {
-        this._points = ps;
+    setFilters(...fs) {
+        this._filters = fs;
         return this;
     }
-    get trimPoints() {
-        return this._points;
+    pick(...ps) {
+        this._picking = true;
+        this._pickPoints = ps;
+        return this;
+    }
+    isPicking() {
+        return this._picking;
+    }
+    getPickPoints() {
+        return this._pickPoints;
+    }
+    get filters() {
+        return this._filters;
     }
     build() {
         const plane = this.sketch.getPlane();
         const sourceWires = this.sketch.getGeometriesWithOwner();
-        // Collect all individual edges from wires/edges in the sketch
         const allEdges = [];
         const edgeToOwner = new Map();
         for (const [wireOrEdge, owner] of sourceWires) {
@@ -35,25 +48,49 @@ export class Trim2D extends GeometrySceneObject {
         if (allEdges.length === 0) {
             return;
         }
+        if (this._filters.length > 0) {
+            this.buildWithFilters(allEdges, edgeToOwner);
+        }
+        if (this._picking) {
+            let pickableEdges;
+            if (this._filters.length > 0) {
+                const matched = new Set(new ShapeFilter(allEdges, ...this._filters).apply());
+                pickableEdges = allEdges.filter(e => !matched.has(e));
+            }
+            else {
+                pickableEdges = allEdges;
+            }
+            this.buildWithPicking(pickableEdges, edgeToOwner, plane);
+        }
+    }
+    buildWithFilters(allEdges, edgeToOwner) {
+        const matchedEdges = new ShapeFilter(allEdges, ...this._filters).apply();
+        const removedWires = new Set();
+        for (const edge of matchedEdges) {
+            const entry = edgeToOwner.get(edge);
+            if (!removedWires.has(entry.wire)) {
+                removedWires.add(entry.wire);
+                entry.owner.removeShape(entry.wire, this);
+            }
+        }
+    }
+    buildWithPicking(pickableEdges, edgeToOwner, plane) {
         const TRIM_TOLERANCE = 50;
-        // Split all edges at intersection points
-        const splitResult = EdgeOps.splitEdgesWithMapping(allEdges);
+        const splitResult = EdgeOps.splitEdgesWithMapping(pickableEdges);
         const splitEdges = splitResult.edges;
         const sourceIndex = splitResult.sourceIndex;
-        // Find split edges to remove
         const splitEdgesToRemove = new Set();
-        if (this._points.length > 0) {
-            for (const lazyPoint of this._points) {
+        if (this._pickPoints.length > 0) {
+            for (const lazyPoint of this._pickPoints) {
                 const point2d = lazyPoint.asPoint2D();
                 const point3d = plane.localToWorld(point2d);
                 for (const idx of EdgeOps.findNearestEdgeIndices(splitEdges, point3d, TRIM_TOLERANCE)) {
                     splitEdgesToRemove.add(idx);
                 }
             }
-            // Remove affected original wires and re-add surviving split edges
             const removedWires = new Set();
             for (const idx of splitEdgesToRemove) {
-                const origEdge = allEdges[sourceIndex[idx]];
+                const origEdge = pickableEdges[sourceIndex[idx]];
                 const entry = edgeToOwner.get(origEdge);
                 if (!removedWires.has(entry.wire)) {
                     removedWires.add(entry.wire);
@@ -64,7 +101,7 @@ export class Trim2D extends GeometrySceneObject {
                 if (splitEdgesToRemove.has(i)) {
                     continue;
                 }
-                const origEdge = allEdges[sourceIndex[i]];
+                const origEdge = pickableEdges[sourceIndex[i]];
                 const entry = edgeToOwner.get(origEdge);
                 if (removedWires.has(entry.wire)) {
                     this.addShape(splitEdges[i]);
@@ -72,11 +109,8 @@ export class Trim2D extends GeometrySceneObject {
             }
         }
         // --- Meta shapes for segment-level hover ---
-        // Originals with trims need the first-pass split (to preserve trim boundaries).
-        // Originals without trims are re-split against only surviving edges
-        // (so ghost intersections from fully-removed edges disappear).
         const origSurvives = new Set();
-        const origHasTrim = new Array(allEdges.length).fill(false);
+        const origHasTrim = new Array(pickableEdges.length).fill(false);
         for (let i = 0; i < splitEdges.length; i++) {
             if (!splitEdgesToRemove.has(i)) {
                 origSurvives.add(sourceIndex[i]);
@@ -85,17 +119,15 @@ export class Trim2D extends GeometrySceneObject {
                 origHasTrim[sourceIndex[i]] = true;
             }
         }
-        // Re-split only surviving originals (for clean meta shapes of untrimmed edges)
         const metaInputEdges = [];
         const metaInputToOrig = [];
-        for (let i = 0; i < allEdges.length; i++) {
+        for (let i = 0; i < pickableEdges.length; i++) {
             if (origSurvives.has(i)) {
-                metaInputEdges.push(allEdges[i]);
+                metaInputEdges.push(pickableEdges[i]);
                 metaInputToOrig.push(i);
             }
         }
         const metaSplit = EdgeOps.splitEdgesWithMapping(metaInputEdges);
-        // Untrimmed originals: use re-split result (clean, no ghost intersections)
         for (let i = 0; i < metaSplit.edges.length; i++) {
             const origIdx = metaInputToOrig[metaSplit.sourceIndex[i]];
             if (origHasTrim[origIdx]) {
@@ -105,7 +137,6 @@ export class Trim2D extends GeometrySceneObject {
             metaEdge.markAsMetaShape('trim');
             this.addShape(metaEdge);
         }
-        // Trimmed originals: use first-pass surviving split edges (preserve boundaries)
         for (let i = 0; i < splitEdges.length; i++) {
             if (splitEdgesToRemove.has(i)) {
                 continue;
@@ -123,8 +154,11 @@ export class Trim2D extends GeometrySceneObject {
     }
     createCopy(remap) {
         const copy = new Trim2D();
-        if (this._points.length > 0) {
-            copy.points(...this._points);
+        if (this._filters.length > 0) {
+            copy.setFilters(...this._filters);
+        }
+        if (this._picking) {
+            copy.pick(...this._pickPoints);
         }
         return copy;
     }
@@ -135,11 +169,22 @@ export class Trim2D extends GeometrySceneObject {
         if (!super.compareTo(other)) {
             return false;
         }
-        if (this._points.length !== other._points.length) {
+        if (this._filters.length !== other._filters.length) {
+            return false;
+        }
+        for (let i = 0; i < this._filters.length; i++) {
+            if (!this._filters[i].equals(other._filters[i])) {
+                return false;
+            }
+        }
+        if (this._picking !== other._picking) {
+            return false;
+        }
+        if (this._pickPoints.length !== other._pickPoints.length) {
             return false;
         }
-        for (let i = 0; i < this._points.length; i++) {
-            if (!this._points[i].compareTo(other._points[i])) {
+        for (let i = 0; i < this._pickPoints.length; i++) {
+            if (!this._pickPoints[i].compareTo(other._pickPoints[i])) {
                 return false;
             }
         }
@@ -149,6 +194,12 @@ export class Trim2D extends GeometrySceneObject {
         return "trim2d";
     }
     serialize() {
-        return {};
+        return {
+            trigger: 'trim-picking',
+            picking: this._picking || undefined,
+            pickPoints: this._picking
+                ? this._pickPoints.map(p => { const pt = p.asPoint2D(); return [pt.x, pt.y]; })
+                : undefined,
+        };
     }
 }

package/lib/dist/filters/edge/above-below.d.ts

@@ -0,0 +1,20 @@
+import { Matrix4 } from "../../math/matrix4.js";
+import { Edge } from "../../common/shapes.js";
+import { FilterBase } from "../filter-base.js";
+import { PlaneObjectBase } from "../../features/plane-renderable-base.js";
+export declare class AbovePlaneFilter extends FilterBase<Edge> {
+    private plane;
+    private partial;
+    constructor(plane: PlaneObjectBase, partial?: boolean);
+    match(shape: Edge): boolean;
+    compareTo(other: AbovePlaneFilter): boolean;
+    transform(matrix: Matrix4): AbovePlaneFilter;
+}
+export declare class BelowPlaneFilter extends FilterBase<Edge> {
+    private plane;
+    private partial;
+    constructor(plane: PlaneObjectBase, partial?: boolean);
+    match(shape: Edge): boolean;
+    compareTo(other: BelowPlaneFilter): boolean;
+    transform(matrix: Matrix4): BelowPlaneFilter;
+}

package/lib/dist/filters/edge/above-below.js

@@ -0,0 +1,57 @@
+import { FilterBase } from "../filter-base.js";
+import { EdgeOps } from "../../oc/edge-ops.js";
+import { PlaneObject } from "../../features/plane.js";
+export class AbovePlaneFilter extends FilterBase {
+    plane;
+    partial;
+    constructor(plane, partial = false) {
+        super();
+        this.plane = plane;
+        this.partial = partial;
+    }
+    match(shape) {
+        const plane = this.plane.getPlane();
+        const firstPoint = EdgeOps.getVertexPoint(EdgeOps.getFirstVertex(shape));
+        const lastPoint = EdgeOps.getVertexPoint(EdgeOps.getLastVertex(shape));
+        const firstAbove = plane.signedDistanceToPoint(firstPoint) > 0;
+        const lastAbove = plane.signedDistanceToPoint(lastPoint) > 0;
+        if (this.partial) {
+            return firstAbove || lastAbove;
+        }
+        return firstAbove && lastAbove;
+    }
+    compareTo(other) {
+        return this.plane.compareTo(other.plane) && this.partial === other.partial;
+    }
+    transform(matrix) {
+        const transformedPlane = this.plane.getPlane().applyMatrix(matrix);
+        return new AbovePlaneFilter(new PlaneObject(transformedPlane), this.partial);
+    }
+}
+export class BelowPlaneFilter extends FilterBase {
+    plane;
+    partial;
+    constructor(plane, partial = false) {
+        super();
+        this.plane = plane;
+        this.partial = partial;
+    }
+    match(shape) {
+        const plane = this.plane.getPlane();
+        const firstPoint = EdgeOps.getVertexPoint(EdgeOps.getFirstVertex(shape));
+        const lastPoint = EdgeOps.getVertexPoint(EdgeOps.getLastVertex(shape));
+        const firstBelow = plane.signedDistanceToPoint(firstPoint) < 0;
+        const lastBelow = plane.signedDistanceToPoint(lastPoint) < 0;
+        if (this.partial) {
+            return firstBelow || lastBelow;
+        }
+        return firstBelow && lastBelow;
+    }
+    compareTo(other) {
+        return this.plane.compareTo(other.plane) && this.partial === other.partial;
+    }
+    transform(matrix) {
+        const transformedPlane = this.plane.getPlane().applyMatrix(matrix);
+        return new BelowPlaneFilter(new PlaneObject(transformedPlane), this.partial);
+    }
+}

package/lib/dist/filters/edge/edge-filter.d.ts

@@ -8,17 +8,23 @@ export declare class EdgeFilterBuilder extends FilterBuilderBase<Edge> {
     /**
      * Selects edges that lie on the given plane.
      * @param plane - The reference plane.
-     * @param offset - Optional distance to offset the plane before matching.
-     * @param bothDirections - When true, also matches the plane offset in the opposite direction.
+     * @param offsetOrOptions - Offset distance, or an options object with `offset`, `bothDirections`, and `partial`.
      */
-    onPlane(plane: PlaneLike | PlaneObjectBase, offset?: number, bothDirections?: boolean): this;
+    onPlane(plane: PlaneLike | PlaneObjectBase, offsetOrOptions?: number | {
+        offset?: number;
+        bothDirections?: boolean;
+        partial?: boolean;
+    }): this;
     /**
      * Excludes edges that lie on the given plane.
      * @param plane - The reference plane.
-     * @param offset - Optional distance to offset the plane before matching.
-     * @param bothDirections - When true, also excludes the plane offset in the opposite direction.
+     * @param offsetOrOptions - Offset distance, or an options object with `offset`, `bothDirections`, and `partial`.
      */
-    notOnPlane(plane: PlaneLike | PlaneObjectBase, offset?: number, bothDirections?: boolean): this;
+    notOnPlane(plane: PlaneLike | PlaneObjectBase, offsetOrOptions?: number | {
+        offset?: number;
+        bothDirections?: boolean;
+        partial?: boolean;
+    }): this;
     /**
      * Selects edges that are parallel to the given plane.
      * @param plane - The reference plane.
@@ -89,5 +95,33 @@ export declare class EdgeFilterBuilder extends FilterBuilderBase<Edge> {
      * @param faceFilters - One or more face filter builders to match against.
      */
     notBelongsToFace(...faceFilters: FilterBuilderBase<Face>[]): this;
+    /**
+     * Selects edges that geometrically intersect with edges of the given scene object.
+     * @param sceneObject - A scene object whose edges are tested for intersection.
+     */
+    intersectsWith(sceneObject: ISceneObject): this;
+    /**
+     * Excludes edges that geometrically intersect with edges of the given scene object.
+     * @param sceneObject - A scene object whose edges are tested for intersection.
+     */
+    notIntersectsWith(sceneObject: ISceneObject): this;
+    /**
+     * Selects edges that are entirely above the given plane (in the direction of its normal).
+     * @param plane - The reference plane.
+     * @param offsetOrOptions - Offset distance, or an options object with `offset` and `partial`.
+     */
+    above(plane: PlaneLike | PlaneObjectBase, offsetOrOptions?: number | {
+        offset?: number;
+        partial?: boolean;
+    }): this;
+    /**
+     * Selects edges that are entirely below the given plane (opposite to its normal direction).
+     * @param plane - The reference plane.
+     * @param offsetOrOptions - Offset distance, or an options object with `offset` and `partial`.
+     */
+    below(plane: PlaneLike | PlaneObjectBase, offsetOrOptions?: number | {
+        offset?: number;
+        partial?: boolean;
+    }): this;
     static build(): EdgeFilterBuilder;
 }

package/lib/dist/filters/edge/edge-filter.js

@@ -11,6 +11,8 @@ import { PlaneObjectBase } from "../../features/plane-renderable-base.js";
 import { AtIndexFilter, NotAtIndexFilter } from "./at-index.js";
 import { BelongsToFaceFilter, NotBelongsToFaceFilter } from "./belongs-to-face.js";
 import { BelongsToFaceFromSceneObjectFilter, NotBelongsToFaceFromSceneObjectFilter } from "./belongs-to-object.js";
+import { IntersectsWithFilter, NotIntersectsWithFilter } from "./intersects-with.js";
+import { AbovePlaneFilter, BelowPlaneFilter } from "./above-below.js";
 import { SceneObject } from "../../common/scene-object.js";
 export class EdgeFilterBuilder extends FilterBuilderBase {
     constructor() {
@@ -43,13 +45,14 @@ export class EdgeFilterBuilder extends FilterBuilderBase {
     /**
      * Selects edges that lie on the given plane.
      * @param plane - The reference plane.
-     * @param offset - Optional distance to offset the plane before matching.
-     * @param bothDirections - When true, also matches the plane offset in the opposite direction.
+     * @param offsetOrOptions - Offset distance, or an options object with `offset`, `bothDirections`, and `partial`.
      */
-    onPlane(plane, offset = 0, bothDirections = false) {
+    onPlane(plane, offsetOrOptions) {
         if (!plane) {
             throw new Error('Plane is required');
         }
+        const opts = typeof offsetOrOptions === 'number' ? { offset: offsetOrOptions } : (offsetOrOptions ?? {});
+        const { offset = 0, bothDirections = false, partial = false } = opts;
         let planeObj;
         let planeObj2;
         if (plane instanceof PlaneObjectBase) {
@@ -67,20 +70,21 @@ export class EdgeFilterBuilder extends FilterBuilderBase {
                 planeObj = new PlaneObject(normalized);
             }
         }
-        const filter = new OnPlaneFilter(planeObj, planeObj2);
+        const filter = new OnPlaneFilter(planeObj, planeObj2, partial);
         this.filters.push(filter);
         return this;
     }
     /**
      * Excludes edges that lie on the given plane.
      * @param plane - The reference plane.
-     * @param offset - Optional distance to offset the plane before matching.
-     * @param bothDirections - When true, also excludes the plane offset in the opposite direction.
+     * @param offsetOrOptions - Offset distance, or an options object with `offset`, `bothDirections`, and `partial`.
      */
-    notOnPlane(plane, offset = 0, bothDirections = false) {
+    notOnPlane(plane, offsetOrOptions) {
         if (!plane) {
             throw new Error('Plane is required');
         }
+        const opts = typeof offsetOrOptions === 'number' ? { offset: offsetOrOptions } : (offsetOrOptions ?? {});
+        const { offset = 0, bothDirections = false, partial = false } = opts;
         let planeObj;
         let planeObj2;
         if (plane instanceof PlaneObjectBase) {
@@ -98,7 +102,7 @@ export class EdgeFilterBuilder extends FilterBuilderBase {
                 planeObj = new PlaneObject(normalized);
             }
         }
-        const filter = new NotOnPlaneFilter(planeObj, planeObj2);
+        const filter = new NotOnPlaneFilter(planeObj, planeObj2, partial);
         this.filters.push(filter);
         return this;
     }
@@ -262,6 +266,70 @@ export class EdgeFilterBuilder extends FilterBuilderBase {
         }
         return this;
     }
+    /**
+     * Selects edges that geometrically intersect with edges of the given scene object.
+     * @param sceneObject - A scene object whose edges are tested for intersection.
+     */
+    intersectsWith(sceneObject) {
+        const filter = new IntersectsWithFilter(sceneObject);
+        this.filters.push(filter);
+        return this;
+    }
+    /**
+     * Excludes edges that geometrically intersect with edges of the given scene object.
+     * @param sceneObject - A scene object whose edges are tested for intersection.
+     */
+    notIntersectsWith(sceneObject) {
+        const filter = new NotIntersectsWithFilter(sceneObject);
+        this.filters.push(filter);
+        return this;
+    }
+    /**
+     * Selects edges that are entirely above the given plane (in the direction of its normal).
+     * @param plane - The reference plane.
+     * @param offsetOrOptions - Offset distance, or an options object with `offset` and `partial`.
+     */
+    above(plane, offsetOrOptions) {
+        if (!plane) {
+            throw new Error('Plane is required');
+        }
+        const opts = typeof offsetOrOptions === 'number' ? { offset: offsetOrOptions } : (offsetOrOptions ?? {});
+        const { offset = 0, partial = false } = opts;
+        let planeObj;
+        if (plane instanceof PlaneObjectBase) {
+            planeObj = plane;
+        }
+        else {
+            let normalized = normalizePlane(plane);
+            planeObj = offset ? new PlaneObject(normalized.offset(offset)) : new PlaneObject(normalized);
+        }
+        const filter = new AbovePlaneFilter(planeObj, partial);
+        this.filters.push(filter);
+        return this;
+    }
+    /**
+     * Selects edges that are entirely below the given plane (opposite to its normal direction).
+     * @param plane - The reference plane.
+     * @param offsetOrOptions - Offset distance, or an options object with `offset` and `partial`.
+     */
+    below(plane, offsetOrOptions) {
+        if (!plane) {
+            throw new Error('Plane is required');
+        }
+        const opts = typeof offsetOrOptions === 'number' ? { offset: offsetOrOptions } : (offsetOrOptions ?? {});
+        const { offset = 0, partial = false } = opts;
+        let planeObj;
+        if (plane instanceof PlaneObjectBase) {
+            planeObj = plane;
+        }
+        else {
+            let normalized = normalizePlane(plane);
+            planeObj = offset ? new PlaneObject(normalized.offset(offset)) : new PlaneObject(normalized);
+        }
+        const filter = new BelowPlaneFilter(planeObj, partial);
+        this.filters.push(filter);
+        return this;
+    }
     static build() {
         return new EdgeFilterBuilder();
     }

package/lib/dist/filters/edge/intersects-with.d.ts

@@ -0,0 +1,18 @@
+import { Matrix4 } from "../../math/matrix4.js";
+import { Edge } from "../../common/shapes.js";
+import { FilterBase } from "../filter-base.js";
+import { SceneObject } from "../../common/scene-object.js";
+export declare class IntersectsWithFilter extends FilterBase<Edge> {
+    private sceneObject;
+    constructor(sceneObject: SceneObject);
+    match(shape: Edge): boolean;
+    compareTo(other: IntersectsWithFilter): boolean;
+    transform(_matrix: Matrix4): IntersectsWithFilter;
+}
+export declare class NotIntersectsWithFilter extends FilterBase<Edge> {
+    private sceneObject;
+    constructor(sceneObject: SceneObject);
+    match(shape: Edge): boolean;
+    compareTo(other: NotIntersectsWithFilter): boolean;
+    transform(_matrix: Matrix4): NotIntersectsWithFilter;
+}

package/lib/dist/filters/edge/intersects-with.js

@@ -0,0 +1,38 @@
+import { FilterBase } from "../filter-base.js";
+import { EdgeQuery } from "../../oc/edge-query.js";
+export class IntersectsWithFilter extends FilterBase {
+    sceneObject;
+    constructor(sceneObject) {
+        super();
+        this.sceneObject = sceneObject;
+    }
+    match(shape) {
+        const objectEdges = this.sceneObject.getShapes({ excludeGuide: false })
+            .flatMap(s => s.getSubShapes("edge"));
+        return objectEdges.some(objEdge => EdgeQuery.doEdgesIntersect(shape, objEdge));
+    }
+    compareTo(other) {
+        return this.sceneObject.compareTo(other.sceneObject);
+    }
+    transform(_matrix) {
+        return new IntersectsWithFilter(this.sceneObject);
+    }
+}
+export class NotIntersectsWithFilter extends FilterBase {
+    sceneObject;
+    constructor(sceneObject) {
+        super();
+        this.sceneObject = sceneObject;
+    }
+    match(shape) {
+        const objectEdges = this.sceneObject.getShapes({ excludeGuide: false })
+            .flatMap(s => s.getSubShapes("edge"));
+        return !objectEdges.some(objEdge => EdgeQuery.doEdgesIntersect(shape, objEdge));
+    }
+    compareTo(other) {
+        return this.sceneObject.compareTo(other.sceneObject);
+    }
+    transform(_matrix) {
+        return new NotIntersectsWithFilter(this.sceneObject);
+    }
+}

package/lib/dist/filters/edge/on-plane.d.ts

@@ -5,7 +5,8 @@ import { PlaneObjectBase } from "../../features/plane-renderable-base.js";
 export declare class OnPlaneFilter extends FilterBase<Edge> {
     private plane;
     private plane2?;
-    constructor(plane: PlaneObjectBase, plane2?: PlaneObjectBase);
+    private partial;
+    constructor(plane: PlaneObjectBase, plane2?: PlaneObjectBase, partial?: boolean);
     match(shape: Edge): boolean;
     compareTo(other: OnPlaneFilter): boolean;
     transform(matrix: Matrix4): OnPlaneFilter;
@@ -13,7 +14,8 @@ export declare class OnPlaneFilter extends FilterBase<Edge> {
 export declare class NotOnPlaneFilter extends FilterBase<Edge> {
     private plane;
     private plane2?;
-    constructor(plane: PlaneObjectBase, plane2?: PlaneObjectBase);
+    private partial;
+    constructor(plane: PlaneObjectBase, plane2?: PlaneObjectBase, partial?: boolean);
     match(shape: Edge): boolean;
     compareTo(other: NotOnPlaneFilter): boolean;
     transform(matrix: Matrix4): NotOnPlaneFilter;

package/lib/dist/filters/edge/on-plane.js

@@ -1,16 +1,31 @@
 import { FilterBase } from "../filter-base.js";
 import { EdgeQuery } from "../../oc/edge-query.js";
+import { EdgeOps } from "../../oc/edge-ops.js";
 import { PlaneObject } from "../../features/plane.js";
 export class OnPlaneFilter extends FilterBase {
     plane;
     plane2;
-    constructor(plane, plane2) {
+    partial;
+    constructor(plane, plane2, partial = false) {
         super();
         this.plane = plane;
         this.plane2 = plane2;
+        this.partial = partial;
     }
     match(shape) {
         const plane = this.plane.getPlane();
+        if (this.partial) {
+            const firstPoint = EdgeOps.getVertexPoint(EdgeOps.getFirstVertex(shape));
+            const lastPoint = EdgeOps.getVertexPoint(EdgeOps.getLastVertex(shape));
+            if (plane.containsPoint(firstPoint) || plane.containsPoint(lastPoint)) {
+                return true;
+            }
+            if (this.plane2) {
+                const plane2 = this.plane2.getPlane();
+                return plane2.containsPoint(firstPoint) || plane2.containsPoint(lastPoint);
+            }
+            return false;
+        }
         if (EdgeQuery.isEdgeOnPlane(shape, plane)) {
             return true;
         }
@@ -20,7 +35,7 @@ export class OnPlaneFilter extends FilterBase {
         return false;
     }
     compareTo(other) {
-        if (!this.plane.compareTo(other.plane)) {
+        if (!this.plane.compareTo(other.plane) || this.partial !== other.partial) {
             return false;
         }
         if (this.plane2 && other.plane2) {
@@ -29,31 +44,42 @@ export class OnPlaneFilter extends FilterBase {
         return this.plane2 === other.plane2;
     }
     transform(matrix) {
-        const plane = this.plane.getPlane();
-        const transformedPlane = plane.applyMatrix(matrix);
-        console.log('Plane', plane.normal, 'Origin:', plane.origin, ' Transformed plane:', transformedPlane.normal, ' Origin:', transformedPlane.origin);
-        const planeObj = new PlaneObject(transformedPlane);
+        const transformedPlane = this.plane.getPlane().applyMatrix(matrix);
         const planeObj2 = this.plane2 ? new PlaneObject(this.plane2.getPlane().applyMatrix(matrix)) : undefined;
-        return new OnPlaneFilter(planeObj, planeObj2);
+        return new OnPlaneFilter(new PlaneObject(transformedPlane), planeObj2, this.partial);
     }
 }
 export class NotOnPlaneFilter extends FilterBase {
     plane;
     plane2;
-    constructor(plane, plane2) {
+    partial;
+    constructor(plane, plane2, partial = false) {
         super();
         this.plane = plane;
         this.plane2 = plane2;
+        this.partial = partial;
     }
     match(shape) {
         const plane = this.plane.getPlane();
+        if (this.partial) {
+            const firstPoint = EdgeOps.getVertexPoint(EdgeOps.getFirstVertex(shape));
+            const lastPoint = EdgeOps.getVertexPoint(EdgeOps.getLastVertex(shape));
+            if (plane.containsPoint(firstPoint) || plane.containsPoint(lastPoint)) {
+                return false;
+            }
+            if (this.plane2) {
+                const plane2 = this.plane2.getPlane();
+                return !plane2.containsPoint(firstPoint) && !plane2.containsPoint(lastPoint);
+            }
+            return true;
+        }
         if (this.plane2) {
             return !EdgeQuery.isEdgeOnPlane(shape, plane) && !EdgeQuery.isEdgeOnPlane(shape, this.plane2.getPlane());
         }
         return !EdgeQuery.isEdgeOnPlane(shape, plane);
     }
     compareTo(other) {
-        if (!this.plane.compareTo(other.plane)) {
+        if (!this.plane.compareTo(other.plane) || this.partial !== other.partial) {
             return false;
         }
         if (this.plane2 && other.plane2) {
@@ -62,9 +88,8 @@ export class NotOnPlaneFilter extends FilterBase {
         return this.plane2 === other.plane2;
     }
     transform(matrix) {
-        const plane = this.plane.getPlane();
-        const planeObj = new PlaneObject(plane.applyMatrix(matrix));
+        const transformedPlane = this.plane.getPlane().applyMatrix(matrix);
         const planeObj2 = this.plane2 ? new PlaneObject(this.plane2.getPlane().applyMatrix(matrix)) : undefined;
-        return new NotOnPlaneFilter(planeObj, planeObj2);
+        return new NotOnPlaneFilter(new PlaneObject(transformedPlane), planeObj2, this.partial);
     }
 }

package/lib/dist/filters/filter-builder-base.d.ts

@@ -1,4 +1,3 @@
-import { Matrix4 } from "../math/matrix4.js";
 import { Shape } from "../common/shapes.js";
 import { FilterBase } from "./filter-base.js";
 export declare class FilterBuilderBase<TShape extends Shape = Shape> {
@@ -10,8 +9,4 @@ export declare class FilterBuilderBase<TShape extends Shape = Shape> {
      * by tangency (G1 continuity) to the initially matched shapes.
      */
     withTangents(): this;
-    hasTangentExpansion(): boolean;
-    getFilters(): FilterBase<TShape>[];
-    transform(matrix: Matrix4): FilterBuilderBase<TShape>;
-    equals(other: FilterBuilderBase<TShape>): boolean;
 }