@cornerstonejs/tools 1.48.2 → 1.49.0

package/src/tools/annotation/planarFreehandROITool/drawLoop.ts

@@ -1,5 +1,4 @@
 import { getEnabledElement } from '@cornerstonejs/core';
-import type { Types } from '@cornerstonejs/core';
 import {
   resetElementCursor,
   hideElementCursor,
@@ -9,14 +8,15 @@ import { EventTypes } from '../../../types';
 import { state } from '../../../store';
 import { vec3 } from 'gl-matrix';
 import {
-  shouldInterpolate,
+  shouldSmooth,
   getInterpolatedPoints,
-} from '../../../utilities/planarFreehandROITool/interpolatePoints';
+} from '../../../utilities/planarFreehandROITool/smoothPoints';
 import triggerAnnotationRenderForViewportIds from '../../../utilities/triggerAnnotationRenderForViewportIds';
 import { PlanarFreehandROIAnnotation } from '../../../types/ToolSpecificAnnotationTypes';
 import findOpenUShapedContourVectorToPeak from './findOpenUShapedContourVectorToPeak';
 import { polyline } from '../../../utilities/math';
 import { removeAnnotation } from '../../../stateManagement/annotation/annotationState';
+import reverseIfAntiClockwise from '../../../utilities/contours/reverseIfAntiClockwise';
 
 const {
   addCanvasPointsToArray,
@@ -216,10 +216,14 @@ function completeDrawClosedContour(element: HTMLDivElement): boolean {
   // Remove last point which will be a duplicate now.
   canvasPoints.pop();
 
-  const updatedPoints = shouldInterpolate(this.configuration)
-    ? getInterpolatedPoints(this.configuration, canvasPoints)
+  const clockwise = this.configuration.makeClockWise
+    ? reverseIfAntiClockwise(canvasPoints)
     : canvasPoints;
 
+  const updatedPoints = shouldSmooth(this.configuration, annotation)
+    ? getInterpolatedPoints(this.configuration, clockwise)
+    : clockwise;
+
   // Note: -> This is pretty expensive and may not scale well with hundreds of
   // contours. A future optimisation if we use this for segmentation is to re-do
   // this rendering with the GPU rather than SVG.
@@ -286,7 +290,7 @@ function completeDrawOpenContour(element: HTMLDivElement): boolean {
   const enabledElement = getEnabledElement(element);
   const { viewport, renderingEngine } = enabledElement;
 
-  const updatedPoints = shouldInterpolate(this.configuration)
+  const updatedPoints = shouldSmooth(this.configuration, annotation)
     ? getInterpolatedPoints(this.configuration, canvasPoints)
     : canvasPoints;
 

package/src/tools/annotation/planarFreehandROITool/openContourEditLoop.ts

@@ -11,9 +11,9 @@ import { PlanarFreehandROIAnnotation } from '../../../types/ToolSpecificAnnotati
 import { vec3, vec2 } from 'gl-matrix';
 import { polyline } from '../../../utilities/math';
 import {
-  shouldInterpolate,
+  shouldSmooth,
   getInterpolatedPoints,
-} from '../../../utilities/planarFreehandROITool/interpolatePoints';
+} from '../../../utilities/planarFreehandROITool/smoothPoints';
 import triggerAnnotationRenderForViewportIds from '../../../utilities/triggerAnnotationRenderForViewportIds';
 import findOpenUShapedContourVectorToPeak from './findOpenUShapedContourVectorToPeak';
 
@@ -542,7 +542,7 @@ function completeOpenContourEdit(element: HTMLDivElement) {
   const { fusedCanvasPoints, prevCanvasPoints } = this.editData;
 
   if (fusedCanvasPoints) {
-    const updatedPoints = shouldInterpolate(this.configuration)
+    const updatedPoints = shouldSmooth(this.configuration)
       ? getInterpolatedPoints(
           this.configuration,
           fusedCanvasPoints,

package/src/tools/base/ContourBaseTool.ts

@@ -114,6 +114,7 @@ abstract class ContourBaseTool extends AnnotationTool {
       viewUp
     );
 
+    const referencedSliceIndex = viewport.getCurrentImageIdIndex();
     const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
 
     return <ContourAnnotation>{
@@ -125,6 +126,7 @@ abstract class ContourBaseTool extends AnnotationTool {
         viewUp: <Types.Point3>[...viewUp],
         FrameOfReferenceUID,
         referencedImageId,
+        referencedSliceIndex,
       },
       data: {
         handles: {
@@ -146,6 +148,8 @@ abstract class ContourBaseTool extends AnnotationTool {
           closed: false,
         },
       },
+      interpolationUID: '',
+      autoGenerated: false,
     };
   }
 

package/src/tools/base/ContourSegmentationBaseTool.ts

@@ -16,6 +16,7 @@ import { ContourSegmentationAnnotation } from '../../types/ContourSegmentationAn
 import { StyleSpecifier } from '../../types/AnnotationStyle';
 import { SegmentationRepresentations } from '../../enums';
 import ContourBaseTool from './ContourBaseTool';
+import { InterpolationManager } from '../../utilities/contours/interpolation';
 
 /**
  * A base contour segmentation class responsible for rendering, registering
@@ -24,6 +25,9 @@ import ContourBaseTool from './ContourBaseTool';
 abstract class ContourSegmentationBaseTool extends ContourBaseTool {
   constructor(toolProps: PublicToolProps, defaultToolProps: ToolProps) {
     super(toolProps, defaultToolProps);
+    if (this.configuration.interpolation?.enabled) {
+      InterpolationManager.addTool(this.getToolName());
+    }
   }
 
   /**
@@ -155,6 +159,7 @@ abstract class ContourSegmentationBaseTool extends ContourBaseTool {
       );
 
     const { active } = segmentationRepresentation;
+    const { autoGenerated } = annotation;
     const segmentsLocked = segmentLocking.getLockedSegments(segmentationId);
     const annotationLocked = segmentsLocked.includes(segmentIndex as never);
 
@@ -207,7 +212,12 @@ abstract class ContourSegmentationBaseTool extends ContourBaseTool {
     let lineOpacity = 1;
     let fillOpacity = 0;
 
-    if (active) {
+    if (autoGenerated) {
+      lineWidth = mergedConfig.outlineWidthAutoGenerated ?? lineWidth;
+      lineDash = mergedConfig.outlineDashAutoGenerated ?? lineDash;
+      lineOpacity = mergedConfig.outlineOpacity ?? lineOpacity;
+      fillOpacity = mergedConfig.fillAlphaAutoGenerated ?? fillOpacity;
+    } else if (active) {
       lineWidth = mergedConfig.outlineWidthActive ?? lineWidth;
       lineDash = mergedConfig.outlineDashActive ?? lineDash;
       lineOpacity = mergedConfig.outlineOpacity ?? lineOpacity;

package/src/tools/displayTools/Contour/contourConfig.ts

@@ -2,13 +2,18 @@ import { ContourConfig } from '../../../types/ContourTypes';
 
 const defaultContourConfig: ContourConfig = {
   renderOutline: true,
+  outlineWidthAutoGenerated: 3,
   outlineWidthActive: 2,
-  outlineWidthInactive: 2,
+  outlineWidthInactive: 1,
   outlineOpacity: 1,
   outlineOpacityInactive: 0.85,
+  outlineDashActive: undefined,
+  outlineDashInactive: undefined,
+  outlineDashAutoGenerated: '5,3',
   renderFill: true,
-  fillAlpha: 1,
-  fillAlphaInactive: 0,
+  fillAlpha: 0.5,
+  fillAlphaInactive: 0.3,
+  fillAlphaAutoGenerated: 0.3,
 };
 
 function getDefaultContourConfig(): ContourConfig {

package/src/tools/displayTools/Contour/contourDisplay.ts

@@ -76,9 +76,7 @@ async function render(
   }
 
   if (!geometryIds?.length) {
-    console.warn(
-      `No contours found for segmentationId ${segmentationId}. Skipping render.`
-    );
+    // This is a normal occurrence when contours activated, but not yet drawn
     return;
   }
 

package/src/types/AnnotationStyle.ts

@@ -1,9 +1,11 @@
 type Modes = '' | 'Active' | 'Passive' | 'Enabled';
-type States = '' | 'Highlighted' | 'Selected' | 'Locked';
+type States = '' | 'Highlighted' | 'Selected' | 'Locked' | 'AutoGenerated';
 
 type Properties =
   | 'color'
+  | 'colorAutoGenerated'
   | 'lineWidth'
+  | 'lineWidthAutoGenerated'
   | 'lineDash'
   | 'textBoxFontFamily'
   | 'textBoxFontSize'

package/src/types/AnnotationTypes.ts

@@ -11,6 +11,8 @@ type Annotation = {
   isVisible?: boolean;
   /** Has annotation data been invalidated (e.g., as a result of mouse interactions) */
   invalidated?: boolean;
+  /** If the annotation is auto generated from other annotations*/
+  autoGenerated?: boolean;
   /** Metadata for annotation */
   metadata: {
     /**

package/src/types/ContourSegmentationAnnotation.ts

@@ -1,6 +1,7 @@
 import { ContourAnnotation } from './ContourAnnotation';
 
 export type ContourSegmentationAnnotationData = {
+  autoGenerated?: boolean;
   data: {
     segmentation: {
       segmentationId: string;

package/src/types/ContourTypes.ts

@@ -2,6 +2,8 @@
  * Label map config for the label map representation
  */
 export type ContourConfig = {
+  /** thickness of the outline when segmentation is auto generated */
+  outlineWidthAutoGenerated?: number;
   /** thickness of the outline when segmentation is active */
   outlineWidthActive?: number;
   /** thickness of the outline when segmentation is inactive */
@@ -14,6 +16,10 @@ export type ContourConfig = {
   outlineDashActive?: string;
   /** dash style of the outline when segmentation is inactive */
   outlineDashInactive?: string;
+  /**
+   * Dash style of the outline when segmentation is auto-generated
+   */
+  outlineDashAutoGenerated?: string;
   /** outline visibility */
   renderOutline?: boolean;
   /** render fill */
@@ -22,6 +28,8 @@ export type ContourConfig = {
   fillAlpha?: number;
   /** fillAlphaInactive */
   fillAlphaInactive?: number;
+  /** fillAlphaAutoGenerated */
+  fillAlphaAutoGenerated?: number;
 };
 
 /**

package/src/types/EventTypes.ts

@@ -6,6 +6,8 @@ import IDistance from './IDistance';
 import { SetToolBindingsType } from './ISetToolModeOptions';
 import { Swipe } from '../enums/Touch';
 import { ToolModes } from '../enums';
+import { InterpolationROIAnnotation } from './ToolSpecificAnnotationTypes';
+import { ChangeTypes } from '../enums';
 
 /**
  * The normalized interaction event detail
@@ -118,6 +120,7 @@ type AnnotationAddedEventDetail = {
 type AnnotationCompletedEventDetail = {
   /** The annotation that is being added to the annotations manager. */
   annotation: Annotation;
+  changeType?: ChangeTypes.Completed;
 };
 
 /**
@@ -130,6 +133,8 @@ type AnnotationModifiedEventDetail = {
   renderingEngineId: string;
   /** The annotation that is being added to the annotations manager. */
   annotation: Annotation;
+  /** The type of this change */
+  changeType?: ChangeTypes;
 };
 
 /**
@@ -187,6 +192,28 @@ type AnnotationRenderedEventDetail = {
   renderingEngineId: string;
 };
 
+type AnnotationInterpolationCompletedEventDetail = {
+  /** The annotation that is being updated with a change in label. */
+  annotation: InterpolationROIAnnotation;
+  /** The HTML element that the annotation was rendered on. */
+  element: HTMLDivElement;
+  /** unique id of the viewport */
+  viewportId: string;
+  /** unique id of the rendering engine */
+  renderingEngineId: string;
+};
+
+type AnnotationInterpolationRemovedEventDetail = {
+  /** The annotations that is being removed . */
+  annotations: Array<InterpolationROIAnnotation>;
+  /** The HTML element that the annotation was rendered on. */
+  element: HTMLDivElement;
+  /** unique id of the viewport */
+  viewportId: string;
+  /** unique id of the rendering engine */
+  renderingEngineId: string;
+};
+
 /**
  * EventDetail for when a Segmentation Data is modified by a tool
  */
@@ -498,6 +525,18 @@ type AnnotationLockChangeEventType =
 type AnnotationVisibilityChangeEventType =
   Types.CustomEventType<AnnotationVisibilityChangeEventDetail>;
 
+/**
+ * The Annotation interpolation process completed event type
+ */
+type AnnotationInterpolationCompletedEventType =
+  Types.CustomEventType<AnnotationInterpolationCompletedEventDetail>;
+
+/**
+ * The Annotation interpolation removed event type
+ */
+type AnnotationInterpolationRemovedEventType =
+  Types.CustomEventType<AnnotationInterpolationRemovedEventDetail>;
+
 /**
  * Event for when SegmentationData is modified
  */
@@ -670,6 +709,10 @@ export {
   AnnotationVisibilityChangeEventDetail,
   AnnotationLockChangeEventType,
   AnnotationVisibilityChangeEventType,
+  AnnotationInterpolationCompletedEventDetail,
+  AnnotationInterpolationCompletedEventType,
+  AnnotationInterpolationRemovedEventDetail,
+  AnnotationInterpolationRemovedEventType,
   SegmentationDataModifiedEventType,
   SegmentationRepresentationModifiedEventDetail,
   SegmentationRepresentationModifiedEventType,

package/src/types/InterpolationTypes.ts

@@ -0,0 +1,42 @@
+import { Types } from '@cornerstonejs/core';
+import { Annotation } from './AnnotationTypes';
+import { InterpolationROIAnnotation } from './ToolSpecificAnnotationTypes';
+
+/**
+ * A base viewport and annotation information used to start interpolating
+ * between slices.
+ */
+export type InterpolationViewportData = {
+  /** The annotation that was just completed. */
+  annotation: InterpolationROIAnnotation;
+  /** The type of event, whether initializing the label or updating it. */
+  interpolationUID: string;
+  /** The viewport that this interpolation is occurring within */
+  viewport: Types.IViewport;
+  sliceData: Types.ImageSliceData;
+};
+
+export type ImageInterpolationData = {
+  sliceIndex: number;
+  annotations?: Annotation[];
+};
+
+/**
+ * The selector object for accepting interpolation results.  This object
+ * can be specified to select a sub-set of interpolation results.
+ */
+export type AcceptInterpolationSelector = {
+  /**
+   *  Specify the tool names to apply this to, defaulting to all
+   *  interpolation tools registered
+   */
+  toolNames?: string[];
+  /**
+   * Applies just to the given segmentation
+   */
+  segmentationId?: string;
+  /**
+   * Applies just to the given segment index.
+   */
+  segmentIndex?: number;
+};

package/src/types/ToolSpecificAnnotationTypes.ts

@@ -264,6 +264,21 @@ export type PlanarFreehandROIAnnotation = ContourAnnotation & {
 export type PlanarFreehandContourSegmentationAnnotation =
   PlanarFreehandROIAnnotation & ContourSegmentationAnnotationData;
 
+export type InterpolationROIAnnotation = ContourAnnotation & {
+  metadata: {
+    cameraPosition?: Types.Point3;
+    cameraFocalPoint?: Types.Point3;
+    viewPlaneNormal?: Types.Point3;
+    viewUp?: Types.Point3;
+    annotationUID?: string;
+    FrameOfReferenceUID: string;
+    referencedImageId?: string;
+    toolName: string;
+    referencedSliceIndex?: number;
+  };
+  interpolationUID?: string;
+};
+
 export interface ArrowAnnotation extends Annotation {
   data: {
     text: string;

package/src/types/index.ts

@@ -70,6 +70,10 @@ import {
   LabelmapToolOperationDataStack,
   LabelmapToolOperationDataVolume,
 } from './LabelmapToolOperationData';
+import type {
+  InterpolationViewportData,
+  ImageInterpolationData,
+} from './InterpolationTypes';
 
 // Splines
 import type { CardinalSplineProps } from './CardinalSplineProps';
@@ -94,6 +98,8 @@ export type {
   BidirectionalData,
   CanvasCoordinates,
   IAnnotationManager,
+  InterpolationViewportData,
+  ImageInterpolationData,
   GroupSpecificAnnotations,
   AnnotationState,
   AnnotationStyle,

package/src/utilities/contours/PointsArray.ts

@@ -0,0 +1,165 @@
+import type { Types } from '@cornerstonejs/core';
+import { vec2, vec3 } from 'gl-matrix';
+
+export type PolyDataPointConfiguration = {
+  dimensions?: 2 | 3;
+  initialSize?: number;
+};
+
+/**
+ * PointsArray is a TypedArray based representation of n dimensional points with
+ * custom sub-classes to represent the version of this based on Point2 and Point3
+ * gl-matrix implementation.
+ * This representation is efficient for storing large numbers of points and for
+ * transferring them amongst systems and is planned to have more methods added
+ * for generic manipulation of data.
+ */
+export abstract class PointsArray<T> {
+  data: Float32Array;
+  dimensions = 3;
+  public length = 0;
+
+  constructor(configuration: PolyDataPointConfiguration = {}) {
+    const { initialSize = 1024, dimensions = 3 } = configuration;
+    this.data = new Float32Array(initialSize * dimensions);
+    this.dimensions = dimensions;
+  }
+
+  protected forEach(func: (value: T, index: number) => void, point: T) {
+    for (let i = 0; i < this.length; i++) {
+      func(this.getPoint(i, point), i);
+    }
+  }
+
+  abstract getPoint(index: number, point: T): T;
+
+  /**
+   * Reverse the points in place
+   */
+  public reverse() {
+    const midLength = Math.floor(this.length / 2);
+
+    for (let i = 0; i < midLength; i++) {
+      const indexStart = i * this.dimensions;
+      const indexEnd = (this.length - 1 - i) * this.dimensions;
+      for (let dimension = 0; dimension < this.dimensions; dimension++) {
+        const valueStart = this.data[indexStart + dimension];
+        this.data[indexStart + dimension] = this.data[indexEnd + dimension];
+        this.data[indexEnd + dimension] = valueStart;
+      }
+    }
+  }
+
+  protected map(f: (value, index: number) => T, factory: (index: number) => T) {
+    const mapData = [];
+    for (let i = 0; i < this.length; i++) {
+      mapData.push(f(this.getPoint(i, factory(i)), i));
+    }
+    return mapData;
+  }
+
+  /** Create an PointsArray3 from the x,y,z individual arrays */
+  public static fromXYZ({ x, y, z }: Types.PointsXYZ): PointsArray3 {
+    const array = new PointsArray3({ initialSize: x.length });
+    let offset = 0;
+    for (let i = 0; i < x.length; i++) {
+      array.data[offset++] = x[i];
+      array.data[offset++] = y[i];
+      array.data[offset++] = z[i];
+    }
+    array.length = x.length;
+    return array;
+  }
+}
+
+/**
+ * A version of this with support for Types.Point2 and vec2 generation and extraction.
+ *
+ * This class is designed to allow for efficient storage and manipulation of
+ * large sets of Point2 type data but stored as a single Float32Array.
+ */
+export class PointsArray2 extends PointsArray<Types.Point2> {
+  constructor(configuration = {}) {
+    super({ ...configuration, dimensions: 2 });
+  }
+
+  public forEach(
+    func: (value: Types.Point2, index: number) => void,
+    point = vec2.create() as Types.Point2
+  ) {
+    super.forEach(func, point);
+  }
+
+  public getPoint(index: number, point = vec2.create() as Types.Point2) {
+    if (index >= this.length) {
+      return;
+    }
+    const index2 = index * 2;
+    point[0] = this.data[index2];
+    point[1] = this.data[index2 + 1];
+    return point;
+  }
+
+  public get points() {
+    return this.map(
+      (point) => point,
+      () => vec2.create() as Types.Point2
+    );
+  }
+}
+
+/**
+ * A version of PointsArray designed to work with Types.Point3 and vec3 data,
+ * but efficiently storing the data internally as a Float32Array.
+ * A good use case for this would be storing contour data or function results
+ * of type `(number)=>Point3` as these can be quite large and can benefit from
+ * directly using the Float32Array representation for both the Point3 values and
+ * the internal storage of the Point3[] data.
+ *
+ * For example, a 64k length array of `PointsArray3` data is just a bit over 256k of data as
+ * stored with this class, but when stored as a Point3[], is at least 1 meg in size
+ * because each number is 64 bits, and each Point3[] requires a list of values, adding
+ * at least another 8 bytes per value, and at least another 64 bytes per array.
+ */
+export class PointsArray3 extends PointsArray<Types.Point3> {
+  constructor(configuration = {}) {
+    super({ ...configuration, dimensions: 3 });
+  }
+
+  public forEach(
+    func: (value: Types.Point3, index: number) => void,
+    point = vec3.create() as Types.Point3
+  ) {
+    super.forEach(func, point);
+  }
+
+  public getPoint(index: number, point = vec3.create() as Types.Point3) {
+    if (index >= this.length) {
+      return;
+    }
+    const index2 = index * 3;
+    point[0] = this.data[index2];
+    point[1] = this.data[index2 + 1];
+    point[2] = this.data[index2 + 2];
+    return point;
+  }
+
+  public get points() {
+    return this.map(
+      (point) => point,
+      () => vec3.create() as Types.Point3
+    );
+  }
+
+  public getXYZ(): Types.PointsXYZ {
+    const x = [];
+    const y = [];
+    const z = [];
+    this.forEach((point) => {
+      x.push(point[0]);
+      y.push(point[1]);
+      z.push(point[2]);
+    });
+    return { x, y, z };
+  }
+}

package/src/utilities/contours/index.ts

@@ -2,8 +2,9 @@ import contourFinder from './contourFinder';
 import mergePoints from './mergePoints';
 import detectContourHoles from './detectContourHoles';
 import { generateContourSetsFromLabelmap } from './generateContourSetsFromLabelmap';
-
 import AnnotationToPointData from './AnnotationToPointData';
+import acceptAutogeneratedInterpolations from './interpolation/acceptAutogeneratedInterpolations';
+import * as interpolation from './interpolation';
 
 export {
   contourFinder,
@@ -11,4 +12,6 @@ export {
   detectContourHoles,
   generateContourSetsFromLabelmap,
   AnnotationToPointData,
+  interpolation,
+  acceptAutogeneratedInterpolations,
 };

package/src/utilities/contours/interpolation/acceptAutogeneratedInterpolations.ts

@@ -0,0 +1,16 @@
+import InterpolationManager from '../../segmentation/InterpolationManager/InterpolationManager';
+import type { AcceptInterpolationSelector } from '../../../types/InterpolationTypes';
+import type AnnotationGroupSelector from '../../../types/AnnotationGroupSelector';
+
+/**
+ * Accepts interpolated annotations, marking them as autoGenerated false.
+ *
+ * @param annotationGroupSelector - viewport or FOR to select annotations for
+ * @param selector - nested selection criteria
+ */
+export default function acceptAutogeneratedInterpolations(
+  annotationGroupSelector: AnnotationGroupSelector,
+  selector: AcceptInterpolationSelector
+) {
+  InterpolationManager.acceptAutoGenerated(annotationGroupSelector, selector);
+}

package/src/utilities/contours/interpolation/createPolylineToolData.ts

@@ -0,0 +1,56 @@
+import { Types, utilities as csUtils } from '@cornerstonejs/core';
+import { InterpolationROIAnnotation } from '../../../types/ToolSpecificAnnotationTypes';
+
+/**
+ * Creates a new annotation instance given the tool data, based on the referenced tool
+ * data type.
+ * Note that this object takes ownership of the polyline and handlePoints data, that is,
+ * directly assigns them internally to the result.
+ *
+ * @param polyline - data for the polyline, owned hereafter by the annotation
+ * @param handlePoints - data for the edit handles, if any, owned hereafter by the annotation
+ * @param referencedToolData - for base data for the new tool
+
+ */
+export default function createPolylineToolData(
+  polyline,
+  handlePoints,
+  referencedToolData
+) {
+  const annotation: InterpolationROIAnnotation = csUtils.deepMerge(
+    {
+      data: {},
+      metadata: {},
+    },
+    referencedToolData
+  );
+  Object.assign(annotation, {
+    highlighted: false,
+    invalidated: true,
+    autoGenerated: true,
+    annotationUID: undefined,
+    cachedStats: {},
+  });
+  Object.assign(annotation.data, {
+    handles: {
+      points: handlePoints || [],
+      activeHandleIndex: null,
+      textBox: {
+        hasMoved: false,
+        worldPosition: <Types.Point3>[0, 0, 0],
+        worldBoundingBox: {
+          topLeft: <Types.Point3>[0, 0, 0],
+          topRight: <Types.Point3>[0, 0, 0],
+          bottomLeft: <Types.Point3>[0, 0, 0],
+          bottomRight: <Types.Point3>[0, 0, 0],
+        },
+      },
+    },
+    contour: {
+      polyline,
+      closed: true,
+    },
+  });
+
+  return annotation;
+}