@cornerstonejs/tools 1.53.0 → 1.54.0

package/src/stateManagement/segmentation/segmentIndex.ts

@@ -21,6 +21,11 @@ function setActiveSegmentIndex(
 ): void {
   const segmentation = getSegmentation(segmentationId);
 
+  if (typeof segmentIndex === 'string') {
+    console.warn('segmentIndex is a string, converting to number');
+    segmentIndex = Number(segmentIndex);
+  }
+
   if (segmentation?.activeSegmentIndex !== segmentIndex) {
     segmentation.activeSegmentIndex = segmentIndex;
 

package/src/stateManagement/segmentation/segmentationState.ts

@@ -97,6 +97,65 @@ function getAllSegmentationRepresentations(): Record<
   return segmentationStateManager.getAllSegmentationRepresentations();
 }
 
+/**
+ * Finds all segmentation representations with the given segmentationId.
+ * @param segmentationId - The ID of the segmentation.
+ * @returns An array of found segmentation representations.
+ */
+function getSegmentationIdRepresentations(segmentationId) {
+  const allRepresentations = getAllSegmentationRepresentations() || {};
+  const foundRepresentations = [];
+
+  for (const toolGroupId in allRepresentations) {
+    const toolGroupRepresentations = allRepresentations[toolGroupId];
+
+    const foundRepresentation = toolGroupRepresentations.find(
+      (representation) => representation.segmentationId === segmentationId
+    );
+
+    if (foundRepresentation) {
+      foundRepresentations.push(foundRepresentation);
+    }
+  }
+
+  return foundRepresentations;
+}
+
+/**
+ * Finds a segmentation representation by its UID.
+ *
+ * @param segmentationRepresentationUID - The UID of the segmentation representation to find.
+ * @returns The found segmentation representation, or undefined if not found.
+ */
+function findSegmentationRepresentationByUID(
+  segmentationRepresentationUID: string
+): {
+  toolGroupId: string;
+  segmentationRepresentation: ToolGroupSpecificRepresentation;
+} {
+  const allToolGroupRepresentations = getAllSegmentationRepresentations() || [];
+
+  const toolGroupIds = Object.keys(allToolGroupRepresentations);
+
+  for (const toolGroupId of toolGroupIds) {
+    const toolGroupRepresentations =
+      getAllSegmentationRepresentations()[toolGroupId];
+
+    const foundRepresentation = toolGroupRepresentations.find(
+      (representation) =>
+        representation.segmentationRepresentationUID ===
+        segmentationRepresentationUID
+    );
+
+    if (foundRepresentation) {
+      return {
+        segmentationRepresentation: foundRepresentation,
+        toolGroupId,
+      };
+    }
+  }
+}
+
 /**
  * Get the tool group IDs that have a segmentation representation with the given
  * segmentationId
@@ -445,9 +504,12 @@ export {
   getToolGroupIdsWithSegmentation,
   getAllSegmentationRepresentations,
   getSegmentationRepresentationByUID,
+  getSegmentationIdRepresentations,
   // color
   addColorLUT,
   getColorLUT,
   getNextColorLUTIndex,
   removeColorLUT,
+  //
+  findSegmentationRepresentationByUID,
 };

package/src/tools/ScaleOverlayTool.ts

@@ -139,7 +139,10 @@ class ScaleOverlayTool extends AnnotationDisplayTool {
 
       addAnnotation(newAnnotation, viewport.element);
       annotation = newAnnotation;
-    } else if (this.editData.annotation && this.editData.annotation.data.viewportId == viewport.id) {
+    } else if (
+      this.editData.annotation &&
+      this.editData.annotation.data.viewportId == viewport.id
+    ) {
       this.editData.annotation.data.handles.points =
         viewportCanvasCornersInWorld;
       this.editData.annotation.data.viewportId = viewport.id;

package/src/tools/annotation/PlanarFreehandContourSegmentationTool.ts

@@ -1,8 +1,6 @@
-import type { SplineContourSegmentationAnnotation } from '../../types/ToolSpecificAnnotationTypes';
 import { utilities } from '@cornerstonejs/core';
-import type { PublicToolProps, AnnotationRenderContext } from '../../types';
+import type { PublicToolProps } from '../../types';
 import PlanarFreehandROITool from './PlanarFreehandROITool';
-import { triggerSegmentationDataModified } from '../../stateManagement/segmentation/triggerSegmentationEvents';
 
 class PlanarFreehandContourSegmentationTool extends PlanarFreehandROITool {
   static toolName;
@@ -30,25 +28,6 @@ class PlanarFreehandContourSegmentationTool extends PlanarFreehandROITool {
     // Re-enable contour segmentation behavior disabled by PlanarFreehandROITool
     return true;
   }
-
-  protected renderAnnotationInstance(
-    renderContext: AnnotationRenderContext
-  ): boolean {
-    const { annotation } = renderContext;
-    const { invalidated } = annotation;
-    const renderResult = super.renderAnnotationInstance(renderContext);
-
-    // Trigger the event only for invalid annotations
-    if (invalidated) {
-      const { segmentationId } = (<SplineContourSegmentationAnnotation>(
-        annotation
-      )).data.segmentation;
-
-      triggerSegmentationDataModified(segmentationId);
-    }
-
-    return renderResult;
-  }
 }
 
 PlanarFreehandContourSegmentationTool.toolName =

package/src/tools/annotation/PlanarFreehandROITool.ts

@@ -510,7 +510,7 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
   }
 
   protected isContourSegmentationTool(): boolean {
-    // Disable contour segmenatation behavior because it shall be activated only
+    // Disable contour segmentation behavior because it shall be activated only
     // for PlanarFreehandContourSegmentationTool
     return false;
   }
@@ -539,8 +539,7 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
   protected renderAnnotationInstance(
     renderContext: AnnotationRenderContext
   ): boolean {
-    const { enabledElement, targetId, svgDrawingHelper, annotationStyle } =
-      renderContext;
+    const { enabledElement, targetId, svgDrawingHelper } = renderContext;
     const annotation = renderContext.annotation as PlanarFreehandROIAnnotation;
 
     let renderStatus = false;
@@ -664,7 +663,6 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
     enabledElement
   ) => {
     const { data } = annotation;
-    const { element } = viewport;
     const { cachedStats } = data;
     const { polyline: points } = data.contour;
 

package/src/tools/annotation/ProbeTool.ts

@@ -425,6 +425,10 @@ class ProbeTool extends AnnotationTool {
 
       const { color } = this.getAnnotationStyle({ annotation, styleSpecifier });
 
+      if (!data.cachedStats) {
+        data.cachedStats = {};
+      }
+
       if (
         !data.cachedStats[targetId] ||
         data.cachedStats[targetId].value == null

package/src/tools/annotation/SplineROITool.ts

@@ -640,7 +640,7 @@ class SplineROITool extends ContourSegmentationBaseTool {
   };
 
   protected isContourSegmentationTool(): boolean {
-    // Disable contour segmenatation behavior because it shall be activated only
+    // Disable contour segmentation behavior because it shall be activated only
     // for SplineContourSegmentationTool
     return false;
   }

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

@@ -235,7 +235,7 @@ function completeDrawClosedContour(
     : 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
+  // contours. A future optimization if we use this for segmentation is to re-do
   // this rendering with the GPU rather than SVG.
 
   updateContourPolyline(
@@ -249,7 +249,7 @@ function completeDrawClosedContour(
 
   const { textBox } = annotation.data.handles;
 
-  if (!textBox.hasMoved) {
+  if (!textBox?.hasMoved) {
     triggerContourAnnotationCompleted(annotation, contourHoleProcessingEnabled);
   }
 

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

@@ -47,7 +47,7 @@ function activateOpenContourEndEdit(
   }
 
   let movingTextBox = false;
-  if ((handle as TextBoxHandle).worldPosition) {
+  if ((handle as TextBoxHandle)?.worldPosition) {
     movingTextBox = true;
   }
 

package/src/tools/base/AnnotationTool.ts

@@ -224,7 +224,7 @@ abstract class AnnotationTool extends AnnotationDisplayTool {
       }
     }
 
-    for (let i = 0; i < points.length; i++) {
+    for (let i = 0; i < points?.length; i++) {
       const point = points[i];
       const annotationCanvasCoordinate = viewport.worldToCanvas(point);
 

package/src/tools/base/BaseTool.ts

@@ -1,9 +1,4 @@
-import {
-  StackViewport,
-  utilities,
-  BaseVolumeViewport,
-  VideoViewport,
-} from '@cornerstonejs/core';
+import { utilities, BaseVolumeViewport } from '@cornerstonejs/core';
 import { Types } from '@cornerstonejs/core';
 import ToolModes from '../../enums/ToolModes';
 import StrategyCallbacks from '../../enums/StrategyCallbacks';

package/src/tools/base/ContourBaseTool.ts

@@ -217,7 +217,7 @@ abstract class ContourBaseTool extends AnnotationTool {
    * @returns Polyline points in world space
    */
   protected getPolylinePoints(annotation: ContourAnnotation): Types.Point3[] {
-    // Attenttion: `contour.polyline` is the new way to store a polyline but it
+    // Attention: `contour.polyline` is the new way to store a polyline but it
     // may be undefined because it was `data.polyline` before (fallback)
     return annotation.data.contour?.polyline ?? annotation.data.polyline;
   }

package/src/tools/base/ContourSegmentationBaseTool.ts

@@ -20,10 +20,16 @@ import { SegmentationRepresentations } from '../../enums';
 import ContourBaseTool from './ContourBaseTool';
 import { triggerSegmentationDataModified } from '../../stateManagement/segmentation/triggerSegmentationEvents';
 import { InterpolationManager } from '../../utilities/contours/interpolation';
+import {
+  addContourSegmentationAnnotation,
+  removeContourSegmentationAnnotation,
+} from '../../utilities/contourSegmentation';
+import { getToolGroupIdsWithSegmentation } from '../../stateManagement/segmentation/segmentationState';
+import { triggerAnnotationRenderForToolGroupIds } from '../../utilities';
 
 /**
  * A base contour segmentation class responsible for rendering, registering
- * and unregistering contour segmentation annotations.
+ * and unregister contour segmentation annotations.
  */
 abstract class ContourSegmentationBaseTool extends ContourBaseTool {
   constructor(toolProps: PublicToolProps, defaultToolProps: ToolProps) {
@@ -70,8 +76,7 @@ abstract class ContourSegmentationBaseTool extends ContourBaseTool {
       throw new Error(`A contour segmentation must be active`);
     }
 
-    const { segmentationId, segmentationRepresentationUID } =
-      activeSegmentationRepresentation;
+    const { segmentationId } = activeSegmentationRepresentation;
     const segmentIndex =
       segmentIndexController.getActiveSegmentIndex(segmentationId);
 
@@ -82,7 +87,6 @@ abstract class ContourSegmentationBaseTool extends ContourBaseTool {
           segmentation: {
             segmentationId,
             segmentIndex,
-            segmentationRepresentationUID,
           },
         },
       }
@@ -94,11 +98,10 @@ abstract class ContourSegmentationBaseTool extends ContourBaseTool {
     element: HTMLDivElement
   ): string {
     const annotationUID = super.addAnnotation(annotation, element);
-
     if (this.isContourSegmentationTool()) {
       const contourSegAnnotation = annotation as ContourSegmentationAnnotation;
 
-      this._registerContourSegmentationAnnotation(contourSegAnnotation);
+      addContourSegmentationAnnotation(contourSegAnnotation);
     }
 
     return annotationUID;
@@ -110,7 +113,7 @@ abstract class ContourSegmentationBaseTool extends ContourBaseTool {
    */
   protected cancelAnnotation(annotation: Annotation): void {
     if (this.isContourSegmentationTool()) {
-      this._unregisterContourSegmentationAnnotation(
+      removeContourSegmentationAnnotation(
         annotation as ContourSegmentationAnnotation
       );
     }
@@ -148,16 +151,21 @@ abstract class ContourSegmentationBaseTool extends ContourBaseTool {
   ): boolean {
     const { annotation } = renderContext;
     const { invalidated } = annotation;
-
     // Render the annotation before triggering events
     const renderResult = super.renderAnnotationInstance(renderContext);
-
     if (invalidated && this.isContourSegmentationTool()) {
       const { segmentationId } = (<SplineContourSegmentationAnnotation>(
         annotation
       )).data.segmentation;
-
       triggerSegmentationDataModified(segmentationId);
+
+      // check which other viewport is rendering the same segmentationId
+      // and trigger the event for them to be able to render the segmentation
+      // annotation as well
+
+      const toolGroupIds = getToolGroupIdsWithSegmentation(segmentationId);
+
+      triggerAnnotationRenderForToolGroupIds(toolGroupIds);
     }
 
     return renderResult;
@@ -173,15 +181,16 @@ abstract class ContourSegmentationBaseTool extends ContourBaseTool {
   }): Record<string, any> {
     const { toolGroupId } = this;
     const annotation = context.annotation as ContourSegmentationAnnotation;
-    const { segmentationRepresentationUID, segmentationId, segmentIndex } =
-      annotation.data.segmentation;
+    const { segmentationId, segmentIndex } = annotation.data.segmentation;
     const segmentation = segmentationState.getSegmentation(segmentationId);
     const segmentationRepresentation =
-      segmentationState.getSegmentationRepresentationByUID(
-        toolGroupId,
-        segmentationRepresentationUID
-      );
+      this._getSegmentationRepresentation(segmentationId);
 
+    if (!segmentationRepresentation) {
+      // return defaults if no segmentation representation is found
+      return {};
+    }
+    const { segmentationRepresentationUID } = segmentationRepresentation;
     const { active } = segmentationRepresentation;
     const { autoGenerated } = annotation;
     const segmentsLocked = segmentLocking.getLockedSegments(segmentationId);
@@ -278,37 +287,31 @@ abstract class ContourSegmentationBaseTool extends ContourBaseTool {
     };
   }
 
-  private _registerContourSegmentationAnnotation(
-    annotation: ContourSegmentationAnnotation
-  ) {
-    const { segmentationId, segmentIndex } = annotation.data.segmentation;
-    const segmentation = segmentationState.getSegmentation(segmentationId);
-    const { annotationUIDsMap } = segmentation.representationData.CONTOUR;
+  private _getSegmentationRepresentation(segmentationId) {
+    const segmentationRepresentations =
+      segmentationState.getSegmentationRepresentations(this.toolGroupId);
 
-    let annotationsUIDsSet = annotationUIDsMap.get(segmentIndex);
+    const validSegmentationRepresentations = segmentationRepresentations.filter(
+      (representation) => representation.segmentationId === segmentationId
+    );
 
-    if (!annotationsUIDsSet) {
-      annotationsUIDsSet = new Set();
-      annotationUIDsMap.set(segmentIndex, annotationsUIDsSet);
+    if (!validSegmentationRepresentations) {
+      console.warn(
+        `No segmentation representation found for toolGroupId: ${this.toolGroupId}`
+      );
+      return;
     }
 
-    annotationsUIDsSet.add(annotation.annotationUID);
-  }
-
-  private _unregisterContourSegmentationAnnotation(
-    annotation: ContourSegmentationAnnotation
-  ) {
-    const { segmentationId, segmentIndex } = annotation.data.segmentation;
-    const segmentation = segmentationState.getSegmentation(segmentationId);
-    const { annotationUIDsMap } = segmentation.representationData.CONTOUR;
-    const annotationsUIDsSet = annotationUIDsMap.get(segmentIndex);
-
-    annotationsUIDsSet.delete(annotation.annotationUID);
-
-    // Delete segmentIndex Set if there is no more annotations
-    if (!annotationsUIDsSet.size) {
-      annotationUIDsMap.delete(segmentIndex);
+    if (
+      segmentationState.getSegmentationRepresentations(this.toolGroupId)
+        .length > 1
+    ) {
+      console.warn(
+        'Multiple segmentation representations detected for this tool group. The first one will be used.'
+      );
     }
+
+    return validSegmentationRepresentations[0];
   }
 }
 

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

@@ -2,6 +2,7 @@ import {
   getEnabledElementByIds,
   Types,
   StackViewport,
+  BaseVolumeViewport,
 } from '@cornerstonejs/core';
 
 import Representations from '../../../enums/SegmentationRepresentations';
@@ -11,9 +12,9 @@ import {
   SegmentationRepresentationConfig,
   ToolGroupSpecificRepresentation,
 } from '../../../types/SegmentationStateTypes';
-import { addOrUpdateContourSets } from './addOrUpdateContourSets';
+import { addOrUpdateVTKContourSets } from './vtkContour/addOrUpdateVTKContourSets';
 import removeContourFromElement from './removeContourFromElement';
-import { deleteConfigCache } from './contourConfigCache';
+import { deleteConfigCache } from './vtkContour/contourConfigCache';
 
 /**
  * It removes a segmentation representation from the tool group's viewports and
@@ -66,27 +67,99 @@ async function render(
 ): Promise<void> {
   const { segmentationId } = representationConfig;
   const segmentation = SegmentationState.getSegmentation(segmentationId);
+
+  if (!segmentation) {
+    return;
+  }
+
   const contourData = segmentation.representationData[Representations.Contour];
-  const { geometryIds } = contourData;
 
-  // We don't have a good way to handle stack viewports for contours at the moment.
-  // Plus, if we add a segmentation to one viewport, it gets added to all the viewports in the toolGroup too.
-  if (viewport instanceof StackViewport) {
+  const { geometryIds, annotationUIDsMap } = contourData;
+
+  if (!geometryIds?.length && !annotationUIDsMap?.size) {
     return;
   }
 
-  if (!geometryIds?.length) {
-    // This is a normal occurrence when contours activated, but not yet drawn
+  // this means we would like to use vtk actors for contour data
+
+  if (!(viewport instanceof BaseVolumeViewport)) {
+    // We don't have a good way to handle stack viewports for contours at the moment.
+    // Plus, if we add a segmentation to one viewport, it gets added to all the viewports in the toolGroup too.
     return;
   }
 
   // add the contour sets to the viewport
-  addOrUpdateContourSets(
+  addOrUpdateVTKContourSets(
     viewport,
     geometryIds,
     representationConfig,
     toolGroupConfig
   );
+
+  /**
+   * The following logic could be added if we want to support the use case
+   * where the contour representation data is initiated using annotations
+   * in the state from the get-go , and not when the user draws a contour.
+   */
+  // if (contourData?.points?.length) {
+  //   // contourData = createAnnotationsFromPoints(contourData.points);
+  //   const contourSegmentationAnnotation = {
+  //     annotationUID: csUtils.uuidv4(),
+  //     data: {
+  //       contour: {
+  //         closed: true,
+  //         polyline: contourData.points,
+  //       },
+  //       segmentation: {
+  //         segmentationId,
+  //         segmentIndex: 1, // Todo
+  //         segmentationRepresentationUID:
+  //           representationConfig.segmentationRepresentationUID,
+  //       },
+  //     },
+  //     highlighted: false,
+  //     invalidated: false,
+  //     isLocked: false,
+  //     isVisible: true,
+  //     metadata: {
+  //       toolName: 'PlanarFreehandContourSegmentationTool',
+  //       FrameOfReferenceUID: viewport.getFrameOfReferenceUID(),
+  //       viewPlaneNormal: viewport.getCamera().viewPlaneNormal,
+  //     },
+  //   };
+
+  //   addAnnotation(contourSegmentationAnnotation, viewport.element);
+  // } else if (
+  //   !contourData &&
+  //   polySeg.canComputeRequestedRepresentation(
+  //     representationConfig.segmentationRepresentationUID
+  //   )
+  // ) {
+  // contourData = await polySeg.computeAndAddContourRepresentation(
+  //   segmentationId,
+  //   {
+  //     segmentationRepresentationUID:
+  //       representationConfig.segmentationRepresentationUID,
+  //     viewport,
+  //   }
+  // );
+  // }
+
+  // if (contourData?.geometryIds?.length) {
+  //   handleVTKContour({
+  //     viewport,
+  //     representationConfig,
+  //     toolGroupConfig,
+  //     geometryIds: contourData.geometryIds,
+  //   });
+  // } else if (contourData.annotationUIDsMap?.size) {
+  //   handleContourAnnotationSegmentation({
+  //     viewport,
+  //     representationConfig,
+  //     toolGroupConfig,
+  //     annotationUIDsMap: contourData.annotationUIDsMap,
+  //   });
+  // }
 }
 
 function _removeContourFromToolGroupViewports(

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

@@ -30,6 +30,8 @@ function removeContourFromElement(
 
   // @ts-ignore
   viewport.removeActors(actorUIDsToRemove);
+
+  // Todo: add the logic to remove the svg contour segmentation representations as well
 }
 
 export default removeContourFromElement;

package/src/tools/displayTools/Contour/{addContourSetsToElement.ts → vtkContour/addContourSetsToElement.ts}

@@ -13,7 +13,7 @@ import {
 import {
   SegmentationRepresentationConfig,
   ToolGroupSpecificContourRepresentation,
-} from '../../../types';
+} from '../../../../types';
 import { getConfigCache, setConfigCache } from './contourConfigCache';
 
 export function addContourSetsToElement(

package/src/tools/displayTools/Contour/{addOrUpdateContourSets.ts → vtkContour/addOrUpdateVTKContourSets.ts}

@@ -3,11 +3,11 @@ import { Types } from '@cornerstonejs/core';
 import {
   SegmentationRepresentationConfig,
   ToolGroupSpecificContourRepresentation,
-} from '../../../types';
+} from '../../../../types';
 import { addContourSetsToElement } from './addContourSetsToElement';
-import { updateContourSets } from './updateContourSets';
+import { updateVTKContourSets } from './updateVTKContourSets';
 
-export function addOrUpdateContourSets(
+export function addOrUpdateVTKContourSets(
   viewport: Types.IVolumeViewport,
   geometryIds: string[],
   contourRepresentation: ToolGroupSpecificContourRepresentation,
@@ -17,7 +17,7 @@ export function addOrUpdateContourSets(
   const actorUID = `CONTOUR_${segmentationRepresentationUID}`;
   const actor = viewport.getActor(actorUID);
 
-  const addOrUpdateFn = actor ? updateContourSets : addContourSetsToElement;
+  const addOrUpdateFn = actor ? updateVTKContourSets : addContourSetsToElement;
   addOrUpdateFn(
     viewport,
     geometryIds,

package/src/tools/displayTools/Contour/{updateContourSets.ts → vtkContour/updateVTKContourSets.ts}

@@ -4,11 +4,11 @@ import vtkActor from '@kitware/vtk.js/Rendering/Core/Actor';
 import {
   SegmentationRepresentationConfig,
   ToolGroupSpecificContourRepresentation,
-} from '../../../types';
+} from '../../../../types';
 import { getConfigCache, setConfigCache } from './contourConfigCache';
 import { getSegmentSpecificConfig } from './utils';
 
-export function updateContourSets(
+export function updateVTKContourSets(
   viewport: Types.IVolumeViewport,
   geometryIds: string[],
   contourRepresentation: ToolGroupSpecificContourRepresentation,

package/src/tools/displayTools/Contour/{utils.ts → vtkContour/utils.ts}

@@ -2,7 +2,7 @@ import { Enums, Types } from '@cornerstonejs/core';
 import vtkCellArray from '@kitware/vtk.js/Common/Core/CellArray';
 import vtkPoints from '@kitware/vtk.js/Common/Core/Points';
 import vtkPolyData from '@kitware/vtk.js/Common/DataModel/PolyData';
-import { ToolGroupSpecificContourRepresentation } from '../../../types';
+import { ToolGroupSpecificContourRepresentation } from '../../../../types';
 
 /**
  * If the segment specific config exists for the given segment id, it returns

package/src/tools/displayTools/Labelmap/addLabelmapToElement.ts

@@ -36,7 +36,7 @@ async function addLabelmapToElement(
   const immediateRender = false;
   const suppressEvents = true;
 
-  if (isVolumeSegmentation(labelMapData)) {
+  if (isVolumeSegmentation(labelMapData, viewport)) {
     // Todo: Right now we use MIP blend mode for the labelmap, since the
     // composite blend mode has a non linear behavior regarding fill and line
     // opacity. This should be changed to a custom labelmap blendMode which does

package/src/tools/displayTools/Labelmap/index.ts

@@ -1,4 +1,13 @@
 import labelmapDisplay from './labelmapDisplay';
 import labelmapConfig from './labelmapConfig';
+import {
+  validate as validateLabelmap,
+  validatePublic as validateLabelmapPublic,
+} from './validateLabelmap';
 
-export { labelmapDisplay, labelmapConfig };
+export {
+  labelmapDisplay,
+  labelmapConfig,
+  validateLabelmap,
+  validateLabelmapPublic,
+};