@cornerstonejs/adapters 3.3.3 → 3.4.0

package/dist/esm/adapters/Cornerstone3D/Segmentation/compactMergeSegData.d.ts

@@ -0,0 +1,4 @@
+export declare const compactMergeSegmentDataWithoutInformationLoss: ({ arrayOfSegmentData, newSegmentData }: {
+    arrayOfSegmentData: any;
+    newSegmentData: any;
+}) => void;

package/dist/esm/adapters/Cornerstone3D/Segmentation/compactMergeSegData.js

@@ -0,0 +1,61 @@
+const checkHasOverlapping = _ref => {
+  let {
+    largerArray,
+    currentTestedArray,
+    newArray
+  } = _ref;
+  return largerArray.some((_, currentImageIndex) => {
+    const originalImagePixelData = currentTestedArray[currentImageIndex];
+    const newImagePixelData = newArray[currentImageIndex];
+    if (!originalImagePixelData || !newImagePixelData) {
+      return false;
+    }
+    return originalImagePixelData.some((originalPixel, currentPixelIndex) => {
+      const newPixel = newImagePixelData[currentPixelIndex];
+      return originalPixel && newPixel;
+    });
+  });
+};
+const compactMergeSegmentDataWithoutInformationLoss = _ref2 => {
+  let {
+    arrayOfSegmentData,
+    newSegmentData
+  } = _ref2;
+  if (arrayOfSegmentData.length === 0) {
+    arrayOfSegmentData.push(newSegmentData);
+    return;
+  }
+  for (let currentTestedIndex = 0; currentTestedIndex < arrayOfSegmentData.length; currentTestedIndex++) {
+    const currentTestedArray = arrayOfSegmentData[currentTestedIndex];
+    const originalArrayIsLarger = currentTestedArray.length > newSegmentData.length;
+    const largerArray = originalArrayIsLarger ? currentTestedArray : newSegmentData;
+    const hasOverlapping = checkHasOverlapping({
+      currentTestedArray,
+      largerArray,
+      newArray: newSegmentData
+    });
+    if (hasOverlapping) {
+      continue;
+    }
+    largerArray.forEach((_, currentImageIndex) => {
+      const originalImagePixelData = currentTestedArray[currentImageIndex];
+      const newImagePixelData = newSegmentData[currentImageIndex];
+      if (!originalImagePixelData && !newImagePixelData || !newImagePixelData) {
+        return;
+      }
+      if (!originalImagePixelData) {
+        currentTestedArray[currentImageIndex] = newImagePixelData;
+        return;
+      }
+      const mergedPixelData = originalImagePixelData.map((originalPixel, currentPixelIndex) => {
+        const newPixel = newImagePixelData[currentPixelIndex];
+        return originalPixel || newPixel;
+      });
+      currentTestedArray[currentImageIndex] = mergedPixelData;
+    });
+    return;
+  }
+  arrayOfSegmentData.push(newSegmentData);
+};
+
+export { compactMergeSegmentDataWithoutInformationLoss };

package/dist/esm/adapters/Cornerstone3D/Segmentation/generateToolState.d.ts

@@ -1,16 +1,14 @@
 declare function generateToolState(imageIds: any, arrayBuffer: any, metadataProvider: any, skipOverlapping?: boolean, tolerance?: number, cs3dVersion?: number): any;
-declare function createFromDICOMSegBuffer(referencedImageIds: any, arrayBuffer: any, { metadataProvider, skipOverlapping, tolerance }: {
+declare function createFromDICOMSegBuffer(referencedImageIds: any, arrayBuffer: any, { metadataProvider, tolerance }: {
     metadataProvider: any;
-    skipOverlapping?: boolean;
     tolerance?: number;
 }): Promise<{
-    labelMapImages: any[][];
+    labelMapImages: any;
     segMetadata: {
         seriesInstanceUid: any;
         data: any[];
     };
     segmentsOnFrame: any[];
-    segmentsOnFrameArray: any[];
     centroids: Map<any, any>;
     overlappingSegments: any;
 }>;

package/dist/esm/adapters/Cornerstone3D/Segmentation/generateToolState.js

@@ -10,11 +10,9 @@ function generateToolState(imageIds, arrayBuffer, metadataProvider) {
 function createFromDICOMSegBuffer(referencedImageIds, arrayBuffer, _ref) {
   let {
     metadataProvider,
-    skipOverlapping = false,
     tolerance = 1e-3
   } = _ref;
   return createLabelmapsFromBufferInternal(referencedImageIds, arrayBuffer, metadataProvider, {
-    skipOverlapping,
     tolerance
   });
 }

package/dist/esm/adapters/Cornerstone3D/Segmentation/labelmapImagesFromBuffer.d.ts

@@ -1,13 +1,40 @@
 declare function createLabelmapsFromBufferInternal(referencedImageIds: any, arrayBuffer: any, metadataProvider: any, options: any): Promise<{
-    labelMapImages: any[][];
+    labelMapImages: any;
     segMetadata: {
         seriesInstanceUid: any;
         data: any[];
     };
     segmentsOnFrame: any[];
-    segmentsOnFrameArray: any[];
     centroids: Map<any, any>;
     overlappingSegments: any;
 }>;
-export declare function insertPixelDataPlanar(segmentsOnFrame: any, labelMapImages: any, pixelData: any, multiframe: any, imageIds: any, validOrientations: any, metadataProvider: any, tolerance: any, segmentsPixelIndices: any, sopUIDImageIdIndexMap: any, imageIdMaps: any): Promise<unknown>;
+export declare function insertPixelDataPlanar({ segmentsOnFrame, labelMapImages, pixelDataChunks, multiframe, referencedImageIds, validOrientations, metadataProvider, tolerance, segmentsPixelIndices, sopUIDImageIdIndexMap, imageIdMaps }: {
+    segmentsOnFrame: any;
+    labelMapImages: any;
+    pixelDataChunks: any;
+    multiframe: any;
+    referencedImageIds: any;
+    validOrientations: any;
+    metadataProvider: any;
+    tolerance: any;
+    segmentsPixelIndices: any;
+    sopUIDImageIdIndexMap: any;
+    imageIdMaps: any;
+}): Promise<unknown>;
+export declare function insertOverlappingPixelDataPlanar({ segmentsOnFrame, labelMapImages, pixelDataChunks, multiframe, referencedImageIds, validOrientations, metadataProvider, tolerance, segmentsPixelIndices, sopUIDImageIdIndexMap, imageIdMaps }: {
+    segmentsOnFrame: any;
+    labelMapImages: any;
+    pixelDataChunks: any;
+    multiframe: any;
+    referencedImageIds: any;
+    validOrientations: any;
+    metadataProvider: any;
+    tolerance: any;
+    segmentsPixelIndices: any;
+    sopUIDImageIdIndexMap: any;
+    imageIdMaps: any;
+}): {
+    arrayOfLabelMapImages: any;
+    hasOverlappingSegments: boolean;
+};
 export { createLabelmapsFromBufferInternal };

package/dist/esm/adapters/Cornerstone3D/Segmentation/labelmapImagesFromBuffer.js

@@ -2,7 +2,8 @@ import { imageLoader } from '@cornerstonejs/core';
 import { utilities, data, normalizers } from 'dcmjs';
 import ndarray from 'ndarray';
 import checkOrientation from '../../helpers/checkOrientation.js';
-import { getValidOrientations, getSegmentMetadata, unpackPixelData, checkSEGsOverlapping, calculateCentroid, readFromUnpackedChunks, alignPixelDataWithSourceData, getSegmentIndex, findReferenceSourceImageId } from '../../Cornerstone/Segmentation_4X.js';
+import { getValidOrientations, getSegmentMetadata, unpackPixelData, calculateCentroid, readFromUnpackedChunks, alignPixelDataWithSourceData, getSegmentIndex, findReferenceSourceImageId } from '../../Cornerstone/Segmentation_4X.js';
+import { compactMergeSegmentDataWithoutInformationLoss } from './compactMergeSegData.js';
 
 const {
   DicomMessage,
@@ -14,9 +15,49 @@ const {
 const {
   decode
 } = utilities.compression;
+const updateSegmentsOnFrame = _ref => {
+  let {
+    segmentsOnFrame,
+    imageIdIndex,
+    segmentIndex
+  } = _ref;
+  if (!segmentsOnFrame[imageIdIndex]) {
+    segmentsOnFrame[imageIdIndex] = [];
+  }
+  segmentsOnFrame[imageIdIndex].push(segmentIndex);
+};
+const updateSegmentsPixelIndices = _ref2 => {
+  let {
+    segmentsPixelIndices,
+    segmentIndex,
+    imageIdIndex,
+    indexCache
+  } = _ref2;
+  if (!segmentsPixelIndices.has(segmentIndex)) {
+    segmentsPixelIndices.set(segmentIndex, {});
+  }
+  const segmentIndexObject = segmentsPixelIndices.get(segmentIndex);
+  segmentIndexObject[imageIdIndex] = indexCache;
+  segmentsPixelIndices.set(segmentIndex, segmentIndexObject);
+};
+const extractInfoFromPerFrameFunctionalGroups = _ref3 => {
+  let {
+    PerFrameFunctionalGroups,
+    sequenceIndex,
+    sopUIDImageIdIndexMap,
+    multiframe
+  } = _ref3;
+  const referencedSOPInstanceUid = PerFrameFunctionalGroups.DerivationImageSequence[0].SourceImageSequence[0].ReferencedSOPInstanceUID;
+  const referencedImageId = sopUIDImageIdIndexMap[referencedSOPInstanceUid];
+  const segmentIndex = getSegmentIndex(multiframe, sequenceIndex);
+  return {
+    referencedSOPInstanceUid,
+    referencedImageId,
+    segmentIndex
+  };
+};
 async function createLabelmapsFromBufferInternal(referencedImageIds, arrayBuffer, metadataProvider, options) {
   const {
-    skipOverlapping = false,
     tolerance = 1e-3,
     TypedArrayConstructor = Uint8Array,
     maxBytesPerChunk = 199000000
@@ -61,26 +102,16 @@ async function createLabelmapsFromBufferInternal(referencedImageIds, arrayBuffer
     acc[sopInstanceUID] = imageId;
     return acc;
   }, {});
-  let overlapping = false;
-  if (!skipOverlapping) {
-    overlapping = checkSEGsOverlapping(pixelDataChunks, multiframe, referencedImageIds, validOrientations, metadataProvider, tolerance, TypedArrayConstructor, sopUIDImageIdIndexMap);
-  }
   let insertFunction;
   switch (orientation) {
     case "Planar":
-      if (overlapping) {
-        throw new Error("Overlapping segmentations are not yet supported.");
-      } else {
-        insertFunction = insertPixelDataPlanar;
-      }
+      insertFunction = insertPixelDataPlanar;
       break;
     case "Perpendicular":
       throw new Error("Segmentations orthogonal to the acquisition plane of the source data are not yet supported.");
     case "Oblique":
       throw new Error("Segmentations oblique to the acquisition plane of the source data are not yet supported.");
   }
-  const segmentsOnFrameArray = [];
-  segmentsOnFrameArray[0] = [];
   const segmentsOnFrame = [];
   const imageIdMaps = {
     indices: {},
@@ -95,22 +126,50 @@ async function createLabelmapsFromBufferInternal(referencedImageIds, arrayBuffer
     labelMapImages.push(labelMapImage);
   }
   const segmentsPixelIndices = new Map();
-  const overlappingSegments = await insertFunction(segmentsOnFrame, labelMapImages, pixelDataChunks, multiframe, referencedImageIds, validOrientations, metadataProvider, tolerance, segmentsPixelIndices, sopUIDImageIdIndexMap, imageIdMaps);
+  const {
+    hasOverlappingSegments,
+    arrayOfLabelMapImages
+  } = await insertFunction({
+    segmentsOnFrame,
+    labelMapImages,
+    pixelDataChunks,
+    multiframe,
+    referencedImageIds,
+    validOrientations,
+    metadataProvider,
+    tolerance,
+    segmentsPixelIndices,
+    sopUIDImageIdIndexMap,
+    imageIdMaps,
+    TypedArrayConstructor
+  });
   const centroidXYZ = new Map();
   segmentsPixelIndices.forEach((imageIdIndexBufferIndex, segmentIndex) => {
     const centroids = calculateCentroid(imageIdIndexBufferIndex, multiframe, metadataProvider, referencedImageIds);
     centroidXYZ.set(segmentIndex, centroids);
   });
   return {
-    labelMapImages: [labelMapImages],
+    labelMapImages: arrayOfLabelMapImages,
     segMetadata,
     segmentsOnFrame,
-    segmentsOnFrameArray,
     centroids: centroidXYZ,
-    overlappingSegments
+    overlappingSegments: hasOverlappingSegments
   };
 }
-function insertPixelDataPlanar(segmentsOnFrame, labelMapImages, pixelData, multiframe, imageIds, validOrientations, metadataProvider, tolerance, segmentsPixelIndices, sopUIDImageIdIndexMap, imageIdMaps) {
+function insertPixelDataPlanar(_ref4) {
+  let {
+    segmentsOnFrame,
+    labelMapImages,
+    pixelDataChunks,
+    multiframe,
+    referencedImageIds,
+    validOrientations,
+    metadataProvider,
+    tolerance,
+    segmentsPixelIndices,
+    sopUIDImageIdIndexMap,
+    imageIdMaps
+  } = _ref4;
   const {
     SharedFunctionalGroupsSequence,
     PerFrameFunctionalGroupsSequence,
@@ -125,7 +184,7 @@ function insertPixelDataPlanar(segmentsOnFrame, labelMapImages, pixelData, multi
     for (let i = 0; i < groupsLen; ++i) {
       const PerFrameFunctionalGroups = PerFrameFunctionalGroupsSequence[i];
       const ImageOrientationPatientI = sharedImageOrientationPatient || PerFrameFunctionalGroups.PlaneOrientationSequence.ImageOrientationPatient;
-      const view = readFromUnpackedChunks(pixelData, i * sliceLength, sliceLength);
+      const view = readFromUnpackedChunks(pixelDataChunks, i * sliceLength, sliceLength);
       const pixelDataI2D = ndarray(view, [Rows, Columns]);
       const alignedPixelDataI = alignPixelDataWithSourceData(pixelDataI2D, ImageOrientationPatientI, validOrientations, tolerance);
       if (!alignedPixelDataI) {
@@ -138,7 +197,7 @@ function insertPixelDataPlanar(segmentsOnFrame, labelMapImages, pixelData, multi
       if (!segmentsPixelIndices.has(segmentIndex)) {
         segmentsPixelIndices.set(segmentIndex, {});
       }
-      const imageId = findReferenceSourceImageId(multiframe, i, imageIds, metadataProvider, tolerance, sopUIDImageIdIndexMap);
+      const imageId = findReferenceSourceImageId(multiframe, i, referencedImageIds, metadataProvider, tolerance, sopUIDImageIdIndexMap);
       if (!imageId) {
         console.warn("Image not present in stack, can't import frame : " + i + ".");
         continue;
@@ -158,6 +217,19 @@ function insertPixelDataPlanar(segmentsOnFrame, labelMapImages, pixelData, multi
             if (data[x]) {
               if (!overlapping && labelmap2DView[x] !== 0) {
                 overlapping = true;
+                return resolve(insertOverlappingPixelDataPlanar({
+                  segmentsOnFrame,
+                  labelMapImages,
+                  pixelDataChunks,
+                  multiframe,
+                  referencedImageIds,
+                  validOrientations,
+                  metadataProvider,
+                  tolerance,
+                  segmentsPixelIndices,
+                  sopUIDImageIdIndexMap,
+                  imageIdMaps
+                }));
               }
               labelmap2DView[x] = segmentIndex;
               indexCache.push(x);
@@ -174,8 +246,249 @@ function insertPixelDataPlanar(segmentsOnFrame, labelMapImages, pixelData, multi
       segmentIndexObject[imageIdIndex] = indexCache;
       segmentsPixelIndices.set(segmentIndex, segmentIndexObject);
     }
-    resolve(overlapping);
+    resolve({
+      hasOverlappingSegments: overlapping,
+      arrayOfLabelMapImages: [labelMapImages]
+    });
   });
 }
+const getAlignedPixelData = _ref5 => {
+  let {
+    sharedImageOrientationPatient,
+    PerFrameFunctionalGroups,
+    pixelDataChunks,
+    sequenceIndex,
+    sliceLength,
+    Rows,
+    Columns,
+    validOrientations,
+    tolerance
+  } = _ref5;
+  const ImageOrientationPatientI = sharedImageOrientationPatient || PerFrameFunctionalGroups.PlaneOrientationSequence.ImageOrientationPatient;
+  const view = readFromUnpackedChunks(pixelDataChunks, sequenceIndex * sliceLength, sliceLength);
+  const pixelDataI2D = ndarray(view, [Rows, Columns]);
+  const alignedPixelDataI = alignPixelDataWithSourceData(pixelDataI2D, ImageOrientationPatientI, validOrientations, tolerance);
+  if (!alignedPixelDataI) {
+    throw new Error("Individual SEG frames are out of plane with respect to the first SEG frame. " + "This is not yet supported. Aborting segmentation loading.");
+  }
+  return alignedPixelDataI;
+};
+const checkImageDimensions = _ref6 => {
+  let {
+    metadataProvider,
+    imageId,
+    Rows,
+    Columns
+  } = _ref6;
+  const sourceImageMetadata = metadataProvider.get("instance", imageId);
+  if (Rows !== sourceImageMetadata.Rows || Columns !== sourceImageMetadata.Columns) {
+    throw new Error("Individual SEG frames have different geometry dimensions (Rows and Columns) " + "respect to the source image reference frame. This is not yet supported. " + "Aborting segmentation loading. ");
+  }
+};
+const getArrayOfLabelMapImagesWithSegmentData = _ref7 => {
+  let {
+    arrayOfSegmentData,
+    referencedImageIds
+  } = _ref7;
+  let largestArray = [];
+  for (let i = 0; i < arrayOfSegmentData.length; i++) {
+    const segmentData = arrayOfSegmentData[i];
+    if (segmentData.length > largestArray.length) {
+      largestArray = segmentData;
+    }
+  }
+  return arrayOfSegmentData.map(arr => {
+    const labelMapImages = referencedImageIds.map((referencedImageId, i) => {
+      const hasEmptySegmentData = !arr[i];
+      const labelMapImage = imageLoader.createAndCacheDerivedLabelmapImage(referencedImageId);
+      const pixelData = labelMapImage.getPixelData();
+      if (!hasEmptySegmentData) {
+        for (let j = 0; j < pixelData.length; j++) {
+          pixelData[j] = arr[i][j];
+        }
+      }
+      return labelMapImage;
+    }).filter(Boolean);
+    return labelMapImages;
+  });
+};
+function insertOverlappingPixelDataPlanar(_ref8) {
+  let {
+    segmentsOnFrame,
+    labelMapImages,
+    pixelDataChunks,
+    multiframe,
+    referencedImageIds,
+    validOrientations,
+    metadataProvider,
+    tolerance,
+    segmentsPixelIndices,
+    sopUIDImageIdIndexMap,
+    imageIdMaps
+  } = _ref8;
+  const {
+    SharedFunctionalGroupsSequence,
+    PerFrameFunctionalGroupsSequence,
+    Rows,
+    Columns
+  } = multiframe;
+  const sharedImageOrientationPatient = SharedFunctionalGroupsSequence.PlaneOrientationSequence ? SharedFunctionalGroupsSequence.PlaneOrientationSequence.ImageOrientationPatient : undefined;
+  const sliceLength = Columns * Rows;
+  const arrayOfSegmentData = getArrayOfSegmentData({
+    sliceLength,
+    Rows,
+    Columns,
+    validOrientations,
+    metadataProvider,
+    imageIdMaps,
+    segmentsOnFrame,
+    tolerance,
+    pixelDataChunks,
+    PerFrameFunctionalGroupsSequence,
+    labelMapImages,
+    sopUIDImageIdIndexMap,
+    multiframe,
+    sharedImageOrientationPatient,
+    segmentsPixelIndices
+  });
+  const arrayOfLabelMapImagesWithSegmentData = getArrayOfLabelMapImagesWithSegmentData({
+    arrayOfSegmentData,
+    referencedImageIds
+  });
+  return {
+    arrayOfLabelMapImages: arrayOfLabelMapImagesWithSegmentData,
+    hasOverlappingSegments: true
+  };
+}
+const getArrayOfSegmentData = _ref9 => {
+  let {
+    sliceLength,
+    Rows,
+    Columns,
+    validOrientations,
+    metadataProvider,
+    imageIdMaps,
+    segmentsOnFrame,
+    tolerance,
+    pixelDataChunks,
+    PerFrameFunctionalGroupsSequence,
+    labelMapImages,
+    sopUIDImageIdIndexMap,
+    multiframe,
+    sharedImageOrientationPatient,
+    segmentsPixelIndices
+  } = _ref9;
+  const arrayOfSegmentData = [];
+  const numberOfSegments = multiframe.SegmentSequence.length;
+  for (let currentSegmentIndex = 1; currentSegmentIndex <= numberOfSegments; ++currentSegmentIndex) {
+    const segmentData = getSegmentData({
+      PerFrameFunctionalGroupsSequence,
+      labelMapImages,
+      sopUIDImageIdIndexMap,
+      multiframe,
+      segmentIndex: currentSegmentIndex,
+      sliceLength,
+      Rows,
+      Columns,
+      validOrientations,
+      tolerance,
+      pixelDataChunks,
+      sharedImageOrientationPatient,
+      metadataProvider,
+      imageIdMaps,
+      segmentsOnFrame,
+      segmentsPixelIndices
+    });
+    compactMergeSegmentDataWithoutInformationLoss({
+      arrayOfSegmentData,
+      newSegmentData: segmentData
+    });
+  }
+  return arrayOfSegmentData;
+};
+const getSegmentData = _ref10 => {
+  let {
+    PerFrameFunctionalGroupsSequence,
+    labelMapImages,
+    sopUIDImageIdIndexMap,
+    multiframe,
+    segmentIndex,
+    sliceLength,
+    Rows,
+    Columns,
+    validOrientations,
+    tolerance,
+    pixelDataChunks,
+    sharedImageOrientationPatient,
+    metadataProvider,
+    imageIdMaps,
+    segmentsOnFrame,
+    segmentsPixelIndices
+  } = _ref10;
+  const segmentData = [];
+  for (let currentLabelMapImageIndex = 0; currentLabelMapImageIndex < labelMapImages.length; currentLabelMapImageIndex++) {
+    const currentLabelMapImage = labelMapImages[currentLabelMapImageIndex];
+    const referencedImageId = currentLabelMapImage.referencedImageId;
+    const PerFrameFunctionalGroupsIndex = PerFrameFunctionalGroupsSequence.findIndex((PerFrameFunctionalGroups, currentSequenceIndex) => {
+      const {
+        segmentIndex: groupsSegmentIndex,
+        referencedImageId: groupsReferenceImageId
+      } = extractInfoFromPerFrameFunctionalGroups({
+        PerFrameFunctionalGroups,
+        sequenceIndex: currentSequenceIndex,
+        sopUIDImageIdIndexMap,
+        multiframe
+      });
+      const isCorrectPerFrameFunctionalGroup = groupsSegmentIndex === segmentIndex && groupsReferenceImageId === currentLabelMapImage.referencedImageId;
+      return isCorrectPerFrameFunctionalGroup;
+    });
+    if (PerFrameFunctionalGroupsIndex === -1) {
+      continue;
+    }
+    const PerFrameFunctionalGroups = PerFrameFunctionalGroupsSequence[PerFrameFunctionalGroupsIndex];
+    const alignedPixelDataI = getAlignedPixelData({
+      sharedImageOrientationPatient,
+      PerFrameFunctionalGroups,
+      pixelDataChunks,
+      sequenceIndex: PerFrameFunctionalGroupsIndex,
+      sliceLength,
+      Rows,
+      Columns,
+      validOrientations,
+      tolerance
+    });
+    checkImageDimensions({
+      metadataProvider,
+      Rows,
+      Columns,
+      imageId: referencedImageId
+    });
+    const indexCache = [];
+    const segmentationDataForImageId = alignedPixelDataI.data.map((pixel, pixelIndex) => {
+      const pixelValue = pixel ? segmentIndex : 0;
+      if (pixelValue) {
+        indexCache.push(pixelIndex);
+      }
+      return pixel ? segmentIndex : 0;
+    });
+    const hasWrittenSegmentationData = indexCache.length > 0;
+    if (hasWrittenSegmentationData) {
+      segmentData[currentLabelMapImageIndex] = segmentationDataForImageId;
+    }
+    const imageIdIndex = imageIdMaps.indices[referencedImageId];
+    updateSegmentsOnFrame({
+      imageIdIndex,
+      segmentIndex,
+      segmentsOnFrame
+    });
+    updateSegmentsPixelIndices({
+      imageIdIndex,
+      segmentIndex,
+      segmentsPixelIndices,
+      indexCache
+    });
+  }
+  return segmentData;
+};
 
-export { createLabelmapsFromBufferInternal, insertPixelDataPlanar };
+export { createLabelmapsFromBufferInternal, insertOverlappingPixelDataPlanar, insertPixelDataPlanar };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cornerstonejs/adapters",
-    "version": "3.3.3",
+    "version": "3.4.0",
     "description": "Adapters for Cornerstone3D to/from formats including DICOM SR and others",
     "module": "./dist/esm/index.js",
     "types": "./dist/esm/index.d.ts",
@@ -84,8 +84,8 @@
         "ndarray": "^1.0.19"
     },
     "peerDependencies": {
-        "@cornerstonejs/core": "^3.3.3",
-        "@cornerstonejs/tools": "^3.3.3"
+        "@cornerstonejs/core": "^3.4.0",
+        "@cornerstonejs/tools": "^3.4.0"
     },
-    "gitHead": "66f7ef454b3e787528c463f05a568d4d19f4cfc2"
+    "gitHead": "822b0c3f30dc9d1d9a5e638f099ce463c689ee14"
 }