@cornerstonejs/adapters 5.4.10 → 5.4.12

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

@@ -1,5 +1,5 @@
 export function generateSegmentation(images: object[], inputLabelmaps3D: any | any[], userOptions?: any): Blob;
-export function fillSegmentation(segmentation: any, inputLabelmaps3D: any, userOptions?: {}): object;
+export function fillSegmentation(segmentation: any, inputLabelmaps3D: any, userOptions?: {}, images?: any[], metadata?: any): 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): [];
@@ -18,7 +18,7 @@ export function getSegmentMetadata(multiframe: any, seriesInstanceUid: any): {
     seriesInstanceUid: any;
     data: any[];
 };
-export function readFromUnpackedChunks(chunks: ArrayBuffer[], offset: number, length: number): Uint8Array;
+export function readFromUnpackedChunks(chunks: Uint8Array[] | Uint16Array[], offset: number, length: number): Uint8Array | Uint16Array;
 export function getUnpackedOffsetAndLength(chunks: any, offset: any, length: any): {
     start: {
         chunkIndex: number;

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

@@ -4,6 +4,8 @@ import ndarray from 'ndarray';
 import getDatasetsFromImages from '../helpers/getDatasetsFromImages.js';
 import checkOrientation from '../helpers/checkOrientation.js';
 import { utilities as utilities$1 } from '@cornerstonejs/core';
+import { getReferencedSourceImageSequenceItem, applyPerFrameFunctionalGroups } from '../Cornerstone3D/Segmentation/perFrameFunctionalGroups.js';
+import { getBitmapFramesFromDataset, encodeFramesToTransferSyntax, RLE_LOSSLESS_TRANSFER_SYNTAX_UID as RLE_LOSSLESS_TRANSFER_SYNTAX_UID$1 } from '../Cornerstone3D/encodePixelData.js';
 import { Events } from '../enums/Events.js';
 
 const _utilities$orientatio = utilities.orientation,
@@ -19,6 +21,8 @@ const SegmentationDerivation = derivations.Segmentation;
 const _utilities$compressio = utilities.compression,
   encode = _utilities$compressio.encode,
   decode = _utilities$compressio.decode;
+const RLE_LOSSLESS_TRANSFER_SYNTAX_UID = '1.2.840.10008.1.2.5';
+const EXPLICIT_VR_LITTLE_ENDIAN_TRANSFER_SYNTAX_UID = '1.2.840.10008.1.2.1';
 
 /**
  *
@@ -29,7 +33,7 @@ const _utilities$compressio = utilities.compression,
  */
 const generateSegmentationDefaultOptions = {
   includeSliceSpacing: true,
-  rleEncode: false
+  transferSyntaxUid: RLE_LOSSLESS_TRANSFER_SYNTAX_UID
 };
 
 /**
@@ -49,89 +53,200 @@ function generateSegmentation(images, inputLabelmaps3D) {
   return fillSegmentation(segmentation, inputLabelmaps3D, userOptions);
 }
 
+/**
+ * The set of non-zero segment values actually present in a frame's pixel data,
+ * collected in a single pass. `segmentsOnLabelmap` can be stale, so presence is
+ * verified against the pixels — but once per frame, not with one full-frame
+ * scan per listed segment.
+ */
+function segmentsPresentInFrame(pixelData) {
+  const presentSegments = new Set();
+  if (!pixelData) {
+    return presentSegments;
+  }
+  for (let i = 0; i < pixelData.length; i++) {
+    const value = pixelData[i];
+    if (value !== 0) {
+      presentSegments.add(value);
+    }
+  }
+  return presentSegments;
+}
+
 /**
  * Fills a given segmentation object with data from the input labelmaps3D
  *
  * @param segmentation - The segmentation object to be filled.
  * @param inputLabelmaps3D - An array of 3D labelmaps, or a single 3D labelmap.
  * @param userOptions - Optional configuration settings. Will override the default options.
+ *   - `transferSyntaxUid` — the output transfer syntax. Defaults to RLE Lossless
+ *     (`1.2.840.10008.1.2.5`); Explicit VR Little Endian
+ *     (`1.2.840.10008.1.2.1`) is also supported. Any other value throws.
+ *   - `rleEncode` — **obsolete / ignored.** This option is no longer read. It
+ *     never worked correctly in prior versions (the old path did not produce a
+ *     valid RLE-encoded SEG), so it has been dropped rather than fixed. RLE
+ *     output is now selected via `transferSyntaxUid` (RLE Lossless is the
+ *     default), and encoding is handled by `encodeFramesToTransferSyntax`.
  *
  * @returns {object} The filled segmentation object.
  */
 function fillSegmentation(segmentation, inputLabelmaps3D) {
+  var _ref, _options$transferSynt;
   let userOptions = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  let images = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
+  let metadata = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;
   const options = Object.assign({}, generateSegmentationDefaultOptions, userOptions);
 
   // Use another variable so we don't redefine labelmaps3D.
   const labelmaps3D = Array.isArray(inputLabelmaps3D) ? inputLabelmaps3D : [inputLabelmaps3D];
-  let numberOfFrames = 0;
   const referencedFramesPerLabelmap = [];
+  const frameDescriptors = [];
   for (let labelmapIndex = 0; labelmapIndex < labelmaps3D.length; labelmapIndex++) {
     const labelmap3D = labelmaps3D[labelmapIndex];
     const labelmaps2D = labelmap3D.labelmaps2D,
-      metadata = labelmap3D.metadata;
+      segmentMetadata = labelmap3D.metadata;
     const referencedFramesPerSegment = [];
-    for (let i = 1; i < metadata.length; i++) {
-      if (metadata[i]) {
+    for (let i = 1; i < segmentMetadata.length; i++) {
+      if (segmentMetadata[i]) {
         referencedFramesPerSegment[i] = [];
       }
     }
     for (let i = 0; i < labelmaps2D.length; i++) {
       const labelmap2D = labelmaps2D[i];
-      if (labelmaps2D[i]) {
-        const segmentsOnLabelmap = labelmap2D.segmentsOnLabelmap;
-        segmentsOnLabelmap.forEach(segmentIndex => {
-          if (segmentIndex !== 0) {
-            referencedFramesPerSegment[segmentIndex].push(i);
-            numberOfFrames++;
-          }
-        });
+      if (!(labelmap2D !== null && labelmap2D !== void 0 && labelmap2D.pixelData)) {
+        continue;
       }
+      const segmentsOnLabelmap = labelmap2D.segmentsOnLabelmap;
+      const presentSegments = segmentsPresentInFrame(labelmap2D.pixelData);
+      segmentsOnLabelmap.forEach(segmentIndex => {
+        if (segmentIndex !== 0 && segmentMetadata[segmentIndex] && referencedFramesPerSegment[segmentIndex] && presentSegments.has(segmentIndex)) {
+          referencedFramesPerSegment[segmentIndex].push(i);
+        }
+      });
     }
     referencedFramesPerLabelmap[labelmapIndex] = referencedFramesPerSegment;
   }
+  let numberOfFrames = 0;
+  for (let labelmapIndex = 0; labelmapIndex < labelmaps3D.length; labelmapIndex++) {
+    const referencedFramesPerSegment = referencedFramesPerLabelmap[labelmapIndex];
+    const labelmap3D = labelmaps3D[labelmapIndex];
+    const segmentMetadata = labelmap3D.metadata;
+    for (let segmentIndex = 1; segmentIndex < referencedFramesPerSegment.length; segmentIndex++) {
+      const referencedFrameIndicies = referencedFramesPerSegment[segmentIndex];
+      if (!(referencedFrameIndicies !== null && referencedFrameIndicies !== void 0 && referencedFrameIndicies.length) || !segmentMetadata[segmentIndex]) {
+        continue;
+      }
+      const labelmaps = _getLabelmapsFromReferencedFrameIndicies(labelmap3D, referencedFrameIndicies);
+      if (!labelmaps.length || !labelmaps.some(frame => (frame === null || frame === void 0 ? void 0 : frame.length) && frame.some(v => v !== 0))) {
+        continue;
+      }
+      numberOfFrames += referencedFrameIndicies.length;
+    }
+  }
+  if (numberOfFrames === 0) {
+    throw new Error('No non-empty segmentation frames found for SEG export');
+  }
   segmentation.setNumberOfFrames(numberOfFrames);
   for (let labelmapIndex = 0; labelmapIndex < labelmaps3D.length; labelmapIndex++) {
     const referencedFramesPerSegment = referencedFramesPerLabelmap[labelmapIndex];
     const labelmap3D = labelmaps3D[labelmapIndex];
-    const metadata = labelmap3D.metadata;
+    const segmentMetadata = labelmap3D.metadata;
     for (let segmentIndex = 1; segmentIndex < referencedFramesPerSegment.length; segmentIndex++) {
       const referencedFrameIndicies = referencedFramesPerSegment[segmentIndex];
-      if (referencedFrameIndicies) {
-        // Frame numbers start from 1.
-        const referencedFrameNumbers = referencedFrameIndicies.map(element => {
-          return element + 1;
-        });
-        const segmentMetadata = metadata[segmentIndex];
-        const labelmaps = _getLabelmapsFromReferencedFrameIndicies(labelmap3D, referencedFrameIndicies);
-        segmentation.addSegmentFromLabelmap(segmentMetadata, labelmaps, segmentIndex, referencedFrameNumbers);
+      if (!(referencedFrameIndicies !== null && referencedFrameIndicies !== void 0 && referencedFrameIndicies.length) || !segmentMetadata[segmentIndex]) {
+        continue;
       }
+      const labelmaps = _getLabelmapsFromReferencedFrameIndicies(labelmap3D, referencedFrameIndicies);
+      if (!labelmaps.length || !labelmaps.some(frame => (frame === null || frame === void 0 ? void 0 : frame.length) && frame.some(v => v !== 0))) {
+        continue;
+      }
+
+      // Frame numbers start from 1.
+      const referencedFrameNumbers = referencedFrameIndicies.map(element => element + 1);
+      referencedFrameNumbers.forEach(frameNumber => {
+        frameDescriptors.push({
+          referencedSegmentNumber: segmentIndex,
+          sourceFrameIndex: frameNumber - 1
+        });
+      });
+      segmentation.addSegmentFromLabelmap(segmentMetadata[segmentIndex], labelmaps, segmentIndex, referencedFrameNumbers);
     }
   }
-  if (options.rleEncode) {
-    const rleEncodedFrames = encode(segmentation.dataset.PixelData, numberOfFrames, segmentation.dataset.Rows, segmentation.dataset.Columns);
-
-    // Must use fractional now to RLE encode, as the DICOM standard only allows BitStored && BitsAllocated
-    // to be 1 for BINARY. This is not ideal and there should be a better format for compression in this manner
-    // added to the standard.
-    segmentation.assignToDataset({
-      BitsAllocated: '8',
-      BitsStored: '8',
-      HighBit: '7',
-      SegmentationType: 'FRACTIONAL',
-      SegmentationFractionalType: 'PROBABILITY',
-      MaximumFractionalValue: '255'
+  if (frameDescriptors.length && images !== null && images !== void 0 && images.length && metadata) {
+    // Every SEG frame must reference a resolvable source SOP Instance UID.
+    // Reject rather than silently dropping frames: a dropped frame would make
+    // the per-frame functional groups disagree with the encoded PixelData and
+    // produce a SEG whose source-image references are unreliable.
+    const perFrameInputs = frameDescriptors.map(desc => {
+      const sourceImageSequenceItem = getReferencedSourceImageSequenceItem(images[desc.sourceFrameIndex], metadata);
+      if (!(sourceImageSequenceItem !== null && sourceImageSequenceItem !== void 0 && sourceImageSequenceItem.ReferencedSOPInstanceUID)) {
+        throw new Error("Cannot resolve a source ReferencedSOPInstanceUID for SEG frame " + "(sourceFrameIndex ".concat(desc.sourceFrameIndex, ", segment ") + "".concat(desc.referencedSegmentNumber, "). Refusing to write a SEG with ") + "unreliable source image references.");
+      }
+      return {
+        referencedSegmentNumber: desc.referencedSegmentNumber,
+        sourceImageSequenceItem
+      };
     });
-    segmentation.dataset._meta.TransferSyntaxUID = {
-      Value: ['1.2.840.10008.1.2.5'],
-      vr: 'UI'
-    };
-    segmentation.dataset.SpecificCharacterSet = 'ISO_IR 192';
-    segmentation.dataset._vrMap.PixelData = 'OB';
-    segmentation.dataset.PixelData = rleEncodedFrames;
-  } else {
-    // If no rleEncoding, at least bitpack the data.
+    applyPerFrameFunctionalGroups(segmentation.dataset, perFrameInputs);
+  }
+  const transferSyntaxUid = (_ref = (_options$transferSynt = options.transferSyntaxUid) !== null && _options$transferSynt !== void 0 ? _options$transferSynt : options.transferSyntaxUID) !== null && _ref !== void 0 ? _ref : RLE_LOSSLESS_TRANSFER_SYNTAX_UID;
+  if (transferSyntaxUid === RLE_LOSSLESS_TRANSFER_SYNTAX_UID) {
+    const isBinaryBitmap = segmentation.dataset.SegmentationType === 'BINARY' && Number(segmentation.dataset.BitsAllocated) === 1;
+    if (isBinaryBitmap) {
+      segmentation.bitPackPixelData();
+      const _getBitmapFramesFromD = getBitmapFramesFromDataset(segmentation.dataset),
+        frames = _getBitmapFramesFromD.frames,
+        bitsAllocated = _getBitmapFramesFromD.bitsAllocated;
+      const _encodeFramesToTransf = encodeFramesToTransferSyntax({
+          transferSyntaxUID: RLE_LOSSLESS_TRANSFER_SYNTAX_UID$1,
+          frames,
+          bitsAllocated,
+          columns: Number(segmentation.dataset.Columns) || undefined
+        }),
+        pixelData = _encodeFramesToTransf.pixelData,
+        pixelDataVR = _encodeFramesToTransf.pixelDataVR;
+      segmentation.dataset.PixelData = pixelData;
+      segmentation.dataset._vrMap.PixelData = pixelDataVR;
+      if (!options.skipTransferSyntaxMeta) {
+        segmentation.dataset._meta.TransferSyntaxUID = {
+          Value: [RLE_LOSSLESS_TRANSFER_SYNTAX_UID],
+          vr: 'UI'
+        };
+      }
+      segmentation.dataset.SpecificCharacterSet = 'ISO_IR 192';
+    } else {
+      const rleEncodedFrames = encode(segmentation.dataset.PixelData, numberOfFrames, segmentation.dataset.Rows, segmentation.dataset.Columns);
+
+      // Fractional/8-bit labelmaps: legacy dcmjs row RLE (not valid for 1-bit packed binary).
+      segmentation.assignToDataset({
+        BitsAllocated: '8',
+        BitsStored: '8',
+        HighBit: '7',
+        SegmentationType: 'FRACTIONAL',
+        SegmentationFractionalType: 'PROBABILITY',
+        MaximumFractionalValue: '255'
+      });
+      if (!options.skipTransferSyntaxMeta) {
+        segmentation.dataset._meta.TransferSyntaxUID = {
+          Value: [RLE_LOSSLESS_TRANSFER_SYNTAX_UID],
+          vr: 'UI'
+        };
+      }
+      segmentation.dataset.SpecificCharacterSet = 'ISO_IR 192';
+      segmentation.dataset._vrMap.PixelData = 'OB';
+      segmentation.dataset.PixelData = rleEncodedFrames;
+    }
+  } else if (transferSyntaxUid === EXPLICIT_VR_LITTLE_ENDIAN_TRANSFER_SYNTAX_UID) {
+    // For explicit VR little endian, at least bitpack the data.
     segmentation.bitPackPixelData();
+    if (!options.skipTransferSyntaxMeta) {
+      segmentation.dataset._meta.TransferSyntaxUID = {
+        Value: [EXPLICIT_VR_LITTLE_ENDIAN_TRANSFER_SYNTAX_UID],
+        vr: 'UI'
+      };
+    }
+  } else {
+    throw new Error("Unsupported SEG transfer syntax: ".concat(transferSyntaxUid, ". ") + "Supported: ".concat(RLE_LOSSLESS_TRANSFER_SYNTAX_UID, ", ").concat(EXPLICIT_VR_LITTLE_ENDIAN_TRANSFER_SYNTAX_UID));
   }
   return segmentation;
 }
@@ -581,9 +696,9 @@ function checkSEGsOverlapping(pixelData, multiframe, imageIds, validOrientations
       frameSegmentsMapping.set(imageIdIndex, [frameSegment]);
     }
   }
-  for (let _ref of frameSegmentsMapping.entries()) {
-    var _ref2 = _slicedToArray(_ref, 2);
-    let role = _ref2[1];
+  for (let _ref2 of frameSegmentsMapping.entries()) {
+    var _ref3 = _slicedToArray(_ref2, 2);
+    let role = _ref3[1];
     let temp2DArray = new TypedArrayConstructor(sliceLength).fill(0);
     for (let i = 0; i < role.length; ++i) {
       const frameSegment = role[i];
@@ -711,11 +826,29 @@ function insertOverlappingPixelDataPlanar(segmentsOnFrame, segmentsOnFrameArray,
     tempSegmentsOnFrame = structuredClone(segmentsOnFrameArray[m]);
   }
 }
+function getReferencedSegmentNumberFromIdentificationSequence(segmentIdentificationSequence) {
+  if (!segmentIdentificationSequence) {
+    return undefined;
+  }
+  const normalized = Array.isArray(segmentIdentificationSequence) ? segmentIdentificationSequence[0] : segmentIdentificationSequence;
+  return normalized === null || normalized === void 0 ? void 0 : normalized.ReferencedSegmentNumber;
+}
+function getSharedFunctionalGroupsSequence(multiframe) {
+  const shared = multiframe === null || multiframe === void 0 ? void 0 : multiframe.SharedFunctionalGroupsSequence;
+  if (Array.isArray(shared)) {
+    return shared.length > 0 ? shared[0] : undefined;
+  }
+  return shared;
+}
 const getSegmentIndex = (multiframe, frame) => {
-  const PerFrameFunctionalGroupsSequence = multiframe.PerFrameFunctionalGroupsSequence,
-    SharedFunctionalGroupsSequence = multiframe.SharedFunctionalGroupsSequence;
-  const PerFrameFunctionalGroups = PerFrameFunctionalGroupsSequence[frame];
-  return PerFrameFunctionalGroups && PerFrameFunctionalGroups.SegmentIdentificationSequence ? PerFrameFunctionalGroups.SegmentIdentificationSequence.ReferencedSegmentNumber : SharedFunctionalGroupsSequence.SegmentIdentificationSequence ? SharedFunctionalGroupsSequence.SegmentIdentificationSequence.ReferencedSegmentNumber : undefined;
+  const PerFrameFunctionalGroupsSequence = multiframe.PerFrameFunctionalGroupsSequence;
+  const PerFrameFunctionalGroups = PerFrameFunctionalGroupsSequence === null || PerFrameFunctionalGroupsSequence === void 0 ? void 0 : PerFrameFunctionalGroupsSequence[frame];
+  const fromPerFrame = getReferencedSegmentNumberFromIdentificationSequence(PerFrameFunctionalGroups === null || PerFrameFunctionalGroups === void 0 ? void 0 : PerFrameFunctionalGroups.SegmentIdentificationSequence);
+  if (fromPerFrame !== undefined) {
+    return fromPerFrame;
+  }
+  const shared = getSharedFunctionalGroupsSequence(multiframe);
+  return getReferencedSegmentNumberFromIdentificationSequence(shared === null || shared === void 0 ? void 0 : shared.SegmentIdentificationSequence);
 };
 function insertPixelDataPlanar(segmentsOnFrame, segmentsOnFrameArray, labelmapBufferArray, pixelData, multiframe, imageIds, validOrientations, metadataProvider, tolerance, TypedArrayConstructor, segmentsPixelIndices, sopUIDImageIdIndexMap, imageIdMaps, eventTarget, triggerEvent) {
   const SharedFunctionalGroupsSequence = multiframe.SharedFunctionalGroupsSequence,
@@ -894,13 +1027,14 @@ function getImageIdOfSourceImageBySourceImageSequence(SourceImageSequence, sopUI
     } else if (baseImageId.includes('dicomfile:')) {
       // dicomfile base 1, despite having frame=
       return baseImageId.replace(/frame=\d+/, "frame=".concat(ReferencedFrameNumber));
-    } else if (baseImageId.includes('frame=')) {
-      return baseImageId.replace(/frame=\d+/, "frame=".concat(ReferencedFrameNumber - 1));
+    } else if (baseImageId.includes('frame=') || baseImageId.includes('wadouri:')) {
+      // OHIF local/wadouri use 1-based ?frame= / &frame= (same as dicomfile:).
+      return baseImageId.replace(/frame=\d+/, "frame=".concat(ReferencedFrameNumber));
     } else {
       if (baseImageId.includes('wadors:')) {
         return "".concat(baseImageId, "/frames/").concat(ReferencedFrameNumber);
       } else {
-        return "".concat(baseImageId, "?frame=").concat(ReferencedFrameNumber - 1);
+        return "".concat(baseImageId, "?frame=").concat(ReferencedFrameNumber);
       }
     }
   }
@@ -1049,28 +1183,40 @@ function getSegmentMetadata(multiframe, seriesInstanceUid) {
 }
 
 /**
- * Reads a range of bytes from an array of ArrayBuffer chunks and
- * aggregate them into a new Uint8Array.
+ * Reads a range of SAMPLES (typed-array elements, not bytes) from an array of
+ * typed-array chunks and aggregates them into a new typed array of the same
+ * element type. Chunks may be Uint8Array (8-bit / packed binary) or
+ * Uint16Array (16-bit labelmaps); offsets and lengths are in elements so the
+ * same sample-indexed math works for both widths.
  *
- * @param {ArrayBuffer[]} chunks - An array of ArrayBuffer chunks.
- * @param {number} offset - The offset of the first byte to read.
- * @param {number} length - The number of bytes to read.
- * @returns {Uint8Array} A new Uint8Array containing the requested bytes.
+ * @param {Uint8Array[]|Uint16Array[]} chunks - Typed-array chunks (all the same type).
+ * @param {number} offset - The offset of the first sample to read.
+ * @param {number} length - The number of samples to read.
+ * @returns {Uint8Array|Uint16Array} A view/copy containing the requested samples.
  */
 function readFromUnpackedChunks(chunks, offset, length) {
+  var _chunks$0$constructor, _chunks$, _TypedArray$BYTES_PER;
   const mapping = getUnpackedOffsetAndLength(chunks, offset, length);
-
+  const TypedArray = (_chunks$0$constructor = (_chunks$ = chunks[0]) === null || _chunks$ === void 0 ? void 0 : _chunks$.constructor) !== null && _chunks$0$constructor !== void 0 ? _chunks$0$constructor : Uint8Array;
+  const bytesPerElement = (_TypedArray$BYTES_PER = TypedArray.BYTES_PER_ELEMENT) !== null && _TypedArray$BYTES_PER !== void 0 ? _TypedArray$BYTES_PER : 1;
+
+  // Chunks are typically subarray views that share one backing ArrayBuffer, so
+  // `chunk.buffer` is the whole buffer (byte 0 = chunk 0) while the computed
+  // offsets are chunk-relative. Add each chunk's own byteOffset so a view into
+  // chunk N reads chunk N's bytes and not chunk 0's; element offsets are scaled
+  // by the chunk's element width so 16-bit chunks are not read as bytes.
   // If all the data is in one chunk, we can just slice that chunk
   if (mapping.start.chunkIndex === mapping.end.chunkIndex) {
-    return new Uint8Array(chunks[mapping.start.chunkIndex].buffer, mapping.start.offset, length);
+    const chunk = chunks[mapping.start.chunkIndex];
+    return new TypedArray(chunk.buffer, chunk.byteOffset + mapping.start.offset * bytesPerElement, length);
   } else {
-    // If the data spans multiple chunks, we need to create a new Uint8Array and copy the data from each chunk
-    let result = new Uint8Array(length);
+    // If the data spans multiple chunks, we need to create a new typed array and copy the data from each chunk
+    let result = new TypedArray(length);
     let resultOffset = 0;
     for (let i = mapping.start.chunkIndex; i <= mapping.end.chunkIndex; i++) {
       let start = i === mapping.start.chunkIndex ? mapping.start.offset : 0;
       let end = i === mapping.end.chunkIndex ? mapping.end.offset : chunks[i].length;
-      result.set(new Uint8Array(chunks[i].buffer, start, end - start), resultOffset);
+      result.set(new TypedArray(chunks[i].buffer, chunks[i].byteOffset + start * bytesPerElement, end - start), resultOffset);
       resultOffset += end - start;
     }
     return result;
@@ -1112,10 +1258,10 @@ function calculateCentroid(imageIdIndexBufferIndex, multiframe, metadataProvider
   let worldYAcc = 0;
   let worldZAcc = 0;
   let count = 0;
-  for (const _ref3 of Object.entries(imageIdIndexBufferIndex)) {
-    var _ref4 = _slicedToArray(_ref3, 2);
-    const imageIdIndex = _ref4[0];
-    const bufferIndices = _ref4[1];
+  for (const _ref4 of Object.entries(imageIdIndexBufferIndex)) {
+    var _ref5 = _slicedToArray(_ref4, 2);
+    const imageIdIndex = _ref5[0];
+    const bufferIndices = _ref5[1];
     const z = Number(imageIdIndex);
     if (!bufferIndices || bufferIndices.length === 0) {
       continue;

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

@@ -4,5 +4,14 @@ interface IOptions {
 type Options = IOptions & {
     [key: string]: number | boolean | unknown | string;
 };
+declare function toLabelmap3DArray(inputLabelmaps3D: any): any[];
+declare function collectNonEmptyFrameIndices(labelmap3DArray: any): number[];
+declare function resolveReferencedImagesForExport(images: Array<{
+    imageId?: string;
+} | undefined | null>, frameIndices: number[]): {
+    imageId?: string;
+}[];
+declare function maxSegmentValue(labelmap3DArray: any, frameIndices: number[]): number;
+declare function collectSegmentSequence(labelmap3DArray: any): Record<string, unknown>[];
 declare function generateSegmentation(images: any, labelmaps: any, metadata: any, options?: Options): any;
-export { generateSegmentation };
+export { generateSegmentation, toLabelmap3DArray, collectNonEmptyFrameIndices, resolveReferencedImagesForExport, maxSegmentValue, collectSegmentSequence, };