@cornerstonejs/adapters 5.4.11 → 5.4.13

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

@@ -1,17 +1,294 @@
+import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import { normalizers, derivations } from 'dcmjs';
 import { Enums } from '@cornerstonejs/core';
 import { fillSegmentation } from '../../Cornerstone/Segmentation_4X.js';
+import { getBitmapFramesFromDataset, encodeFramesToTransferSyntax, EXPLICIT_VR_LITTLE_ENDIAN_TRANSFER_SYNTAX_UID } from '../encodePixelData.js';
+import { normalizeSharedFunctionalGroupsSequence, getReferencedSourceImageSequenceItem, applyPerFrameFunctionalGroups } from './perFrameFunctionalGroups.js';
 
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 const MetadataModules = Enums.MetadataModules;
 const SEGImageNormalizer = normalizers.SEGImageNormalizer;
 const SegmentationDerivation = derivations.Segmentation;
+const LABELMAP_SEG_SOP_CLASS_UID = '1.2.840.10008.5.1.4.1.1.66.7';
+const BITMAP_SEG_SOP_CLASS_UID = '1.2.840.10008.5.1.4.1.1.66.4';
+function resolveTransferSyntaxUid() {
+  let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  const transferSyntaxUid = options.transferSyntaxUid || options.transferSyntaxUID;
+  if (!transferSyntaxUid) {
+    return EXPLICIT_VR_LITTLE_ENDIAN_TRANSFER_SYNTAX_UID;
+  }
+  return transferSyntaxUid;
+}
+function applySegDatasetTransferSyntax(dataset, transferSyntaxUid, pixelData, pixelDataVR) {
+  dataset.PixelData = pixelData;
+  dataset._vrMap = dataset._vrMap || {};
+  dataset._vrMap.PixelData = pixelDataVR;
+  dataset._meta = dataset._meta || {};
+  dataset._meta.TransferSyntaxUID = {
+    Value: [transferSyntaxUid],
+    vr: 'UI'
+  };
+}
+function hasAnySegment(pixelData) {
+  for (let i = 0; i < pixelData.length; i++) {
+    if (pixelData[i] !== 0) {
+      return true;
+    }
+  }
+  return false;
+}
+function toLabelmap3DArray(inputLabelmaps3D) {
+  if (Array.isArray(inputLabelmaps3D)) {
+    return inputLabelmaps3D.filter(Boolean);
+  }
+  return inputLabelmaps3D ? [inputLabelmaps3D] : [];
+}
+function collectNonEmptyFrameIndices(labelmap3DArray) {
+  const indices = new Set();
+  labelmap3DArray.forEach(labelmap3D => {
+    var _labelmap3D$labelmaps;
+    const labelmaps2D = (_labelmap3D$labelmaps = labelmap3D === null || labelmap3D === void 0 ? void 0 : labelmap3D.labelmaps2D) !== null && _labelmap3D$labelmaps !== void 0 ? _labelmap3D$labelmaps : [];
+    for (let i = 0; i < labelmaps2D.length; i++) {
+      const frame = labelmaps2D[i];
+      if (frame !== null && frame !== void 0 && frame.pixelData && hasAnySegment(frame.pixelData)) {
+        indices.add(i);
+      }
+    }
+  });
+  return Array.from(indices).sort((a, b) => a - b);
+}
+function resolveReferencedImagesForExport(images, frameIndices) {
+  if (!frameIndices.length) {
+    throw new Error('No non-empty labelmap frames found for SEG export');
+  }
+  return frameIndices.map(frameIndex => {
+    const image = images[frameIndex];
+    if (!(image !== null && image !== void 0 && image.imageId)) {
+      throw new Error("Cannot resolve referenced source image for labelmap stack frame ".concat(frameIndex, " ") + "(image not loaded in cache). Load the referenced series before storing the segmentation.");
+    }
+    return image;
+  });
+}
+function maxSegmentValue(labelmap3DArray, frameIndices) {
+  let max = 0;
+  labelmap3DArray.forEach(labelmap3D => {
+    var _labelmap3D$labelmaps2;
+    const labelmaps2D = (_labelmap3D$labelmaps2 = labelmap3D === null || labelmap3D === void 0 ? void 0 : labelmap3D.labelmaps2D) !== null && _labelmap3D$labelmaps2 !== void 0 ? _labelmap3D$labelmaps2 : [];
+    frameIndices.forEach(frameIndex => {
+      var _labelmaps2D$frameInd;
+      const pixelData = (_labelmaps2D$frameInd = labelmaps2D[frameIndex]) === null || _labelmaps2D$frameInd === void 0 ? void 0 : _labelmaps2D$frameInd.pixelData;
+      if (!pixelData) {
+        return;
+      }
+      for (let i = 0; i < pixelData.length; i++) {
+        if (pixelData[i] > max) {
+          max = pixelData[i];
+        }
+      }
+    });
+  });
+  return max;
+}
+function collectSegmentSequence(labelmap3DArray) {
+  const bySegmentNumber = new Map();
+  labelmap3DArray.forEach(labelmap3D => {
+    var _labelmap3D$metadata;
+    ((_labelmap3D$metadata = labelmap3D === null || labelmap3D === void 0 ? void 0 : labelmap3D.metadata) !== null && _labelmap3D$metadata !== void 0 ? _labelmap3D$metadata : []).forEach((segment, index) => {
+      var _segment$SegmentNumbe;
+      if (!segment) {
+        return;
+      }
+      const key = Number((_segment$SegmentNumbe = segment.SegmentNumber) !== null && _segment$SegmentNumbe !== void 0 ? _segment$SegmentNumbe : index);
+      if (!bySegmentNumber.has(key)) {
+        bySegmentNumber.set(key, _objectSpread({}, segment));
+      }
+    });
+  });
+  return Array.from(bySegmentNumber.entries()).sort((a, b) => a[0] - b[0]).map(_ref => {
+    let _ref2 = _slicedToArray(_ref, 2),
+      segment = _ref2[1];
+    return segment;
+  });
+}
+function getPlaneSequencesForImage(image, metadata) {
+  var _metadata$get;
+  const imagePlane = metadata === null || metadata === void 0 || (_metadata$get = metadata.get) === null || _metadata$get === void 0 ? void 0 : _metadata$get.call(metadata, MetadataModules.IMAGE_PLANE, image === null || image === void 0 ? void 0 : image.imageId);
+  if (!imagePlane) {
+    return {};
+  }
+  const result = {};
+  const imagePositionPatient = imagePlane.imagePositionPatient,
+    imageOrientationPatient = imagePlane.imageOrientationPatient,
+    rowCosines = imagePlane.rowCosines,
+    columnCosines = imagePlane.columnCosines;
+  if (Array.isArray(imagePositionPatient) && imagePositionPatient.length === 3) {
+    result.planePositionSequence = {
+      ImagePositionPatient: [...imagePositionPatient]
+    };
+  }
+  let orientation = imageOrientationPatient;
+  if ((!Array.isArray(orientation) || orientation.length !== 6) && Array.isArray(rowCosines) && Array.isArray(columnCosines)) {
+    orientation = [...rowCosines, ...columnCosines];
+  }
+  if (Array.isArray(orientation) && orientation.length === 6) {
+    result.planeOrientationSequence = {
+      ImageOrientationPatient: [...orientation]
+    };
+  }
+  return result;
+}
+function fillLabelmapSegmentation(segmentation, inputLabelmaps3D, metadata, images) {
+  let options = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
+  const labelmap3DArray = toLabelmap3DArray(inputLabelmaps3D);
+  const segmentSequence = collectSegmentSequence(labelmap3DArray);
+  const validFrameIndices = collectNonEmptyFrameIndices(labelmap3DArray);
+  if (!validFrameIndices.length) {
+    throw new Error('No non-empty labelmap frames found for SEG export');
+  }
+  const firstFrame = labelmap3DArray.map(labelmap3D => {
+    var _labelmap3D$labelmaps3;
+    return labelmap3D === null || labelmap3D === void 0 || (_labelmap3D$labelmaps3 = labelmap3D.labelmaps2D) === null || _labelmap3D$labelmaps3 === void 0 ? void 0 : _labelmap3D$labelmaps3[validFrameIndices[0]];
+  }).find(Boolean);
+  const rows = firstFrame.rows;
+  const columns = firstFrame.columns;
+  const frameLength = rows * columns;
+  const numberOfFrames = validFrameIndices.length;
+  const maxValue = maxSegmentValue(labelmap3DArray, validFrameIndices);
+  const useUint16 = maxValue > 255;
+  const FrameArray = useUint16 ? Uint16Array : Uint8Array;
+  const bitsAllocated = useUint16 ? 16 : 8;
+  let overlapWarned = false;
+  const buildExportFrame = frameIndex => {
+    const frame = new FrameArray(frameLength);
+    labelmap3DArray.forEach(labelmap3D => {
+      var _labelmap3D$labelmaps4;
+      const source = labelmap3D === null || labelmap3D === void 0 || (_labelmap3D$labelmaps4 = labelmap3D.labelmaps2D) === null || _labelmap3D$labelmaps4 === void 0 || (_labelmap3D$labelmaps4 = _labelmap3D$labelmaps4[frameIndex]) === null || _labelmap3D$labelmaps4 === void 0 ? void 0 : _labelmap3D$labelmaps4.pixelData;
+      if (!source) {
+        return;
+      }
+      const len = Math.min(source.length, frameLength);
+      for (let i = 0; i < len; i++) {
+        const value = source[i];
+        if (value === 0) {
+          continue;
+        }
+        if (frame[i] !== 0 && frame[i] !== value && !overlapWarned) {
+          console.warn('generateSegmentation: overlapping labelmap segments detected on the ' + 'same voxel while exporting a LABELMAP SEG; the later labelmap wins.');
+          overlapWarned = true;
+        }
+        frame[i] = value;
+      }
+    });
+    return frame;
+  };
+  const dataset = segmentation.dataset;
+  dataset.NumberOfFrames = numberOfFrames;
+  dataset.Rows = rows;
+  dataset.Columns = columns;
+  dataset.SOPClassUID = LABELMAP_SEG_SOP_CLASS_UID;
+  dataset.SegmentationType = 'LABELMAP';
+  if (segmentSequence.length) {
+    dataset.SegmentSequence = segmentSequence;
+  }
+  dataset.BitsAllocated = useUint16 ? '16' : '8';
+  dataset.BitsStored = useUint16 ? '16' : '8';
+  dataset.HighBit = useUint16 ? '15' : '7';
+  dataset.PixelRepresentation = '0';
+  delete dataset.MaximumFractionalValue;
+  delete dataset.SegmentationFractionalType;
+  dataset.SpecificCharacterSet = 'ISO_IR 192';
+  dataset._vrMap || (dataset._vrMap = {});
+  const transferSyntaxUid = resolveTransferSyntaxUid(options);
+  const _encodeFramesToTransf = encodeFramesToTransferSyntax({
+      transferSyntaxUID: transferSyntaxUid,
+      buildFrame: outputIndex => buildExportFrame(validFrameIndices[outputIndex]),
+      frameCount: validFrameIndices.length,
+      bitsAllocated,
+      columns
+    }),
+    pixelData = _encodeFramesToTransf.pixelData,
+    pixelDataVR = _encodeFramesToTransf.pixelDataVR;
+  applySegDatasetTransferSyntax(dataset, transferSyntaxUid, pixelData, pixelDataVR);
+  dataset._meta || (dataset._meta = {});
+  dataset._meta.MediaStorageSOPClassUID = {
+    Value: [LABELMAP_SEG_SOP_CLASS_UID],
+    vr: 'UI'
+  };
+  const sourceImageSequence = images.map(image => getReferencedSourceImageSequenceItem(image, metadata)).filter(item => item.ReferencedSOPInstanceUID);
+  if (sourceImageSequence.length) {
+    dataset.SourceImageSequence = sourceImageSequence;
+  }
+  const perFrameInputs = validFrameIndices.map((_, outputIndex) => {
+    var _dataset$PerFrameFunc, _dataset$PerFrameFunc2, _planeSequences$plane, _planeSequences$plane2;
+    const image = images[outputIndex];
+    const sourceImageSequenceItem = getReferencedSourceImageSequenceItem(image, metadata);
+    if (!(sourceImageSequenceItem !== null && sourceImageSequenceItem !== void 0 && sourceImageSequenceItem.ReferencedSOPInstanceUID)) {
+      throw new Error("Cannot resolve a source ReferencedSOPInstanceUID for labelmap SEG " + "frame ".concat(outputIndex, ". Refusing to write a SEG with unreliable ") + "source image references.");
+    }
+    const priorGroup = (_dataset$PerFrameFunc = (_dataset$PerFrameFunc2 = dataset.PerFrameFunctionalGroupsSequence) === null || _dataset$PerFrameFunc2 === void 0 ? void 0 : _dataset$PerFrameFunc2[outputIndex]) !== null && _dataset$PerFrameFunc !== void 0 ? _dataset$PerFrameFunc : {};
+    const planeSequences = getPlaneSequencesForImage(image, metadata);
+    return {
+      sourceImageSequenceItem,
+      planeOrientationSequence: (_planeSequences$plane = planeSequences.planeOrientationSequence) !== null && _planeSequences$plane !== void 0 ? _planeSequences$plane : priorGroup === null || priorGroup === void 0 ? void 0 : priorGroup.PlaneOrientationSequence,
+      planePositionSequence: (_planeSequences$plane2 = planeSequences.planePositionSequence) !== null && _planeSequences$plane2 !== void 0 ? _planeSequences$plane2 : priorGroup === null || priorGroup === void 0 ? void 0 : priorGroup.PlanePositionSequence
+    };
+  });
+  applyPerFrameFunctionalGroups(dataset, perFrameInputs);
+  const sopInstanceUIDs = new Set(images.map(image => {
+    var _metadata$get2;
+    return (_metadata$get2 = metadata.get(MetadataModules.IMAGE_DATA, image === null || image === void 0 ? void 0 : image.imageId)) === null || _metadata$get2 === void 0 ? void 0 : _metadata$get2.SOPInstanceUID;
+  }).filter(Boolean));
+  const referencedSeriesSequence = dataset.ReferencedSeriesSequence;
+  const referencedSeries = Array.isArray(referencedSeriesSequence) ? referencedSeriesSequence[0] : referencedSeriesSequence;
+  if (referencedSeries !== null && referencedSeries !== void 0 && referencedSeries.ReferencedInstanceSequence && sopInstanceUIDs.size) {
+    const referencedInstances = Array.isArray(referencedSeries.ReferencedInstanceSequence) ? referencedSeries.ReferencedInstanceSequence : [referencedSeries.ReferencedInstanceSequence];
+    referencedSeries.ReferencedInstanceSequence = referencedInstances.filter(instance => (instance === null || instance === void 0 ? void 0 : instance.ReferencedSOPInstanceUID) && sopInstanceUIDs.has(instance.ReferencedSOPInstanceUID));
+  }
+  return segmentation;
+}
 function generateSegmentation(images, labelmaps, metadata) {
   let options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
-  const segmentation = _createMultiframeSegmentationFromReferencedImages(images, metadata, options);
-  const segmentationResult = fillSegmentation(segmentation, labelmaps, options);
+  const requestedSOPClassUID = (options === null || options === void 0 ? void 0 : options.sopClassUID) || BITMAP_SEG_SOP_CLASS_UID;
+  const shouldExportBitmap = requestedSOPClassUID === BITMAP_SEG_SOP_CLASS_UID;
+  if (shouldExportBitmap) {
+    var _segmentationResult$d;
+    const transferSyntaxUid = resolveTransferSyntaxUid(options);
+    const segmentation = _createMultiframeSegmentationFromReferencedImages(images, metadata, options);
+    const segmentationResult = fillSegmentation(segmentation, labelmaps, _objectSpread(_objectSpread({}, options), {}, {
+      transferSyntaxUid: EXPLICIT_VR_LITTLE_ENDIAN_TRANSFER_SYNTAX_UID,
+      skipTransferSyntaxMeta: true
+    }), images, metadata);
+    const _getBitmapFramesFromD = getBitmapFramesFromDataset(segmentationResult.dataset),
+      frames = _getBitmapFramesFromD.frames,
+      bitsAllocated = _getBitmapFramesFromD.bitsAllocated;
+    const _encodeFramesToTransf2 = encodeFramesToTransferSyntax({
+        transferSyntaxUID: transferSyntaxUid,
+        frames,
+        bitsAllocated,
+        columns: Number(segmentationResult.dataset.Columns) || undefined
+      }),
+      pixelData = _encodeFramesToTransf2.pixelData,
+      pixelDataVR = _encodeFramesToTransf2.pixelDataVR;
+    applySegDatasetTransferSyntax(segmentationResult.dataset, transferSyntaxUid, pixelData, pixelDataVR);
+    segmentationResult.dataset.SOPClassUID = BITMAP_SEG_SOP_CLASS_UID;
+    (_segmentationResult$d = segmentationResult.dataset)._meta || (_segmentationResult$d._meta = {});
+    segmentationResult.dataset._meta.MediaStorageSOPClassUID = {
+      Value: [BITMAP_SEG_SOP_CLASS_UID],
+      vr: 'UI'
+    };
+    const predecessorImageId = options === null || options === void 0 ? void 0 : options.predecessorImageId;
+    if (predecessorImageId) {
+      const predecessor = metadata.get(MetadataModules.PREDECESSOR_SEQUENCE, predecessorImageId);
+      Object.assign(segmentationResult, predecessor);
+    }
+    return segmentationResult;
+  }
+  const nonEmptyFrameIndices = collectNonEmptyFrameIndices(toLabelmap3DArray(labelmaps));
+  const filteredImages = resolveReferencedImagesForExport(images, nonEmptyFrameIndices);
+  const segmentation = _createMultiframeSegmentationFromReferencedImages(filteredImages, metadata, options);
+  const segmentationResult = fillLabelmapSegmentation(segmentation, labelmaps, metadata, filteredImages, options);
   const predecessorImageId = options === null || options === void 0 ? void 0 : options.predecessorImageId;
   if (predecessorImageId) {
     const predecessor = metadata.get(MetadataModules.PREDECESSOR_SEQUENCE, predecessorImageId);
@@ -20,6 +297,10 @@ function generateSegmentation(images, labelmaps, metadata) {
   return segmentationResult;
 }
 function _createMultiframeSegmentationFromReferencedImages(images, metadata, options) {
+  var _images$, _multiframe$SharedFun;
+  if (!(images !== null && images !== void 0 && images.length) || !((_images$ = images[0]) !== null && _images$ !== void 0 && _images$.imageId)) {
+    throw new Error('Cannot create SEG derivation: no referenced source images were resolved.');
+  }
   const studyImageId = (options === null || options === void 0 ? void 0 : options.predecessorImageId) || images[0].imageId;
   const studyData = metadata.get(MetadataModules.STUDY_DATA, studyImageId);
   const datasets = images.map(image => {
@@ -45,8 +326,8 @@ function _createMultiframeSegmentationFromReferencedImages(images, metadata, opt
   if (!multiframe) {
     throw new Error('Failed to normalize the multiframe dataset, the data is not multi-frame.');
   }
-  multiframe.SharedFunctionalGroupsSequence || (multiframe.SharedFunctionalGroupsSequence = {});
-  multiframe.SharedFunctionalGroupsSequence.PixelMeasuresSequence = {};
+  normalizeSharedFunctionalGroupsSequence(multiframe);
+  (_multiframe$SharedFun = multiframe.SharedFunctionalGroupsSequence).PixelMeasuresSequence || (_multiframe$SharedFun.PixelMeasuresSequence = {});
   multiframe.PerFrameFunctionalGroupsSequence || (multiframe.PerFrameFunctionalGroupsSequence = []);
   for (let index = 0; index < images.length; index++) {
     var _multiframe$PerFrameF, _index;
@@ -62,4 +343,4 @@ function _createMultiframeSegmentationFromReferencedImages(images, metadata, opt
   return new SegmentationDerivation([multiframe], options);
 }
 
-export { generateSegmentation };
+export { collectNonEmptyFrameIndices, collectSegmentSequence, generateSegmentation, maxSegmentValue, resolveReferencedImagesForExport, toLabelmap3DArray };

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

@@ -1,4 +1,23 @@
+import { createLabelmapsFromDICOMBuffer, createLabelmapsFromSegImageIds } from './labelmapImagesFromBuffer.js';
 declare function generateToolState(imageIds: any, arrayBuffer: any, metadataProvider: any, skipOverlapping?: boolean, tolerance?: number, cs3dVersion?: number): any;
+declare function createFromDicomSegImageId(referencedImageIds: any, segImageId: any, { metadataProvider, tolerance, parserType, frameImageIds, getFrameImageId, decodeImageData, concurrency, }: {
+    metadataProvider: any;
+    tolerance?: number;
+    parserType?: string;
+    frameImageIds?: any;
+    getFrameImageId?: any;
+    decodeImageData?: any;
+    concurrency?: any;
+}): Promise<{
+    labelMapImages: any;
+    segMetadata: {
+        seriesInstanceUid: any;
+        data: any[];
+    };
+    segmentsOnFrame: any[];
+    centroids: Map<any, any>;
+    overlappingSegments: any;
+}>;
 declare function createFromDICOMSegBuffer(referencedImageIds: any, arrayBuffer: any, { metadataProvider, tolerance }: {
     metadataProvider: any;
     tolerance?: number;
@@ -12,4 +31,4 @@ declare function createFromDICOMSegBuffer(referencedImageIds: any, arrayBuffer:
     centroids: Map<any, any>;
     overlappingSegments: any;
 }>;
-export { generateToolState, createFromDICOMSegBuffer };
+export { generateToolState, createFromDicomSegImageId, createFromDICOMSegBuffer, createLabelmapsFromSegImageIds, createLabelmapsFromDICOMBuffer, };

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

@@ -1,19 +1,49 @@
 import { generateToolState as generateToolState$1 } from '../../Cornerstone/Segmentation.js';
-import { createLabelmapsFromBufferInternal } from './labelmapImagesFromBuffer.js';
+import { createLabelmapsFromDICOMBuffer, createLabelmapsFromSegImageIds } from './labelmapImagesFromBuffer.js';
 
 function generateToolState(imageIds, arrayBuffer, metadataProvider) {
   let skipOverlapping = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
   let tolerance = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1e-3;
   let cs3dVersion = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 4;
-  return generateToolState$1(imageIds, arrayBuffer, metadataProvider, skipOverlapping, tolerance, cs3dVersion);
+  if (cs3dVersion !== 4) {
+    return generateToolState$1(imageIds, arrayBuffer, metadataProvider, skipOverlapping, tolerance, cs3dVersion);
+  }
+  return createLabelmapsFromDICOMBuffer(imageIds, arrayBuffer, metadataProvider, {
+    tolerance,
+    parserType: 'bitmap'
+  });
 }
-function createFromDICOMSegBuffer(referencedImageIds, arrayBuffer, _ref) {
+function createFromDicomSegImageId(referencedImageIds, segImageId, _ref) {
   let metadataProvider = _ref.metadataProvider,
     _ref$tolerance = _ref.tolerance,
-    tolerance = _ref$tolerance === void 0 ? 1e-3 : _ref$tolerance;
-  return createLabelmapsFromBufferInternal(referencedImageIds, arrayBuffer, metadataProvider, {
-    tolerance
+    tolerance = _ref$tolerance === void 0 ? 1e-3 : _ref$tolerance,
+    _ref$parserType = _ref.parserType,
+    parserType = _ref$parserType === void 0 ? 'bitmap' : _ref$parserType,
+    _ref$frameImageIds = _ref.frameImageIds,
+    frameImageIds = _ref$frameImageIds === void 0 ? undefined : _ref$frameImageIds,
+    _ref$getFrameImageId = _ref.getFrameImageId,
+    getFrameImageId = _ref$getFrameImageId === void 0 ? undefined : _ref$getFrameImageId,
+    _ref$decodeImageData = _ref.decodeImageData,
+    decodeImageData = _ref$decodeImageData === void 0 ? undefined : _ref$decodeImageData,
+    _ref$concurrency = _ref.concurrency,
+    concurrency = _ref$concurrency === void 0 ? undefined : _ref$concurrency;
+  return createLabelmapsFromSegImageIds(referencedImageIds, segImageId, metadataProvider, {
+    tolerance,
+    parserType,
+    frameImageIds,
+    getFrameImageId,
+    decodeImageData,
+    concurrency
+  });
+}
+function createFromDICOMSegBuffer(referencedImageIds, arrayBuffer, _ref2) {
+  let metadataProvider = _ref2.metadataProvider,
+    _ref2$tolerance = _ref2.tolerance,
+    tolerance = _ref2$tolerance === void 0 ? 1e-3 : _ref2$tolerance;
+  return createLabelmapsFromDICOMBuffer(referencedImageIds, arrayBuffer, metadataProvider, {
+    tolerance,
+    parserType: 'bitmap'
   });
 }
 
-export { createFromDICOMSegBuffer, generateToolState };
+export { createFromDICOMSegBuffer, createFromDicomSegImageId, createLabelmapsFromDICOMBuffer, createLabelmapsFromSegImageIds, generateToolState };

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

@@ -1,4 +1,4 @@
 import { generateSegmentation } from './generateSegmentation.js';
 import { generateLabelMaps2DFrom3D } from './generateLabelMaps2DFrom3D.js';
-import { generateToolState, createFromDICOMSegBuffer } from './generateToolState.js';
-export { generateLabelMaps2DFrom3D, generateSegmentation, generateToolState, createFromDICOMSegBuffer, };
+import { generateToolState, createFromDicomSegImageId, createFromDICOMSegBuffer, createLabelmapsFromSegImageIds, createLabelmapsFromDICOMBuffer } from './generateToolState.js';
+export { generateLabelMaps2DFrom3D, generateSegmentation, generateToolState, createFromDicomSegImageId, createFromDICOMSegBuffer, createLabelmapsFromSegImageIds, createLabelmapsFromDICOMBuffer, };

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

@@ -1,3 +1,4 @@
 export { generateSegmentation } from './generateSegmentation.js';
 export { generateLabelMaps2DFrom3D } from './generateLabelMaps2DFrom3D.js';
-export { createFromDICOMSegBuffer, generateToolState } from './generateToolState.js';
+export { createFromDICOMSegBuffer, createFromDicomSegImageId, generateToolState } from './generateToolState.js';
+export { createLabelmapsFromDICOMBuffer, createLabelmapsFromSegImageIds } from './labelmapImagesFromBuffer.js';

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

@@ -1,4 +1,24 @@
-declare function createLabelmapsFromBufferInternal(referencedImageIds: any, arrayBuffer: any, metadataProvider: any, options: any): Promise<{
+declare function isPseudoBinaryFractional(pixelData: ArrayLike<number>, maximumFractionalValue: unknown): boolean;
+declare function buildSopUIDImageIdIndexMap(referencedImageIds: any, metadataProvider: any): any;
+type DecodeFrameImageData = (frameImageId: string, frameNumber: number) => Promise<ArrayLike<number> | ArrayLike<number>[] | Uint8Array | Uint16Array | (Uint8Array | Uint16Array)[]>;
+declare function resolveFrameImageIds({ segImageId, numberOfFrames, frameImageIds, getFrameImageId, }: {
+    segImageId: string;
+    numberOfFrames: number;
+    frameImageIds?: string[];
+    getFrameImageId?: (baseSegImageId: string, frameNumber: number) => string;
+}): string[];
+declare function decodeSegPixelDataFromFrameIds({ segImageId, multiframe, frameImageIds, getFrameImageId, decodeImageData, concurrency, }: {
+    segImageId: string;
+    multiframe: Record<string, unknown>;
+    frameImageIds?: string[];
+    getFrameImageId?: (baseSegImageId: string, frameNumber: number) => string;
+    decodeImageData: DecodeFrameImageData;
+    concurrency?: number;
+}): Promise<{
+    pixelDataChunks: (Uint8Array | Uint16Array)[];
+    expectedVoxelCount: number;
+}>;
+declare function createLabelmapsFromSegImageIds(referencedImageIds: any, segImageId: any, metadataProvider: any, options: any): Promise<{
     labelMapImages: any;
     segMetadata: {
         seriesInstanceUid: any;
@@ -8,7 +28,7 @@ declare function createLabelmapsFromBufferInternal(referencedImageIds: any, arra
     centroids: Map<any, any>;
     overlappingSegments: any;
 }>;
-export declare function insertPixelDataPlanar({ segmentsOnFrame, labelMapImages, pixelDataChunks, multiframe, referencedImageIds, validOrientations, metadataProvider, tolerance, segmentsPixelIndices, sopUIDImageIdIndexMap, imageIdMaps, }: {
+export declare function insertPixelDataPlanar({ segmentsOnFrame, labelMapImages, pixelDataChunks, multiframe, referencedImageIds, validOrientations, metadataProvider, tolerance, segmentsPixelIndices, sopUIDImageIdIndexMap, imageIdMaps, parserType, decodedFrameCount, }: {
     segmentsOnFrame: any;
     labelMapImages: any;
     pixelDataChunks: any;
@@ -20,6 +40,8 @@ export declare function insertPixelDataPlanar({ segmentsOnFrame, labelMapImages,
     segmentsPixelIndices: any;
     sopUIDImageIdIndexMap: any;
     imageIdMaps: any;
+    parserType: any;
+    decodedFrameCount: any;
 }): Promise<unknown>;
 export declare function insertOverlappingPixelDataPlanar({ segmentsOnFrame, labelMapImages, pixelDataChunks, multiframe, referencedImageIds, validOrientations, metadataProvider, tolerance, segmentsPixelIndices, sopUIDImageIdIndexMap, imageIdMaps, }: {
     segmentsOnFrame: any;
@@ -37,4 +59,24 @@ export declare function insertOverlappingPixelDataPlanar({ segmentsOnFrame, labe
     arrayOfLabelMapImages: any;
     hasOverlappingSegments: boolean;
 };
-export { createLabelmapsFromBufferInternal };
+declare function createLabelmapsFromDICOMBuffer(referencedImageIds: any, arrayBuffer: any, metadataProvider: any, options?: Record<string, unknown>): Promise<{
+    labelMapImages: any;
+    segMetadata: {
+        seriesInstanceUid: any;
+        data: any[];
+    };
+    segmentsOnFrame: any[];
+    centroids: Map<any, any>;
+    overlappingSegments: any;
+}>;
+declare function createLabelmapsFromBufferInternal(referencedImageIds: any, segImageId: any, metadataProvider: any, options: any): Promise<{
+    labelMapImages: any;
+    segMetadata: {
+        seriesInstanceUid: any;
+        data: any[];
+    };
+    segmentsOnFrame: any[];
+    centroids: Map<any, any>;
+    overlappingSegments: any;
+}>;
+export { createLabelmapsFromSegImageIds, createLabelmapsFromDICOMBuffer, createLabelmapsFromBufferInternal, decodeSegPixelDataFromFrameIds, resolveFrameImageIds, buildSopUIDImageIdIndexMap, isPseudoBinaryFractional, };