fluidcad 0.0.33 → 0.0.35

package/lib/dist/features/2d/tarc-constrained.d.ts

@@ -1,4 +1,5 @@
 import { GeometrySceneObject } from "./geometry.js";
+import { SceneObject } from "../../common/scene-object.js";
 import { LazyVertex } from "../lazy-vertex.js";
 import { QualifiedSceneObject } from "./constraints/qualified-geometry.js";
 import { ITangentArcTwoObjects } from "../../core/interfaces.js";
@@ -11,6 +12,7 @@ export declare class TangentArcTwoObjects extends GeometrySceneObject implements
     build(): void;
     start(index?: number): LazyVertex;
     end(index?: number): LazyVertex;
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
     compareTo(other: TangentArcTwoObjects): boolean;
     getType(): string;
     getUniqueType(): string;

package/lib/dist/features/2d/tarc-constrained.js

@@ -1,6 +1,7 @@
 import { GeometrySceneObject } from "./geometry.js";
 import { LazyVertex } from "../lazy-vertex.js";
 import { Vertex } from "../../common/vertex.js";
+import { QualifiedSceneObject } from "./constraints/qualified-geometry.js";
 import { createConstraintSolver } from "../../oc/constraints/create-solver.js";
 export class TangentArcTwoObjects extends GeometrySceneObject {
     c1;
@@ -41,6 +42,13 @@ export class TangentArcTwoObjects extends GeometrySceneObject {
     end(index = 0) {
         return new LazyVertex(this.generateUniqueName(`end-vertex-${index}`), () => [this.getState('end')]);
     }
+    createCopy(remap) {
+        const remappedC1Object = remap.get(this.c1.object) || this.c1.object;
+        const remappedC2Object = remap.get(this.c2.object) || this.c2.object;
+        const c1 = new QualifiedSceneObject(remappedC1Object, this.c1.qualifier);
+        const c2 = new QualifiedSceneObject(remappedC2Object, this.c2.qualifier);
+        return new TangentArcTwoObjects(c1, c2, this.radius, this.mustTouch);
+    }
     compareTo(other) {
         if (!(other instanceof TangentArcTwoObjects)) {
             return false;

package/lib/dist/features/2d/tarc-radius-to-object.d.ts

@@ -0,0 +1,16 @@
+import { GeometrySceneObject } from "./geometry.js";
+import { SceneObject } from "../../common/scene-object.js";
+import { QualifiedSceneObject } from "./constraints/qualified-geometry.js";
+export declare class TangentArcRadiusToObject extends GeometrySceneObject {
+    radius: number;
+    target: QualifiedSceneObject;
+    constructor(radius: number, target: QualifiedSceneObject);
+    build(): void;
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
+    compareTo(other: TangentArcRadiusToObject): boolean;
+    getType(): string;
+    getUniqueType(): string;
+    serialize(): {
+        radius: number;
+    };
+}

package/lib/dist/features/2d/tarc-radius-to-object.js

@@ -0,0 +1,58 @@
+import { GeometrySceneObject } from "./geometry.js";
+import { Vertex } from "../../common/vertex.js";
+import { QualifiedSceneObject } from "./constraints/qualified-geometry.js";
+import { solveTangentArcRadiusToObject } from "../../oc/constraints/geometric/tangent-arc-radius-to-object.js";
+export class TangentArcRadiusToObject extends GeometrySceneObject {
+    radius;
+    target;
+    constructor(radius, target) {
+        super();
+        this.radius = radius;
+        this.target = target;
+    }
+    build() {
+        const plane = this.sketch.getPlane();
+        const startPoint = this.getCurrentPosition();
+        const startTangent = this.sketch.getTangentAt(this);
+        const targetShape = this.target.toQualifiedShape();
+        const result = solveTangentArcRadiusToObject(plane, startPoint, startTangent, this.radius, targetShape);
+        for (let i = 0; i < result.edges.length; i++) {
+            this.setState(`edge-${i}`, result.edges[i]);
+        }
+        if (result.edges.length > 0) {
+            const lastEdge = result.edges[result.edges.length - 1];
+            const localStart = plane.worldToLocal(lastEdge.getFirstVertex().toPoint());
+            const localEnd = plane.worldToLocal(lastEdge.getLastVertex().toPoint());
+            this.setState('start', Vertex.fromPoint2D(localStart));
+            this.setState('end', Vertex.fromPoint2D(localEnd));
+            if (result.endTangent) {
+                this.setTangent(result.endTangent);
+            }
+            this.setCurrentPosition(localEnd);
+        }
+        this.addShapes(result.edges);
+    }
+    createCopy(remap) {
+        const remappedObject = remap.get(this.target.object) || this.target.object;
+        const target = new QualifiedSceneObject(remappedObject, this.target.qualifier);
+        return new TangentArcRadiusToObject(this.radius, target);
+    }
+    compareTo(other) {
+        if (!(other instanceof TangentArcRadiusToObject)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        return this.radius === other.radius && this.target.compareTo(other.target);
+    }
+    getType() {
+        return 'tarc';
+    }
+    getUniqueType() {
+        return 'tarc-radius-to-object';
+    }
+    serialize() {
+        return { radius: this.radius };
+    }
+}

package/lib/dist/features/2d/tarc-to-object.d.ts

@@ -0,0 +1,18 @@
+import { GeometrySceneObject } from "./geometry.js";
+import { SceneObject } from "../../common/scene-object.js";
+import { QualifiedSceneObject } from "./constraints/qualified-geometry.js";
+import { ITangentArcToObject } from "../../core/interfaces.js";
+export declare class TangentArcToObject extends GeometrySceneObject implements ITangentArcToObject {
+    target: QualifiedSceneObject;
+    private flipped;
+    constructor(target: QualifiedSceneObject);
+    flip(): this;
+    build(): void;
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
+    compareTo(other: TangentArcToObject): boolean;
+    getType(): string;
+    getUniqueType(): string;
+    serialize(): {
+        flipped: boolean;
+    };
+}

package/lib/dist/features/2d/tarc-to-object.js

@@ -0,0 +1,66 @@
+import { GeometrySceneObject } from "./geometry.js";
+import { Vertex } from "../../common/vertex.js";
+import { QualifiedSceneObject } from "./constraints/qualified-geometry.js";
+import { createConstraintSolver } from "../../oc/constraints/create-solver.js";
+export class TangentArcToObject extends GeometrySceneObject {
+    target;
+    flipped = false;
+    constructor(target) {
+        super();
+        this.target = target;
+    }
+    flip() {
+        this.flipped = true;
+        return this;
+    }
+    build() {
+        const plane = this.sketch.getPlane();
+        const startPoint = this.getCurrentPosition();
+        const startTangent = this.sketch.getTangentAt(this);
+        const targetShape = this.target.toQualifiedShape();
+        const solver = createConstraintSolver(false);
+        const result = solver.getTangentArcFromPointTangent(plane, startPoint, startTangent, targetShape, this.flipped);
+        for (let i = 0; i < result.edges.length; i++) {
+            this.setState(`edge-${i}`, result.edges[i]);
+        }
+        if (result.edges.length > 0) {
+            const lastEdge = result.edges[result.edges.length - 1];
+            const localStart = plane.worldToLocal(lastEdge.getFirstVertex().toPoint());
+            const localEnd = plane.worldToLocal(lastEdge.getLastVertex().toPoint());
+            this.setState('start', Vertex.fromPoint2D(localStart));
+            this.setState('end', Vertex.fromPoint2D(localEnd));
+            if (result.endTangent) {
+                this.setTangent(result.endTangent);
+            }
+            this.setCurrentPosition(localEnd);
+        }
+        this.addShapes(result.edges);
+    }
+    createCopy(remap) {
+        const remappedObject = remap.get(this.target.object) || this.target.object;
+        const target = new QualifiedSceneObject(remappedObject, this.target.qualifier);
+        const copy = new TangentArcToObject(target);
+        if (this.flipped) {
+            copy.flip();
+        }
+        return copy;
+    }
+    compareTo(other) {
+        if (!(other instanceof TangentArcToObject)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        return this.target.compareTo(other.target) && this.flipped === other.flipped;
+    }
+    getType() {
+        return 'tarc';
+    }
+    getUniqueType() {
+        return 'tarc-to-object';
+    }
+    serialize() {
+        return { flipped: this.flipped };
+    }
+}

package/lib/dist/features/2d/tarc-to-point-tangent.d.ts

@@ -1,3 +1,4 @@
+import { SceneObject } from "../../common/scene-object.js";
 import { GeometrySceneObject } from "./geometry.js";
 import { LazyVertex } from "../lazy-vertex.js";
 export declare class TangentArcToPointTangent extends GeometrySceneObject {
@@ -5,6 +6,7 @@ export declare class TangentArcToPointTangent extends GeometrySceneObject {
     startTangent: LazyVertex;
     constructor(endPoint: LazyVertex, startTangent: LazyVertex);
     build(): void;
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
     compareTo(other: TangentArcToPointTangent): boolean;
     getType(): string;
     getUniqueType(): string;

package/lib/dist/features/2d/tarc-to-point-tangent.js

@@ -60,8 +60,14 @@ export class TangentArcToPointTangent extends GeometrySceneObject {
         this.setState('start', Vertex.fromPoint2D(startPoint));
         this.setState('end', Vertex.fromPoint2D(targetPoint));
         this.addShape(edge);
+        const centerVertex = Vertex.fromPoint2D(centerPoint);
+        centerVertex.markAsMetaShape();
+        this.addShape(centerVertex);
         this.setCurrentPosition(targetPoint);
     }
+    createCopy(remap) {
+        return new TangentArcToPointTangent(this.endPoint, this.startTangent);
+    }
     compareTo(other) {
         if (!(other instanceof TangentArcToPointTangent)) {
             return false;

package/lib/dist/features/2d/tarc-to-point.d.ts

@@ -1,9 +1,11 @@
+import { SceneObject } from "../../common/scene-object.js";
 import { GeometrySceneObject } from "./geometry.js";
 import { LazyVertex } from "../lazy-vertex.js";
 export declare class TangentArcToPoint extends GeometrySceneObject {
     endPoint: LazyVertex;
     constructor(endPoint: LazyVertex);
     build(): void;
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
     compareTo(other: TangentArcToPoint): boolean;
     getType(): string;
     getUniqueType(): string;

package/lib/dist/features/2d/tarc-to-point.js

@@ -58,8 +58,14 @@ export class TangentArcToPoint extends GeometrySceneObject {
         this.setState('start', Vertex.fromPoint2D(startPoint));
         this.setState('end', Vertex.fromPoint2D(targetPoint));
         this.addShape(edge);
+        const centerVertex = Vertex.fromPoint2D(centerPoint);
+        centerVertex.markAsMetaShape();
+        this.addShape(centerVertex);
         this.setCurrentPosition(targetPoint);
     }
+    createCopy(remap) {
+        return new TangentArcToPoint(this.endPoint);
+    }
     compareTo(other) {
         if (!(other instanceof TangentArcToPoint)) {
             return false;

package/lib/dist/features/2d/tarc-with-tangent.d.ts

@@ -1,3 +1,4 @@
+import { SceneObject } from "../../common/scene-object.js";
 import { LazyVertex } from "../lazy-vertex.js";
 import { GeometrySceneObject } from "./geometry.js";
 export declare class TangentArcWithTangent extends GeometrySceneObject {
@@ -6,6 +7,7 @@ export declare class TangentArcWithTangent extends GeometrySceneObject {
     startTangent: LazyVertex;
     constructor(radius: number, endAngle: number, startTangent: LazyVertex);
     build(): void;
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
     compareTo(other: TangentArcWithTangent): boolean;
     getType(): string;
     getUniqueType(): string;

package/lib/dist/features/2d/tarc-with-tangent.js

@@ -44,8 +44,14 @@ export class TangentArcWithTangent extends GeometrySceneObject {
         const ty = sign * Math.cos(endAngleRad);
         this.setTangent(new Point2D(tx, ty));
         this.addShape(edge);
+        const centerVertex = Vertex.fromPoint2D(centerPoint);
+        centerVertex.markAsMetaShape();
+        this.addShape(centerVertex);
         this.setCurrentPosition(endPoint);
     }
+    createCopy(remap) {
+        return new TangentArcWithTangent(this.radius, this.endAngle, this.startTangent);
+    }
     compareTo(other) {
         if (!(other instanceof TangentArcWithTangent)) {
             return false;

package/lib/dist/features/2d/tarc.d.ts

@@ -1,9 +1,11 @@
+import { SceneObject } from "../../common/scene-object.js";
 import { GeometrySceneObject } from "./geometry.js";
 export declare class TangentArc extends GeometrySceneObject {
     radius: number;
     endAngle: number;
     constructor(radius: number, endAngle: number);
     build(): void;
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
     compareTo(other: TangentArc): boolean;
     getType(): string;
     serialize(): {

package/lib/dist/features/2d/tarc.js

@@ -46,8 +46,14 @@ export class TangentArc extends GeometrySceneObject {
         const ty = sign * Math.cos(endAngleRad);
         this.setTangent(new Point2D(tx, ty));
         this.addShape(edge);
+        const centerVertex = Vertex.fromPoint2D(centerPoint);
+        centerVertex.markAsMetaShape();
+        this.addShape(centerVertex);
         this.setCurrentPosition(endPoint);
     }
+    createCopy(remap) {
+        return new TangentArc(this.radius, this.endAngle);
+    }
     compareTo(other) {
         if (!(other instanceof TangentArc)) {
             return false;

package/lib/dist/features/2d/vline.d.ts

@@ -6,8 +6,10 @@ export declare class VerticalLine extends GeometrySceneObject implements IVLine
     distanceOrTarget: number | SceneObject;
     private targetPlane;
     private _centered;
+    private _hasExplicitStart;
     constructor(distanceOrTarget: number | SceneObject, targetPlane?: PlaneObjectBase);
     centered(value?: boolean): this;
+    setHasExplicitStart(value?: boolean): this;
     build(): void;
     getDependencies(): SceneObject[];
     createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
@@ -17,5 +19,6 @@ export declare class VerticalLine extends GeometrySceneObject implements IVLine
     serialize(): {
         distance: number;
         centered: boolean;
+        hasExplicitStart: boolean;
     };
 }

package/lib/dist/features/2d/vline.js

@@ -8,6 +8,7 @@ export class VerticalLine extends GeometrySceneObject {
     distanceOrTarget;
     targetPlane;
     _centered = false;
+    _hasExplicitStart = false;
     constructor(distanceOrTarget, targetPlane = null) {
         super();
         this.distanceOrTarget = distanceOrTarget;
@@ -17,6 +18,10 @@ export class VerticalLine extends GeometrySceneObject {
         this._centered = value;
         return this;
     }
+    setHasExplicitStart(value = true) {
+        this._hasExplicitStart = value;
+        return this;
+    }
     build() {
         const plane = this.targetPlane?.getPlane() || this.sketch.getPlane();
         const currentPos = this.targetPlane
@@ -78,6 +83,7 @@ export class VerticalLine extends GeometrySceneObject {
             : this.distanceOrTarget;
         const copy = new VerticalLine(distanceOrTarget, targetPlane);
         copy.centered(this._centered);
+        copy._hasExplicitStart = this._hasExplicitStart;
         return copy;
     }
     compareTo(other) {
@@ -104,7 +110,7 @@ export class VerticalLine extends GeometrySceneObject {
         else if (this.distanceOrTarget !== other.distanceOrTarget) {
             return false;
         }
-        return this._centered === other._centered;
+        return this._centered === other._centered && this._hasExplicitStart === other._hasExplicitStart;
     }
     getType() {
         return 'line';
@@ -115,7 +121,8 @@ export class VerticalLine extends GeometrySceneObject {
     serialize() {
         return {
             distance: typeof this.distanceOrTarget === 'number' ? this.distanceOrTarget : null,
-            centered: this._centered
+            centered: this._centered,
+            hasExplicitStart: this._hasExplicitStart,
         };
     }
 }

package/lib/dist/features/copy-circular.d.ts

@@ -1,14 +1,15 @@
 import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
 import { Axis } from "../math/axis.js";
+import { type NumberParam } from "../core/param.js";
 export type CircularCopyOptions = {
-    count: number;
+    count: NumberParam;
     centered?: boolean;
     skip?: number[];
 } & ({
-    offset: number;
+    offset: NumberParam;
     angle?: never;
 } | {
-    angle: number;
+    angle: NumberParam;
     offset?: never;
 });
 export declare class CopyCircular extends SceneObject {

package/lib/dist/features/copy-circular.js

@@ -2,6 +2,7 @@ import { SceneObject } from "../common/scene-object.js";
 import { Matrix4 } from "../math/matrix4.js";
 import { rad } from "../helpers/math-helpers.js";
 import { ShapeOps } from "../oc/shape-ops.js";
+import { resolveParam } from "../core/param.js";
 export class CopyCircular extends SceneObject {
     axis;
     options;
@@ -17,13 +18,21 @@ export class CopyCircular extends SceneObject {
         if (!this.targetObjects) {
             objects = context.getActiveSceneObjects();
         }
-        const { count, centered, skip } = this.options;
+        const originalShapes = objects.flatMap(obj => obj.getShapes());
+        for (const obj of objects) {
+            obj.removeShapes(this);
+        }
+        for (const shape of originalShapes) {
+            this.addShape(shape);
+        }
+        const count = resolveParam(this.options.count);
+        const { centered, skip } = this.options;
         let offset;
         if ('offset' in this.options && this.options.offset !== undefined) {
-            offset = this.options.offset;
+            offset = resolveParam(this.options.offset);
         }
         else {
-            offset = this.options.angle / count;
+            offset = resolveParam(this.options.angle) / count;
         }
         const startOffset = centered ? -(count * offset) / 2 : 0;
         for (let i = 1; i < count; i++) {
@@ -31,12 +40,10 @@ export class CopyCircular extends SceneObject {
                 continue;
             const angle = startOffset + offset * i;
             const matrix = Matrix4.fromRotationAroundAxis(this.axis.origin, this.axis.direction, rad(angle));
-            for (const obj of objects) {
-                for (const shape of obj.getShapes()) {
-                    const transformed = ShapeOps.transform(shape, matrix);
-                    transformed.setMeshSource(shape, matrix);
-                    this.addShape(transformed);
-                }
+            for (const shape of originalShapes) {
+                const transformed = ShapeOps.transform(shape, matrix);
+                transformed.setMeshSource(shape, matrix);
+                this.addShape(transformed);
             }
         }
     }

package/lib/dist/features/copy-circular2d.js

@@ -2,6 +2,7 @@ import { Matrix4 } from "../math/matrix4.js";
 import { rad } from "../helpers/math-helpers.js";
 import { ShapeOps } from "../oc/shape-ops.js";
 import { GeometrySceneObject } from "./2d/geometry.js";
+import { resolveParam } from "../core/param.js";
 export class CopyCircular2D extends GeometrySceneObject {
     center;
     options;
@@ -21,16 +22,24 @@ export class CopyCircular2D extends GeometrySceneObject {
         else {
             objects = allSiblings;
         }
+        const originalShapes = objects.flatMap(obj => obj.getShapes());
+        for (const obj of objects) {
+            obj.removeShapes(this);
+        }
+        for (const shape of originalShapes) {
+            this.addShape(shape);
+        }
         const plane = this.sketch.getPlane();
         const origin = plane.localToWorld(this.center.asPoint2D());
         const direction = plane.normal;
-        const { count, centered, skip } = this.options;
+        const count = resolveParam(this.options.count);
+        const { centered, skip } = this.options;
         let offset;
         if ('offset' in this.options && this.options.offset !== undefined) {
-            offset = this.options.offset;
+            offset = resolveParam(this.options.offset);
         }
         else {
-            offset = this.options.angle / count;
+            offset = resolveParam(this.options.angle) / count;
         }
         const startOffset = centered ? -(count * offset) / 2 : 0;
         for (let i = 1; i < count; i++) {
@@ -38,12 +47,10 @@ export class CopyCircular2D extends GeometrySceneObject {
                 continue;
             const angle = startOffset + offset * i;
             const matrix = Matrix4.fromRotationAroundAxis(origin, direction, rad(angle));
-            for (const obj of objects) {
-                for (const shape of obj.getShapes()) {
-                    const transformed = ShapeOps.transform(shape, matrix);
-                    transformed.setMeshSource(shape, matrix);
-                    this.addShape(transformed);
-                }
+            for (const shape of originalShapes) {
+                const transformed = ShapeOps.transform(shape, matrix);
+                transformed.setMeshSource(shape, matrix);
+                this.addShape(transformed);
             }
         }
         this.setCurrentPosition(this.center.asPoint2D());

package/lib/dist/features/copy-linear.d.ts

@@ -1,14 +1,15 @@
 import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
 import { Axis } from "../math/axis.js";
+import { type NumberParam } from "../core/param.js";
 export type LinearCopyOptions = {
-    count: number | number[];
+    count: NumberParam | number[];
     centered?: boolean;
     skip?: number[][];
 } & ({
-    offset: number | number[];
+    offset: NumberParam | number[];
     length?: never;
 } | {
-    length: number | number[];
+    length: NumberParam | number[];
     offset?: never;
 });
 export declare class CopyLinear extends SceneObject {

package/lib/dist/features/copy-linear.js

@@ -1,6 +1,7 @@
 import { SceneObject } from "../common/scene-object.js";
 import { Matrix4 } from "../math/matrix4.js";
 import { ShapeOps } from "../oc/shape-ops.js";
+import { resolveParam } from "../core/param.js";
 export class CopyLinear extends SceneObject {
     axes;
     options;
@@ -16,15 +17,22 @@ export class CopyLinear extends SceneObject {
         if (!this.targetObjects) {
             objects = context.getActiveSceneObjects();
         }
-        const { count, centered, skip } = this.options;
-        const counts = Array.isArray(count)
-            ? count
-            : this.axes.map(() => count);
+        const originalShapes = objects.flatMap(obj => obj.getShapes());
+        for (const obj of objects) {
+            obj.removeShapes(this);
+        }
+        for (const shape of originalShapes) {
+            this.addShape(shape);
+        }
+        const { centered, skip } = this.options;
+        const counts = Array.isArray(this.options.count)
+            ? this.options.count
+            : this.axes.map(() => resolveParam(this.options.count));
         const offsets = 'offset' in this.options && this.options.offset !== undefined
-            ? (Array.isArray(this.options.offset) ? this.options.offset : this.axes.map(() => this.options.offset))
+            ? (Array.isArray(this.options.offset) ? this.options.offset : this.axes.map(() => resolveParam(this.options.offset)))
             : null;
         const lengths = 'length' in this.options && this.options.length !== undefined
-            ? (Array.isArray(this.options.length) ? this.options.length : this.axes.map(() => this.options.length))
+            ? (Array.isArray(this.options.length) ? this.options.length : this.axes.map(() => resolveParam(this.options.length)))
             : null;
         const axisOffsets = this.axes.map((_, a) => {
             if (offsets) {
@@ -58,12 +66,10 @@ export class CopyLinear extends SceneObject {
                 const translation = this.axes[a].direction.multiply(distance);
                 matrix = matrix.multiply(Matrix4.fromTranslationVector(translation));
             }
-            for (const obj of objects) {
-                for (const shape of obj.getShapes()) {
-                    const transformed = ShapeOps.transform(shape, matrix);
-                    transformed.setMeshSource(shape, matrix);
-                    this.addShape(transformed);
-                }
+            for (const shape of originalShapes) {
+                const transformed = ShapeOps.transform(shape, matrix);
+                transformed.setMeshSource(shape, matrix);
+                this.addShape(transformed);
             }
         }
     }

package/lib/dist/features/copy-linear2d.js

@@ -2,6 +2,7 @@ import { Matrix4 } from "../math/matrix4.js";
 import { ShapeOps } from "../oc/shape-ops.js";
 import { GeometrySceneObject } from "./2d/geometry.js";
 import { AxisObjectBase } from "./axis-renderable-base.js";
+import { resolveParam } from "../core/param.js";
 export class CopyLinear2D extends GeometrySceneObject {
     axes;
     options;
@@ -21,16 +22,23 @@ export class CopyLinear2D extends GeometrySceneObject {
         else {
             objects = allSiblings;
         }
+        const originalShapes = objects.flatMap(obj => obj.getShapes());
+        for (const obj of objects) {
+            obj.removeShapes(this);
+        }
+        for (const shape of originalShapes) {
+            this.addShape(shape);
+        }
         const resolvedAxes = this.axes.map(a => a instanceof AxisObjectBase ? a.getAxis() : a);
-        const { count, centered, skip } = this.options;
-        const counts = Array.isArray(count)
-            ? count
-            : resolvedAxes.map(() => count);
+        const { centered, skip } = this.options;
+        const counts = Array.isArray(this.options.count)
+            ? this.options.count
+            : resolvedAxes.map(() => resolveParam(this.options.count));
         const offsets = 'offset' in this.options && this.options.offset !== undefined
-            ? (Array.isArray(this.options.offset) ? this.options.offset : resolvedAxes.map(() => this.options.offset))
+            ? (Array.isArray(this.options.offset) ? this.options.offset : resolvedAxes.map(() => resolveParam(this.options.offset)))
             : null;
         const lengths = 'length' in this.options && this.options.length !== undefined
-            ? (Array.isArray(this.options.length) ? this.options.length : resolvedAxes.map(() => this.options.length))
+            ? (Array.isArray(this.options.length) ? this.options.length : resolvedAxes.map(() => resolveParam(this.options.length)))
             : null;
         const axisOffsets = resolvedAxes.map((_, a) => {
             if (offsets) {
@@ -64,12 +72,10 @@ export class CopyLinear2D extends GeometrySceneObject {
                 const translation = resolvedAxes[a].direction.multiply(distance);
                 matrix = matrix.multiply(Matrix4.fromTranslationVector(translation));
             }
-            for (const obj of objects) {
-                for (const shape of obj.getShapes()) {
-                    const transformed = ShapeOps.transform(shape, matrix);
-                    transformed.setMeshSource(shape, matrix);
-                    this.addShape(transformed);
-                }
+            for (const shape of originalShapes) {
+                const transformed = ShapeOps.transform(shape, matrix);
+                transformed.setMeshSource(shape, matrix);
+                this.addShape(transformed);
             }
         }
     }