@cornerstonejs/tools 2.0.0-beta.3 → 2.0.0-beta.30

package/dist/esm/tools/annotation/planarFreehandROITool/renderMethods.js

@@ -1,6 +1,7 @@
-import { drawHandles as drawHandlesSvg, drawPolyline as drawPolylineSvg, } from '../../../drawingSvg';
+import { drawHandles as drawHandlesSvg, drawPolyline as drawPolylineSvg, drawPath as drawPathSvg, } from '../../../drawingSvg';
 import { polyline } from '../../../utilities/math';
 import { findOpenUShapedContourVectorToPeakOnRender } from './findOpenUShapedContourVectorToPeak';
+import getContourHolesDataCanvas from '../../../utilities/contours/getContourHolesDataCanvas';
 const { pointsAreWithinCloseContourProximity } = polyline;
 function _getRenderingOptions(enabledElement, annotation) {
     const styleSpecifier = {
@@ -9,15 +10,18 @@ function _getRenderingOptions(enabledElement, annotation) {
         viewportId: enabledElement.viewport.id,
         annotationUID: annotation.annotationUID,
     };
-    const lineWidth = this.getStyle('lineWidth', styleSpecifier, annotation);
-    const lineDash = this.getStyle('lineDash', styleSpecifier, annotation);
-    const color = this.getStyle('color', styleSpecifier, annotation);
-    const isOpenContour = annotation.data.isOpenContour;
+    const { lineWidth, lineDash, color, fillColor, fillOpacity } = this.getAnnotationStyle({
+        annotation,
+        styleSpecifier,
+    });
+    const { closed: isClosedContour } = annotation.data.contour;
     const options = {
-        color: color === undefined ? undefined : color,
-        width: lineWidth === undefined ? undefined : lineWidth,
-        lineDash: lineDash === undefined ? undefined : lineDash,
-        connectLastToFirst: !isOpenContour,
+        color,
+        width: lineWidth,
+        lineDash,
+        fillColor,
+        fillOpacity,
+        closePath: isClosedContour,
     };
     return options;
 }
@@ -25,7 +29,10 @@ function renderContour(enabledElement, svgDrawingHelper, annotation) {
     if (!enabledElement?.viewport?.getImageData()) {
         return;
     }
-    if (annotation.data.isOpenContour) {
+    if (annotation.data.contour.closed) {
+        this.renderClosedContour(enabledElement, svgDrawingHelper, annotation);
+    }
+    else {
         if (annotation.data.isOpenUShapeContour) {
             calculateUShapeContourVectorToPeakIfNotPresent(enabledElement, annotation);
             this.renderOpenUShapedContour(enabledElement, svgDrawingHelper, annotation);
@@ -34,9 +41,6 @@ function renderContour(enabledElement, svgDrawingHelper, annotation) {
             this.renderOpenContour(enabledElement, svgDrawingHelper, annotation);
         }
     }
-    else {
-        this.renderClosedContour(enabledElement, svgDrawingHelper, annotation);
-    }
 }
 function calculateUShapeContourVectorToPeakIfNotPresent(enabledElement, annotation) {
     if (!annotation.data.openUShapeContourVectorToPeak) {
@@ -45,16 +49,21 @@ function calculateUShapeContourVectorToPeakIfNotPresent(enabledElement, annotati
     }
 }
 function renderClosedContour(enabledElement, svgDrawingHelper, annotation) {
+    if (annotation.parentAnnotationUID) {
+        return;
+    }
     const { viewport } = enabledElement;
     const options = this._getRenderingOptions(enabledElement, annotation);
-    const canvasPoints = annotation.data.polyline.map((worldPos) => viewport.worldToCanvas(worldPos));
+    const canvasPolyline = annotation.data.contour.polyline.map((worldPos) => viewport.worldToCanvas(worldPos));
+    const childContours = getContourHolesDataCanvas(annotation, viewport);
+    const allContours = [canvasPolyline, ...childContours];
     const polylineUID = '1';
-    drawPolylineSvg(svgDrawingHelper, annotation.annotationUID, polylineUID, canvasPoints, options);
+    drawPathSvg(svgDrawingHelper, annotation.annotationUID, polylineUID, allContours, options);
 }
 function renderOpenContour(enabledElement, svgDrawingHelper, annotation) {
     const { viewport } = enabledElement;
     const options = this._getRenderingOptions(enabledElement, annotation);
-    const canvasPoints = annotation.data.polyline.map((worldPos) => viewport.worldToCanvas(worldPos));
+    const canvasPoints = annotation.data.contour.polyline.map((worldPos) => viewport.worldToCanvas(worldPos));
     const polylineUID = '1';
     drawPolylineSvg(svgDrawingHelper, annotation.annotationUID, polylineUID, canvasPoints, options);
     const activeHandleIndex = annotation.data.handles.activeHandleIndex;
@@ -85,7 +94,8 @@ function renderOpenContour(enabledElement, svgDrawingHelper, annotation) {
 }
 function renderOpenUShapedContour(enabledElement, svgDrawingHelper, annotation) {
     const { viewport } = enabledElement;
-    const { polyline, openUShapeContourVectorToPeak } = annotation.data;
+    const { openUShapeContourVectorToPeak } = annotation.data;
+    const { polyline } = annotation.data.contour;
     this.renderOpenContour(enabledElement, svgDrawingHelper, annotation);
     if (!openUShapeContourVectorToPeak) {
         return;
@@ -100,7 +110,7 @@ function renderOpenUShapedContour(enabledElement, svgDrawingHelper, annotation)
     drawPolylineSvg(svgDrawingHelper, annotation.annotationUID, 'first-to-last', [firstCanvasPoint, lastCanvasPoint], {
         color: options.color,
         width: options.width,
-        connectLastToFirst: false,
+        closePath: false,
         lineDash: '2,2',
     });
     drawPolylineSvg(svgDrawingHelper, annotation.annotationUID, 'midpoint-to-open-contour', [
@@ -109,7 +119,7 @@ function renderOpenUShapedContour(enabledElement, svgDrawingHelper, annotation)
     ], {
         color: options.color,
         width: options.width,
-        connectLastToFirst: false,
+        closePath: false,
         lineDash: '2,2',
     });
 }
@@ -117,7 +127,7 @@ function renderContourBeingDrawn(enabledElement, svgDrawingHelper, annotation) {
     const options = this._getRenderingOptions(enabledElement, annotation);
     const { allowOpenContours } = this.configuration;
     const { canvasPoints } = this.drawData;
-    options.connectLastToFirst = false;
+    options.closePath = false;
     drawPolylineSvg(svgDrawingHelper, annotation.annotationUID, '1', canvasPoints, options);
     if (allowOpenContours) {
         const firstPoint = canvasPoints[0];
@@ -132,14 +142,20 @@ function renderContourBeingDrawn(enabledElement, svgDrawingHelper, annotation) {
     }
 }
 function renderClosedContourBeingEdited(enabledElement, svgDrawingHelper, annotation) {
+    const { viewport } = enabledElement;
     const { fusedCanvasPoints } = this.editData;
     if (fusedCanvasPoints === undefined) {
         this.renderClosedContour(enabledElement, svgDrawingHelper, annotation);
         return;
     }
+    const childContours = getContourHolesDataCanvas(annotation, viewport);
+    const allContours = [fusedCanvasPoints, ...childContours];
     const options = this._getRenderingOptions(enabledElement, annotation);
     const polylineUIDToRender = 'preview-1';
-    drawPolylineSvg(svgDrawingHelper, annotation.annotationUID, polylineUIDToRender, fusedCanvasPoints, options);
+    if (annotation.parentAnnotationUID && options.fillOpacity) {
+        options.fillOpacity = 0;
+    }
+    drawPathSvg(svgDrawingHelper, annotation.annotationUID, polylineUIDToRender, allContours, options);
 }
 function renderOpenContourBeingEdited(enabledElement, svgDrawingHelper, annotation) {
     const { fusedCanvasPoints } = this.editData;
@@ -151,10 +167,42 @@ function renderOpenContourBeingEdited(enabledElement, svgDrawingHelper, annotati
     const polylineUIDToRender = 'preview-1';
     drawPolylineSvg(svgDrawingHelper, annotation.annotationUID, polylineUIDToRender, fusedCanvasPoints, options);
 }
+function renderPointContourWithMarker(enabledElement, svgDrawingHelper, annotation) {
+    if (annotation.parentAnnotationUID) {
+        return;
+    }
+    const { viewport } = enabledElement;
+    const options = this._getRenderingOptions(enabledElement, annotation);
+    const canvasPolyline = annotation.data.contour.polyline.map((worldPos) => viewport.worldToCanvas(worldPos));
+    const childContours = getContourHolesDataCanvas(annotation, viewport);
+    const polylineUID = '1';
+    const center = canvasPolyline[0];
+    const radius = 6;
+    const numberOfPoints = 100;
+    const circlePoints = [];
+    for (let i = 0; i < numberOfPoints; i++) {
+        const angle = (i / numberOfPoints) * 2 * Math.PI;
+        const x = center[0] + radius * Math.cos(angle);
+        const y = center[1] + radius * Math.sin(angle);
+        circlePoints.push([x, y]);
+    }
+    const crosshair = [
+        [center[0] - radius * 2, center[1]],
+        [center[0] + radius * 2, center[1]],
+        [center[0], center[1] - radius * 2],
+        [center[0], center[1] + radius * 2],
+    ];
+    drawPathSvg(svgDrawingHelper, annotation.annotationUID, polylineUID + '-crosshair_v', [crosshair[0], crosshair[1]], options);
+    drawPathSvg(svgDrawingHelper, annotation.annotationUID, polylineUID + '-crosshair_h', [crosshair[2], crosshair[3]], options);
+    const allContours = [circlePoints, ...childContours];
+    drawPathSvg(svgDrawingHelper, annotation.annotationUID, polylineUID, allContours, options);
+}
 function registerRenderMethods(toolInstance) {
     toolInstance.renderContour = renderContour.bind(toolInstance);
     toolInstance.renderClosedContour = renderClosedContour.bind(toolInstance);
     toolInstance.renderOpenContour = renderOpenContour.bind(toolInstance);
+    toolInstance.renderPointContourWithMarker =
+        renderPointContourWithMarker.bind(toolInstance);
     toolInstance.renderOpenUShapedContour =
         renderOpenUShapedContour.bind(toolInstance);
     toolInstance.renderContourBeingDrawn =
@@ -166,4 +214,3 @@ function registerRenderMethods(toolInstance) {
     toolInstance._getRenderingOptions = _getRenderingOptions.bind(toolInstance);
 }
 export default registerRenderMethods;
-//# sourceMappingURL=renderMethods.js.map

package/dist/esm/tools/annotation/splines/BSpline.d.ts

@@ -0,0 +1,5 @@
+import { CubicSpline } from './CubicSpline';
+declare class BSpline extends CubicSpline {
+    protected getTransformMatrix(): number[];
+}
+export { BSpline as default, BSpline };

package/dist/esm/tools/annotation/splines/BSpline.js

@@ -0,0 +1,9 @@
+import { mat4 } from 'gl-matrix';
+import { CubicSpline } from './CubicSpline';
+const TRANSFORM_MATRIX = mat4.multiplyScalar(mat4.create(), mat4.fromValues(1, 4, 1, 0, -3, 0, 3, 0, 3, -6, 3, 0, -1, 3, -3, 1), 1 / 6);
+class BSpline extends CubicSpline {
+    getTransformMatrix() {
+        return TRANSFORM_MATRIX;
+    }
+}
+export { BSpline as default, BSpline };

package/dist/esm/tools/annotation/splines/CardinalSpline.d.ts

@@ -0,0 +1,12 @@
+import { CubicSpline } from './CubicSpline';
+import type { CardinalSplineProps } from '../../../types';
+declare class CardinalSpline extends CubicSpline {
+    private _scale;
+    private _fixedScale;
+    constructor(props?: CardinalSplineProps);
+    get scale(): number;
+    set scale(scale: number);
+    get fixedScale(): boolean;
+    protected getTransformMatrix(): number[];
+}
+export { CardinalSpline as default, CardinalSpline };

package/dist/esm/tools/annotation/splines/CardinalSpline.js

@@ -0,0 +1,32 @@
+import { CubicSpline } from './CubicSpline';
+class CardinalSpline extends CubicSpline {
+    constructor(props) {
+        super(props);
+        this._scale = props?.scale ?? 0.5;
+        this._fixedScale = props?.fixedScale ?? false;
+    }
+    get scale() {
+        return this._scale;
+    }
+    set scale(scale) {
+        if (this._fixedScale || this._scale === scale) {
+            return;
+        }
+        this._scale = scale;
+        this.invalidated = true;
+    }
+    get fixedScale() {
+        return this._fixedScale;
+    }
+    getTransformMatrix() {
+        const { scale: s } = this;
+        const s2 = 2 * s;
+        return [
+            0, 1, 0, 0,
+            -s, 0, s, 0,
+            s2, s - 3, 3 - s2, -s,
+            -s, 2 - s, s - 2, s
+        ];
+    }
+}
+export { CardinalSpline as default, CardinalSpline };

package/dist/esm/tools/annotation/splines/CatmullRomSpline.d.ts

@@ -0,0 +1,5 @@
+import { CardinalSpline } from './CardinalSpline';
+declare class CatmullRomSpline extends CardinalSpline {
+    constructor();
+}
+export { CatmullRomSpline as default, CatmullRomSpline };

package/dist/esm/tools/annotation/splines/CatmullRomSpline.js

@@ -0,0 +1,7 @@
+import { CardinalSpline } from './CardinalSpline';
+class CatmullRomSpline extends CardinalSpline {
+    constructor() {
+        super({ scale: 0.5, fixedScale: true });
+    }
+}
+export { CatmullRomSpline as default, CatmullRomSpline };

package/dist/esm/tools/annotation/splines/CubicSpline.d.ts

@@ -0,0 +1,13 @@
+import type { Types } from '@cornerstonejs/core';
+import { Spline } from './Spline';
+import type { SplineCurveSegment } from '../../../types';
+declare abstract class CubicSpline extends Spline {
+    protected getPreviewCurveSegments(controlPointPreview: Types.Point2, closeSpline: boolean): SplineCurveSegment[];
+    protected getSplineCurves(): SplineCurveSegment[];
+    private _getNumCurveSegments;
+    private _getPoint;
+    private _getCurveSegmentPoints;
+    private _getLineSegments;
+    private _getCurveSegment;
+}
+export { CubicSpline as default, CubicSpline };

package/dist/esm/tools/annotation/splines/CubicSpline.js

@@ -0,0 +1,164 @@
+import { vec4 } from 'gl-matrix';
+import { Spline } from './Spline';
+import * as math from '../../../utilities/math';
+const MAX_U_ERROR = 1e-8;
+class CubicSpline extends Spline {
+    getPreviewCurveSegments(controlPointPreview, closeSpline) {
+        const previewNumCurveSegments = this._getNumCurveSegments() + 1;
+        const startCurveSegIndex = Math.max(0, previewNumCurveSegments - 2);
+        const endCurveSegIndex = closeSpline
+            ? previewNumCurveSegments
+            : previewNumCurveSegments - 1;
+        const transformMatrix = this.getTransformMatrix();
+        const controlPoints = [...this.controlPoints];
+        const curveSegments = [];
+        if (!closeSpline) {
+            controlPoints.push(controlPointPreview);
+        }
+        for (let i = startCurveSegIndex; i <= endCurveSegIndex; i++) {
+            const curveSegment = this._getCurveSegment(i, transformMatrix, controlPoints, closeSpline);
+            curveSegments.push(curveSegment);
+        }
+        return curveSegments;
+    }
+    getSplineCurves() {
+        const numCurveSegments = this._getNumCurveSegments();
+        const curveSegments = new Array(numCurveSegments);
+        if (numCurveSegments <= 0) {
+            return [];
+        }
+        const transformMatrix = this.getTransformMatrix();
+        let previousCurveSegmentsLength = 0;
+        for (let i = 0; i < numCurveSegments; i++) {
+            const curveSegment = this._getCurveSegment(i, transformMatrix);
+            curveSegment.previousCurveSegmentsLength = previousCurveSegmentsLength;
+            curveSegments[i] = curveSegment;
+            previousCurveSegmentsLength += curveSegment.length;
+        }
+        return curveSegments;
+    }
+    _getNumCurveSegments(controlPoints = this.controlPoints, closed = this.closed) {
+        return closed
+            ? controlPoints.length
+            : Math.max(0, controlPoints.length - 1);
+    }
+    _getPoint(u, transformMatrix, controlPoints = this.controlPoints, closed = this.closed) {
+        const numCurveSegments = this._getNumCurveSegments(controlPoints, closed);
+        const uInt = Math.floor(u);
+        let curveSegmentIndex = uInt % numCurveSegments;
+        const t = u - uInt;
+        const curveSegmentIndexOutOfBounds = curveSegmentIndex < 0 || curveSegmentIndex >= numCurveSegments;
+        if (curveSegmentIndexOutOfBounds) {
+            if (this.closed) {
+                curveSegmentIndex =
+                    (numCurveSegments + curveSegmentIndex) % numCurveSegments;
+            }
+            else {
+                return;
+            }
+        }
+        const { p0, p1, p2, p3 } = this._getCurveSegmentPoints(curveSegmentIndex, controlPoints, closed);
+        const tt = t * t;
+        const ttt = tt * t;
+        const tValues = vec4.fromValues(1, t, tt, ttt);
+        const qValues = vec4.transformMat4(vec4.create(), tValues, transformMatrix);
+        return [
+            vec4.dot(qValues, vec4.fromValues(p0[0], p1[0], p2[0], p3[0])),
+            vec4.dot(qValues, vec4.fromValues(p0[1], p1[1], p2[1], p3[1])),
+        ];
+    }
+    _getCurveSegmentPoints(curveSegmentIndex, controlPoints = this.controlPoints, closed = this.closed) {
+        const numCurveSegments = this._getNumCurveSegments(controlPoints, closed);
+        const p1Index = curveSegmentIndex;
+        const p0Index = p1Index - 1;
+        const p2Index = closed ? (p1Index + 1) % numCurveSegments : p1Index + 1;
+        const p3Index = p2Index + 1;
+        const p1 = controlPoints[p1Index];
+        const p2 = controlPoints[p2Index];
+        let p0;
+        let p3;
+        if (p0Index >= 0) {
+            p0 = controlPoints[p0Index];
+        }
+        else {
+            p0 = closed
+                ? controlPoints[controlPoints.length - 1]
+                : math.point.mirror(p2, p1);
+        }
+        if (p3Index < controlPoints.length) {
+            p3 = controlPoints[p3Index];
+        }
+        else {
+            p3 = closed ? controlPoints[0] : math.point.mirror(p1, p2);
+        }
+        return { p0, p1, p2, p3 };
+    }
+    _getLineSegments(curveSegmentIndex, transformMatrix, controlPoints = this.controlPoints, closed = this.closed) {
+        const numCurveSegments = this._getNumCurveSegments(controlPoints, closed);
+        const numLineSegments = this.resolution + 1;
+        const inc = 1 / numLineSegments;
+        const minU = curveSegmentIndex;
+        let maxU = minU + 1;
+        if (!closed && curveSegmentIndex === numCurveSegments - 1) {
+            maxU -= MAX_U_ERROR;
+        }
+        const lineSegments = [];
+        let startPoint;
+        let endPoint;
+        let previousLineSegmentsLength = 0;
+        for (let i = 0, u = minU; i <= numLineSegments; i++, u += inc) {
+            u = u > maxU ? maxU : u;
+            const point = this._getPoint(u, transformMatrix, controlPoints, closed);
+            if (!i) {
+                startPoint = point;
+                continue;
+            }
+            endPoint = point;
+            const dx = endPoint[0] - startPoint[0];
+            const dy = endPoint[1] - startPoint[1];
+            const length = Math.sqrt(dx ** 2 + dy ** 2);
+            const aabb = {
+                minX: startPoint[0] <= endPoint[0] ? startPoint[0] : endPoint[0],
+                maxX: startPoint[0] >= endPoint[0] ? startPoint[0] : endPoint[0],
+                minY: startPoint[1] <= endPoint[1] ? startPoint[1] : endPoint[1],
+                maxY: startPoint[1] >= endPoint[1] ? startPoint[1] : endPoint[1],
+            };
+            lineSegments.push({
+                points: {
+                    start: startPoint,
+                    end: endPoint,
+                },
+                aabb,
+                length,
+                previousLineSegmentsLength,
+            });
+            startPoint = endPoint;
+            previousLineSegmentsLength += length;
+        }
+        return lineSegments;
+    }
+    _getCurveSegment(curveSegmentIndex, transformMatrix = this.getTransformMatrix(), controlPoints = this.controlPoints, closed = this.closed) {
+        const { p0, p1, p2, p3 } = this._getCurveSegmentPoints(curveSegmentIndex, controlPoints, closed);
+        const lineSegments = this._getLineSegments(curveSegmentIndex, transformMatrix, controlPoints, closed);
+        let curveSegmentLength = 0;
+        let minX = Infinity;
+        let minY = Infinity;
+        let maxX = -Infinity;
+        let maxY = -Infinity;
+        lineSegments.forEach(({ aabb: lineSegAABB, length: lineSegLength }) => {
+            minX = Math.min(minX, lineSegAABB.minX);
+            minY = Math.min(minY, lineSegAABB.minY);
+            maxX = Math.max(maxX, lineSegAABB.maxX);
+            maxY = Math.max(maxY, lineSegAABB.maxY);
+            curveSegmentLength += lineSegLength;
+        });
+        return {
+            controlPoints: { p0, p1, p2, p3 },
+            aabb: { minX, minY, maxX, maxY },
+            length: curveSegmentLength,
+            previousCurveSegmentsLength: 0,
+            lineSegments,
+        };
+    }
+}
+export { CubicSpline as default, CubicSpline };

package/dist/esm/tools/annotation/splines/LinearSpline.d.ts

@@ -0,0 +1,5 @@
+import { CardinalSpline } from './CardinalSpline';
+declare class LinearSpline extends CardinalSpline {
+    constructor();
+}
+export { LinearSpline as default, LinearSpline };

package/dist/esm/tools/annotation/splines/LinearSpline.js

@@ -0,0 +1,7 @@
+import { CardinalSpline } from './CardinalSpline';
+class LinearSpline extends CardinalSpline {
+    constructor() {
+        super({ resolution: 0, fixedResolution: true, scale: 0, fixedScale: true });
+    }
+}
+export { LinearSpline as default, LinearSpline };

package/dist/esm/tools/annotation/splines/QuadraticBezier.d.ts

@@ -0,0 +1,6 @@
+import { QuadraticSpline } from './QuadraticSpline';
+declare class QuadraticBezier extends QuadraticSpline {
+    hasTangentPoints(): boolean;
+    protected getTransformMatrix(): number[];
+}
+export { QuadraticBezier as default, QuadraticBezier };

package/dist/esm/tools/annotation/splines/QuadraticBezier.js

@@ -0,0 +1,15 @@
+import { QuadraticSpline } from './QuadraticSpline';
+const TRANSFORM_MATRIX = [
+    1, 0, 0,
+    -2, 2, 0,
+    1, -2, 1,
+];
+class QuadraticBezier extends QuadraticSpline {
+    hasTangentPoints() {
+        return true;
+    }
+    getTransformMatrix() {
+        return TRANSFORM_MATRIX;
+    }
+}
+export { QuadraticBezier as default, QuadraticBezier };

package/dist/esm/tools/annotation/splines/QuadraticSpline.d.ts

@@ -0,0 +1,9 @@
+import type { Types } from '@cornerstonejs/core';
+import { Spline } from './Spline';
+import type { SplineLineSegment, SplineCurveSegment } from '../../../types/';
+declare abstract class QuadraticSpline extends Spline {
+    protected getSplineCurves(): SplineCurveSegment[];
+    protected getLineSegments(): SplineLineSegment[];
+    getPreviewCurveSegments(controlPointPreview: Types.Point2, closeSpline: boolean): SplineCurveSegment[];
+}
+export { QuadraticSpline as default, QuadraticSpline };

package/dist/esm/tools/annotation/splines/QuadraticSpline.js

@@ -0,0 +1,13 @@
+import { Spline } from './Spline';
+class QuadraticSpline extends Spline {
+    getSplineCurves() {
+        return [];
+    }
+    getLineSegments() {
+        return [];
+    }
+    getPreviewCurveSegments(controlPointPreview, closeSpline) {
+        return [];
+    }
+}
+export { QuadraticSpline as default, QuadraticSpline };

package/dist/esm/tools/annotation/splines/Spline.d.ts

@@ -0,0 +1,51 @@
+import type { Types } from '@cornerstonejs/core';
+import type { ISpline, SplineProps, ClosestControlPoint, ClosestSplinePoint, ClosestPoint, ControlPointInfo, SplineCurveSegment } from '../../../types';
+declare abstract class Spline implements ISpline {
+    private _controlPoints;
+    private _resolution;
+    private _fixedResolution;
+    private _closed;
+    private _invalidated;
+    private _curveSegments;
+    private _aabb;
+    private _length;
+    constructor(props?: SplineProps);
+    protected get controlPoints(): Types.Point2[];
+    get numControlPoints(): number;
+    get resolution(): number;
+    set resolution(resolution: number);
+    get fixedResolution(): boolean;
+    get closed(): boolean;
+    set closed(closed: boolean);
+    get aabb(): Types.AABB2;
+    get length(): number;
+    get invalidated(): boolean;
+    protected set invalidated(invalidated: boolean);
+    hasTangentPoints(): boolean;
+    addControlPoint(point: Types.Point2): void;
+    addControlPoints(points: Types.Point2[]): void;
+    addControlPointAtU(u: number): ControlPointInfo;
+    deleteControlPointByIndex(index: number): boolean;
+    clearControlPoints(): void;
+    setControlPoints(points: Types.Point2[]): void;
+    updateControlPoint(index: number, newControlPoint: Types.Point2): void;
+    getControlPoints(): Types.Point2[];
+    getClosestControlPoint(point: Types.Point2): ClosestControlPoint;
+    getClosestControlPointWithinDistance(point: Types.Point2, maxDist: number): ClosestControlPoint;
+    getClosestPoint(point: Types.Point2): ClosestSplinePoint;
+    getClosestPointOnControlPointLines(point: Types.Point2): ClosestPoint;
+    getPolylinePoints(): Types.Point2[];
+    getPreviewPolylinePoints(controlPointPreview: Types.Point2, closeDistance: number): Types.Point2[];
+    isPointNearCurve(point: Types.Point2, maxDist: number): boolean;
+    containsPoint(point: Types.Point2): boolean;
+    protected abstract getTransformMatrix(): number[];
+    protected abstract getSplineCurves(): SplineCurveSegment[];
+    protected abstract getPreviewCurveSegments(controlPointPreview: Types.Point2, closeSpline: boolean): SplineCurveSegment[];
+    private _update;
+    private _convertCurveSegmentsToPolyline;
+    private _getCurveSegmmentsDistanceSquaredInfo;
+    private _getCurveSegmmentsWithinDistance;
+    private _getLineSegmentAt;
+    private _getClosingCurveSegmentWithStraightLineSegment;
+}
+export { Spline as default, Spline };