@cornerstonejs/adapters 2.11.7 → 2.12.1

package/dist/esm/adapters/Cornerstone/Segmentation_4X.d.ts

@@ -1,3 +1,48 @@
+export function generateSegmentation(images: object[], inputLabelmaps3D: any | any[], userOptions?: any): Blob;
+export function fillSegmentation(segmentation: any, inputLabelmaps3D: any, userOptions?: {}): object;
+export function _getLabelmapsFromReferencedFrameIndicies(labelmap3D: any, referencedFrameIndicies: any): any[];
+export function _createSegFromImages(images: any[], isMultiframe: boolean, options: any): any;
+export function generateToolState(referencedImageIds: string[], arrayBuffer: ArrayBuffer, metadataProvider: any, options: obj): [];
+export function findReferenceSourceImageId(multiframe: any, frameSegment: Int, imageIds: string[], metadataProvider: any, tolerance: Float, sopUIDImageIdIndexMap: any): string;
+export function checkSEGsOverlapping(pixelData: any, multiframe: any, imageIds: any, validOrientations: any, metadataProvider: any, tolerance: any, TypedArrayConstructor: any, sopUIDImageIdIndexMap: any): boolean;
+export function insertOverlappingPixelDataPlanar(segmentsOnFrame: any, segmentsOnFrameArray: any, labelmapBufferArray: any, pixelData: any, multiframe: any, imageIds: any, validOrientations: any, metadataProvider: any, tolerance: any, TypedArrayConstructor: any, segmentsPixelIndices: any, sopUIDImageIdIndexMap: any): void;
+export function insertPixelDataPlanar(segmentsOnFrame: any, segmentsOnFrameArray: any, labelmapBufferArray: any, pixelData: any, multiframe: any, imageIds: any, validOrientations: any, metadataProvider: any, tolerance: any, TypedArrayConstructor: any, segmentsPixelIndices: any, sopUIDImageIdIndexMap: any, imageIdMaps: any, eventTarget: any, triggerEvent: any): Promise<any>;
+export function unpackPixelData(multiframe: any, options: any): Uint8Array;
+export function getUnpackedChunks(data: any, maxBytesPerChunk: any): any[];
+export function getImageIdOfSourceImageBySourceImageSequence(SourceImageSequence: any, sopUIDImageIdIndexMap: any): string;
+export function getImageIdOfSourceImagebyGeometry(ReferencedSeriesInstanceUID: string, FrameOfReferenceUID: string, PerFrameFunctionalGroup: any, imageIds: string[], metadataProvider: any, tolerance: Float): string;
+export function getImageIdOfReferencedFrame(sopInstanceUid: string, frameNumber: number, sopUIDImageIdIndexMap: any): string;
+export function getValidOrientations(iop: any): any;
+export function alignPixelDataWithSourceData(pixelData2D: Ndarray, iop: any, orientations: any, tolerance: any): Ndarray;
+export function getSegmentMetadata(multiframe: any, seriesInstanceUid: any): {
+    seriesInstanceUid: any;
+    data: any[];
+};
+export function readFromUnpackedChunks(chunks: ArrayBuffer[], offset: number, length: number): Uint8Array;
+export function getUnpackedOffsetAndLength(chunks: any, offset: any, length: any): {
+    start: {
+        chunkIndex: number;
+        offset: any;
+    };
+    end: {
+        chunkIndex: number;
+        offset: any;
+    };
+};
+export function calculateCentroid(imageIdIndexBufferIndex: any, multiframe: any, metadataProvider: any, imageIds: any): {
+    image: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    world: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    count: number;
+};
+export function getSegmentIndex(multiframe: any, frame: any): any;
 export default Segmentation;
 export type BrushData = {
     toolState: any;
@@ -8,6 +53,3 @@ declare namespace Segmentation {
     export { generateToolState };
     export { fillSegmentation };
 }
-export function fillSegmentation(segmentation: any, inputLabelmaps3D: any, userOptions?: {}): object;
-export function generateSegmentation(images: object[], inputLabelmaps3D: any | any[], userOptions?: any): Blob;
-export function generateToolState(referencedImageIds: string[], arrayBuffer: ArrayBuffer, metadataProvider: any, options: obj): [];

package/dist/esm/adapters/Cornerstone/Segmentation_4X.js

@@ -180,7 +180,9 @@ function _createSegFromImages(images, isMultiframe, options) {
  */
 function generateToolState(_x, _x2, _x3, _x4) {
   return _generateToolState.apply(this, arguments);
-} // function insertPixelDataPerpendicular(
+}
+
+// function insertPixelDataPerpendicular(
 //     segmentsOnFrame,
 //     labelmapBuffer,
 //     pixelData,
@@ -195,23 +197,30 @@ function generateToolState(_x, _x2, _x3, _x4) {
 //         Rows,
 //         Columns
 //     } = multiframe;
+
 //     const firstImagePlaneModule = metadataProvider.get(
 //         "imagePlaneModule",
 //         imageIds[0]
 //     );
+
 //     const lastImagePlaneModule = metadataProvider.get(
 //         "imagePlaneModule",
 //         imageIds[imageIds.length - 1]
 //     );
+
 //     console.log(firstImagePlaneModule);
 //     console.log(lastImagePlaneModule);
+
 //     const corners = [
 //         ...getCorners(firstImagePlaneModule),
 //         ...getCorners(lastImagePlaneModule)
 //     ];
+
 //     console.log(`corners:`);
 //     console.log(corners);
+
 //     const indexToWorld = mat4.create();
+
 //     const ippFirstFrame = firstImagePlaneModule.imagePositionPatient;
 //     const rowCosines = Array.isArray(firstImagePlaneModule.rowCosines)
 //         ? [...firstImagePlaneModule.rowCosines]
@@ -220,6 +229,7 @@ function generateToolState(_x, _x2, _x3, _x4) {
 //               firstImagePlaneModule.rowCosines.y,
 //               firstImagePlaneModule.rowCosines.z
 //           ];
+
 //     const columnCosines = Array.isArray(firstImagePlaneModule.columnCosines)
 //         ? [...firstImagePlaneModule.columnCosines]
 //         : [
@@ -227,7 +237,9 @@ function generateToolState(_x, _x2, _x3, _x4) {
 //               firstImagePlaneModule.columnCosines.y,
 //               firstImagePlaneModule.columnCosines.z
 //           ];
+
 //     const { pixelSpacing } = firstImagePlaneModule;
+
 //     mat4.set(
 //         indexToWorld,
 //         // Column 1
@@ -251,36 +263,50 @@ function generateToolState(_x, _x2, _x3, _x4) {
 //         0,
 //         1
 //     );
+
 //     // TODO -> Get origin and (x,y,z) increments to build a translation matrix:
 //     // TODO -> Equation C.7.6.2.1-1
+
 //     // | cx*di rx* Xx 0 |  |x|
 //     // | cy*di ry Xy 0 |  |y|
 //     // | cz*di rz Xz 0 |  |z|
 //     // | tx ty tz 1 |  |1|
+
 //     // const [
 //     //     0, 0 , 0 , 0,
 //     //     0, 0 , 0 , 0,
 //     //     0, 0 , 0 , 0,
 //     //     ipp[0], ipp[1] , ipp[2] , 1,
 //     // ]
+
 //     // Each frame:
+
 //     // Find which corner the first voxel lines up with (one of 8 corners.)
+
 //     // Find how i,j,k orient with respect to source volume.
 //     // Go through each frame, find location in source to start, and whether to increment +/ix,+/-y,+/-z
 //     //   through each voxel.
+
 //     // [1,0,0,0,1,0]
+
 //     // const [
+
 //     // ]
+
 //     // Invert transformation matrix to get worldToIndex
+
 //     // Apply world to index on each point to fill up the matrix.
+
 //     // const sharedImageOrientationPatient = SharedFunctionalGroupsSequence.PlaneOrientationSequence
 //     //     ? SharedFunctionalGroupsSequence.PlaneOrientationSequence
 //     //           .ImageOrientationPatient
 //     //     : undefined;
 //     // const sliceLength = Columns * Rows;
 // }
+
 // function getCorners(imagePlaneModule) {
 //     // console.log(imagePlaneModule);
+
 //     const {
 //         rows,
 //         columns,
@@ -290,18 +316,22 @@ function generateToolState(_x, _x2, _x3, _x4) {
 //         rowPixelSpacing,
 //         columnPixelSpacing
 //     } = imagePlaneModule;
+
 //     const rowLength = columns * columnPixelSpacing;
 //     const columnLength = rows * rowPixelSpacing;
+
 //     const entireRowVector = [
 //         rowLength * columnCosines[0],
 //         rowLength * columnCosines[1],
 //         rowLength * columnCosines[2]
 //     ];
+
 //     const entireColumnVector = [
 //         columnLength * rowCosines[0],
 //         columnLength * rowCosines[1],
 //         columnLength * rowCosines[2]
 //     ];
+
 //     const topLeft = [ipp[0], ipp[1], ipp[2]];
 //     const topRight = [
 //         topLeft[0] + entireRowVector[0],
@@ -313,13 +343,16 @@ function generateToolState(_x, _x2, _x3, _x4) {
 //         topLeft[1] + entireColumnVector[1],
 //         topLeft[2] + entireColumnVector[2]
 //     ];
+
 //     const bottomRight = [
 //         bottomLeft[0] + entireRowVector[0],
 //         bottomLeft[1] + entireRowVector[1],
 //         bottomLeft[2] + entireRowVector[2]
 //     ];
+
 //     return [topLeft, topRight, bottomLeft, bottomRight];
 // }
+
 /**
  * Find the reference frame of the segmentation frame in the source data.
  *
@@ -1149,4 +1182,4 @@ var Segmentation = {
   fillSegmentation: fillSegmentation
 };
 
-export { Segmentation as default, fillSegmentation, generateSegmentation, generateToolState };
+export { _createSegFromImages, _getLabelmapsFromReferencedFrameIndicies, alignPixelDataWithSourceData, calculateCentroid, checkSEGsOverlapping, Segmentation as default, fillSegmentation, findReferenceSourceImageId, generateSegmentation, generateToolState, getImageIdOfReferencedFrame, getImageIdOfSourceImageBySourceImageSequence, getImageIdOfSourceImagebyGeometry, getSegmentIndex, getSegmentMetadata, getUnpackedChunks, getUnpackedOffsetAndLength, getValidOrientations, insertOverlappingPixelDataPlanar, insertPixelDataPlanar, readFromUnpackedChunks, unpackPixelData };

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

@@ -1,2 +1,17 @@
-declare function generateToolState(imageIds: any, arrayBuffer: any, metadataProvider: any, skipOverlapping?: boolean, tolerance?: number): any;
-export { generateToolState };
+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 }: {
+    metadataProvider: any;
+    skipOverlapping?: boolean;
+    tolerance?: number;
+}): Promise<{
+    labelMapImages: any[][];
+    segMetadata: {
+        seriesInstanceUid: any;
+        data: any[];
+    };
+    segmentsOnFrame: any[];
+    segmentsOnFrameArray: any[];
+    centroids: Map<any, any>;
+    overlappingSegments: any;
+}>;
+export { generateToolState, createFromDICOMSegBuffer };

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

@@ -1,9 +1,22 @@
 import { generateToolState as generateToolState$1 } from '../../Cornerstone/Segmentation.js';
+import { createLabelmapsFromBufferInternal } from './labelmapImagesFromBuffer.js';
 
 function generateToolState(imageIds, arrayBuffer, metadataProvider) {
   var skipOverlapping = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
   var tolerance = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1e-3;
-  return generateToolState$1(imageIds, arrayBuffer, metadataProvider, skipOverlapping, tolerance);
+  var cs3dVersion = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 4;
+  return generateToolState$1(imageIds, arrayBuffer, metadataProvider, skipOverlapping, tolerance, cs3dVersion);
+}
+function createFromDICOMSegBuffer(referencedImageIds, arrayBuffer, _ref) {
+  var metadataProvider = _ref.metadataProvider,
+    _ref$skipOverlapping = _ref.skipOverlapping,
+    skipOverlapping = _ref$skipOverlapping === void 0 ? false : _ref$skipOverlapping,
+    _ref$tolerance = _ref.tolerance,
+    tolerance = _ref$tolerance === void 0 ? 1e-3 : _ref$tolerance;
+  return createLabelmapsFromBufferInternal(referencedImageIds, arrayBuffer, metadataProvider, {
+    skipOverlapping: skipOverlapping,
+    tolerance: tolerance
+  });
 }
 
-export { generateToolState };
+export { createFromDICOMSegBuffer, generateToolState };

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

@@ -1,4 +1,4 @@
 import { generateSegmentation } from "./generateSegmentation";
 import { generateLabelMaps2DFrom3D } from "./generateLabelMaps2DFrom3D";
-import { generateToolState } from "./generateToolState";
-export { generateLabelMaps2DFrom3D, generateSegmentation, generateToolState };
+import { generateToolState, createFromDICOMSegBuffer } from "./generateToolState";
+export { generateLabelMaps2DFrom3D, generateSegmentation, generateToolState, createFromDICOMSegBuffer };

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

@@ -1,3 +1,3 @@
 export { generateSegmentation } from './generateSegmentation.js';
 export { generateLabelMaps2DFrom3D } from './generateLabelMaps2DFrom3D.js';
-export { generateToolState } from './generateToolState.js';
+export { createFromDICOMSegBuffer, generateToolState } from './generateToolState.js';

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

@@ -0,0 +1,13 @@
+declare function createLabelmapsFromBufferInternal(referencedImageIds: any, arrayBuffer: any, metadataProvider: any, options: any): Promise<{
+    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 { createLabelmapsFromBufferInternal };

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

@@ -0,0 +1,198 @@
+import { asyncToGenerator as _asyncToGenerator, regeneratorRuntime as _regeneratorRuntime, toConsumableArray as _toConsumableArray } from '../../../_virtual/_rollupPluginBabelHelpers.js';
+import { imageLoader } from '@cornerstonejs/core';
+import { data, normalizers, utilities } from 'dcmjs';
+import ndarray from 'ndarray';
+import checkOrientation from '../../helpers/checkOrientation.js';
+import { calculateCentroid, checkSEGsOverlapping, unpackPixelData, getValidOrientations, getSegmentMetadata, readFromUnpackedChunks, alignPixelDataWithSourceData, getSegmentIndex, findReferenceSourceImageId } from '../../Cornerstone/Segmentation_4X.js';
+
+var DicomMessage = data.DicomMessage,
+  DicomMetaDictionary = data.DicomMetaDictionary;
+var Normalizer = normalizers.Normalizer;
+var decode = utilities.compression.decode;
+function createLabelmapsFromBufferInternal(_x, _x2, _x3, _x4) {
+  return _createLabelmapsFromBufferInternal.apply(this, arguments);
+}
+function _createLabelmapsFromBufferInternal() {
+  _createLabelmapsFromBufferInternal = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(referencedImageIds, arrayBuffer, metadataProvider, options) {
+    var _options$skipOverlapp, skipOverlapping, _options$tolerance, tolerance, _options$TypedArrayCo, TypedArrayConstructor, _options$maxBytesPerC, maxBytesPerChunk, dicomData, dataset, multiframe, imagePlaneModule, generalSeriesModule, SeriesInstanceUID, ImageOrientationPatient, validOrientations, segMetadata, TransferSyntaxUID, pixelData, pixelDataChunks, rleEncodedFrames, orientation, sopUIDImageIdIndexMap, overlapping, insertFunction, segmentsOnFrameArray, segmentsOnFrame, imageIdMaps, labelMapImages, i, referenceImageId, labelMapImage, segmentsPixelIndices, overlappingSegments, centroidXYZ;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _options$skipOverlapp = options.skipOverlapping, skipOverlapping = _options$skipOverlapp === void 0 ? false : _options$skipOverlapp, _options$tolerance = options.tolerance, tolerance = _options$tolerance === void 0 ? 1e-3 : _options$tolerance, _options$TypedArrayCo = options.TypedArrayConstructor, TypedArrayConstructor = _options$TypedArrayCo === void 0 ? Uint8Array : _options$TypedArrayCo, _options$maxBytesPerC = options.maxBytesPerChunk, maxBytesPerChunk = _options$maxBytesPerC === void 0 ? 199000000 : _options$maxBytesPerC;
+          dicomData = DicomMessage.readFile(arrayBuffer);
+          dataset = DicomMetaDictionary.naturalizeDataset(dicomData.dict);
+          dataset._meta = DicomMetaDictionary.namifyDataset(dicomData.meta);
+          multiframe = Normalizer.normalizeToDataset([dataset]);
+          imagePlaneModule = metadataProvider.get("imagePlaneModule", referencedImageIds[0]);
+          generalSeriesModule = metadataProvider.get("generalSeriesModule", referencedImageIds[0]);
+          SeriesInstanceUID = generalSeriesModule.seriesInstanceUID;
+          if (!imagePlaneModule) {
+            console.warn("Insufficient metadata, imagePlaneModule missing.");
+          }
+          ImageOrientationPatient = Array.isArray(imagePlaneModule.rowCosines) ? [].concat(_toConsumableArray(imagePlaneModule.rowCosines), _toConsumableArray(imagePlaneModule.columnCosines)) : [imagePlaneModule.rowCosines.x, imagePlaneModule.rowCosines.y, imagePlaneModule.rowCosines.z, imagePlaneModule.columnCosines.x, imagePlaneModule.columnCosines.y, imagePlaneModule.columnCosines.z];
+          validOrientations = getValidOrientations(ImageOrientationPatient);
+          segMetadata = getSegmentMetadata(multiframe, SeriesInstanceUID);
+          TransferSyntaxUID = multiframe._meta.TransferSyntaxUID.Value[0];
+          if (!(TransferSyntaxUID === "1.2.840.10008.1.2.5")) {
+            _context.next = 22;
+            break;
+          }
+          rleEncodedFrames = Array.isArray(multiframe.PixelData) ? multiframe.PixelData : [multiframe.PixelData];
+          pixelData = decode(rleEncodedFrames, multiframe.Rows, multiframe.Columns);
+          if (!(multiframe.BitsStored === 1)) {
+            _context.next = 19;
+            break;
+          }
+          console.warn("No implementation for rle + bit packing.");
+          return _context.abrupt("return");
+        case 19:
+          pixelDataChunks = [pixelData];
+          _context.next = 25;
+          break;
+        case 22:
+          pixelDataChunks = unpackPixelData(multiframe, {
+            maxBytesPerChunk: maxBytesPerChunk
+          });
+          if (pixelDataChunks) {
+            _context.next = 25;
+            break;
+          }
+          throw new Error("Fractional segmentations are not yet supported");
+        case 25:
+          orientation = checkOrientation(multiframe, validOrientations, [imagePlaneModule.rows, imagePlaneModule.columns, referencedImageIds.length], tolerance);
+          sopUIDImageIdIndexMap = referencedImageIds.reduce(function (acc, imageId) {
+            var _metadataProvider$get = metadataProvider.get("generalImageModule", imageId),
+              sopInstanceUID = _metadataProvider$get.sopInstanceUID;
+            acc[sopInstanceUID] = imageId;
+            return acc;
+          }, {});
+          overlapping = false;
+          if (!skipOverlapping) {
+            overlapping = checkSEGsOverlapping(pixelDataChunks, multiframe, referencedImageIds, validOrientations, metadataProvider, tolerance, TypedArrayConstructor, sopUIDImageIdIndexMap);
+          }
+          _context.t0 = orientation;
+          _context.next = _context.t0 === "Planar" ? 32 : _context.t0 === "Perpendicular" ? 38 : _context.t0 === "Oblique" ? 39 : 40;
+          break;
+        case 32:
+          if (!overlapping) {
+            _context.next = 36;
+            break;
+          }
+          throw new Error("Overlapping segmentations are not yet supported.");
+        case 36:
+          insertFunction = insertPixelDataPlanar;
+        case 37:
+          return _context.abrupt("break", 40);
+        case 38:
+          throw new Error("Segmentations orthogonal to the acquisition plane of the source data are not yet supported.");
+        case 39:
+          throw new Error("Segmentations oblique to the acquisition plane of the source data are not yet supported.");
+        case 40:
+          segmentsOnFrameArray = [];
+          segmentsOnFrameArray[0] = [];
+          segmentsOnFrame = [];
+          imageIdMaps = {
+            indices: {},
+            metadata: {}
+          };
+          labelMapImages = [];
+          for (i = 0; i < referencedImageIds.length; i++) {
+            referenceImageId = referencedImageIds[i];
+            imageIdMaps.indices[referenceImageId] = i;
+            imageIdMaps.metadata[referenceImageId] = metadataProvider.get("instance", referenceImageId);
+            labelMapImage = imageLoader.createAndCacheDerivedLabelmapImage(referenceImageId);
+            labelMapImages.push(labelMapImage);
+          }
+          segmentsPixelIndices = new Map();
+          _context.next = 49;
+          return insertFunction(segmentsOnFrame, labelMapImages, pixelDataChunks, multiframe, referencedImageIds, validOrientations, metadataProvider, tolerance, segmentsPixelIndices, sopUIDImageIdIndexMap, imageIdMaps);
+        case 49:
+          overlappingSegments = _context.sent;
+          centroidXYZ = new Map();
+          segmentsPixelIndices.forEach(function (imageIdIndexBufferIndex, segmentIndex) {
+            var centroids = calculateCentroid(imageIdIndexBufferIndex, multiframe, metadataProvider, referencedImageIds);
+            centroidXYZ.set(segmentIndex, centroids);
+          });
+          return _context.abrupt("return", {
+            labelMapImages: [labelMapImages],
+            segMetadata: segMetadata,
+            segmentsOnFrame: segmentsOnFrame,
+            segmentsOnFrameArray: segmentsOnFrameArray,
+            centroids: centroidXYZ,
+            overlappingSegments: overlappingSegments
+          });
+        case 53:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return _createLabelmapsFromBufferInternal.apply(this, arguments);
+}
+function insertPixelDataPlanar(segmentsOnFrame, labelMapImages, pixelData, multiframe, imageIds, validOrientations, metadataProvider, tolerance, segmentsPixelIndices, sopUIDImageIdIndexMap, imageIdMaps) {
+  var SharedFunctionalGroupsSequence = multiframe.SharedFunctionalGroupsSequence,
+    PerFrameFunctionalGroupsSequence = multiframe.PerFrameFunctionalGroupsSequence,
+    Rows = multiframe.Rows,
+    Columns = multiframe.Columns;
+  var sharedImageOrientationPatient = SharedFunctionalGroupsSequence.PlaneOrientationSequence ? SharedFunctionalGroupsSequence.PlaneOrientationSequence.ImageOrientationPatient : undefined;
+  var sliceLength = Columns * Rows;
+  var groupsLen = PerFrameFunctionalGroupsSequence.length;
+  var overlapping = false;
+  return new Promise(function (resolve) {
+    for (var i = 0; i < groupsLen; ++i) {
+      var PerFrameFunctionalGroups = PerFrameFunctionalGroupsSequence[i];
+      var ImageOrientationPatientI = sharedImageOrientationPatient || PerFrameFunctionalGroups.PlaneOrientationSequence.ImageOrientationPatient;
+      var view = readFromUnpackedChunks(pixelData, i * sliceLength, sliceLength);
+      var pixelDataI2D = ndarray(view, [Rows, Columns]);
+      var 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.");
+      }
+      var segmentIndex = getSegmentIndex(multiframe, i);
+      if (segmentIndex === undefined) {
+        throw new Error("Could not retrieve the segment index. Aborting segmentation loading.");
+      }
+      if (!segmentsPixelIndices.has(segmentIndex)) {
+        segmentsPixelIndices.set(segmentIndex, {});
+      }
+      var imageId = findReferenceSourceImageId(multiframe, i, imageIds, metadataProvider, tolerance, sopUIDImageIdIndexMap);
+      if (!imageId) {
+        console.warn("Image not present in stack, can't import frame : " + i + ".");
+        continue;
+      }
+      var sourceImageMetadata = imageIdMaps.metadata[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. ");
+      }
+      var imageIdIndex = imageIdMaps.indices[imageId];
+      var labelmapImage = labelMapImages[imageIdIndex];
+      var labelmap2DView = labelmapImage.getPixelData();
+      var data = alignedPixelDataI.data;
+      var indexCache = [];
+      for (var j = 0, len = alignedPixelDataI.data.length; j < len; ++j) {
+        if (data[j]) {
+          for (var x = j; x < len; ++x) {
+            if (data[x]) {
+              if (!overlapping && labelmap2DView[x] !== 0) {
+                overlapping = true;
+              }
+              labelmap2DView[x] = segmentIndex;
+              indexCache.push(x);
+            }
+          }
+          if (!segmentsOnFrame[imageIdIndex]) {
+            segmentsOnFrame[imageIdIndex] = [];
+          }
+          segmentsOnFrame[imageIdIndex].push(segmentIndex);
+          break;
+        }
+      }
+      var segmentIndexObject = segmentsPixelIndices.get(segmentIndex);
+      segmentIndexObject[imageIdIndex] = indexCache;
+      segmentsPixelIndices.set(segmentIndex, segmentIndexObject);
+    }
+    resolve(overlapping);
+  });
+}
+
+export { createLabelmapsFromBufferInternal, insertPixelDataPlanar };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cornerstonejs/adapters",
-    "version": "2.11.7",
+    "version": "2.12.1",
     "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": "^2.11.7",
-        "@cornerstonejs/tools": "^2.11.7"
+        "@cornerstonejs/core": "^2.12.1",
+        "@cornerstonejs/tools": "^2.12.1"
     },
-    "gitHead": "a70a7d7c02057c5758bb8cb0957d757e4c445f80"
+    "gitHead": "0bb31a1b9c61111d2d94c100d8b5d4c699182c42"
 }