@cornerstonejs/adapters 5.4.11 → 5.4.12

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

@@ -1,30 +1,362 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import { triggerEvent, eventTarget, imageLoader } from '@cornerstonejs/core';
-import { utilities as utilities$1 } from '@cornerstonejs/tools';
-import { data, normalizers, utilities } from 'dcmjs';
+import { utilities } from '@cornerstonejs/tools';
+import { data, normalizers } from 'dcmjs';
 import ndarray from 'ndarray';
 import checkOrientation from '../../helpers/checkOrientation.js';
-import { getValidOrientations, getSegmentMetadata, unpackPixelData, calculateCentroid, readFromUnpackedChunks, alignPixelDataWithSourceData, getSegmentIndex, findReferenceSourceImageId } from '../../Cornerstone/Segmentation_4X.js';
+import { unpackBinaryFrameFromPacked, getSegNumberOfFramesFromDataset, createDecodeImageDataFromMultiframe } from '../encodePixelData.js';
+import { getValidOrientations, getSegmentMetadata, calculateCentroid, readFromUnpackedChunks, alignPixelDataWithSourceData, getSegmentIndex, findReferenceSourceImageId, getImageIdOfSourceImageBySourceImageSequence } from '../../Cornerstone/Segmentation_4X.js';
 import { compactMergeSegmentDataWithoutInformationLoss } from './compactMergeSegData.js';
+import { normalizeSharedFunctionalGroupsSequence } from './perFrameFunctionalGroups.js';
 import { Events } from '../../enums/Events.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 DicomMessage = data.DicomMessage,
   DicomMetaDictionary = data.DicomMetaDictionary;
 const Normalizer = normalizers.Normalizer;
-const decode = utilities.compression.decode;
-const updateSegmentsOnFrame = _ref => {
-  let segmentsOnFrame = _ref.segmentsOnFrame,
-    imageIdIndex = _ref.imageIdIndex,
-    segmentIndex = _ref.segmentIndex;
+const LABELMAP_SEG_SOP_CLASS_UID = '1.2.840.10008.5.1.4.1.1.66.7';
+const BUFFER_SEG_IMAGE_ID = 'cornerstone-adapters-buffer-seg:0';
+function stripFrameQualifiersFromImageId(imageId) {
+  if (!imageId) {
+    return imageId;
+  }
+  if (imageId.includes('/frames/')) {
+    return imageId.replace(/\/frames\/\d+.*$/, '');
+  }
+  return imageId.split('&frame=')[0].split('?frame=')[0];
+}
+function prepareSegMultiframeMetadata(multiframe) {
+  normalizeSharedFunctionalGroupsSequence(multiframe);
+  const perFrame = multiframe.PerFrameFunctionalGroupsSequence;
+  if (perFrame && !Array.isArray(perFrame)) {
+    multiframe.PerFrameFunctionalGroupsSequence = [perFrame];
+  }
+}
+function getFrameNumberFromImageId(imageId) {
+  const frameQueryMatch = imageId.match(/(?:&|\?)frame=(\d+)/);
+  if (frameQueryMatch) {
+    return Number(frameQueryMatch[1]);
+  }
+  const wadorsFrameMatch = imageId.match(/\/frames\/(\d+)/);
+  if (wadorsFrameMatch) {
+    return Number(wadorsFrameMatch[1]);
+  }
+  return undefined;
+}
+function isPseudoBinaryFractional(pixelData, maximumFractionalValue) {
+  const max = Number(maximumFractionalValue);
+  if (!Number.isFinite(max)) {
+    return false;
+  }
+  for (let i = 0; i < pixelData.length; i++) {
+    const value = pixelData[i];
+    if (value !== 0 && value !== max) {
+      return false;
+    }
+  }
+  return true;
+}
+function isPseudoBinaryFractionalFromChunks(chunks, maximumFractionalValue) {
+  for (const chunk of chunks) {
+    if (!isPseudoBinaryFractional(chunk, maximumFractionalValue)) {
+      return false;
+    }
+  }
+  return true;
+}
+function buildSopUIDImageIdIndexMap(referencedImageIds, metadataProvider) {
+  return referencedImageIds.reduce((acc, imageId) => {
+    var _metadataProvider$get;
+    const _ref = (_metadataProvider$get = metadataProvider.get('generalImageModule', imageId)) !== null && _metadataProvider$get !== void 0 ? _metadataProvider$get : {},
+      sopInstanceUID = _ref.sopInstanceUID;
+    if (!sopInstanceUID) {
+      return acc;
+    }
+    if (!acc[sopInstanceUID]) {
+      acc[sopInstanceUID] = imageId;
+    }
+    return acc;
+  }, {});
+}
+function resolveStackImageId(imageId, referencedImageIds, metadataProvider) {
+  if (!imageId) {
+    return undefined;
+  }
+  if (referencedImageIds.includes(imageId)) {
+    return imageId;
+  }
+  const strippedTarget = stripFrameQualifiersFromImageId(imageId);
+  const targetFrame = getFrameNumberFromImageId(imageId);
+  for (const refId of referencedImageIds) {
+    var _getFrameNumberFromIm;
+    if (stripFrameQualifiersFromImageId(refId) !== strippedTarget) {
+      continue;
+    }
+    if (targetFrame === undefined) {
+      return refId;
+    }
+    const refFrame = (_getFrameNumberFromIm = getFrameNumberFromImageId(refId)) !== null && _getFrameNumberFromIm !== void 0 ? _getFrameNumberFromIm : 1;
+    if (refFrame === targetFrame) {
+      return refId;
+    }
+  }
+  if (metadataProvider !== null && metadataProvider !== void 0 && metadataProvider.get) {
+    const _ref2 = metadataProvider.get('generalImageModule', imageId) || {},
+      sopInstanceUID = _ref2.sopInstanceUID;
+    if (sopInstanceUID) {
+      for (const refId of referencedImageIds) {
+        var _metadataProvider$get2, _getFrameNumberFromIm2;
+        const refSop = (_metadataProvider$get2 = metadataProvider.get('generalImageModule', refId)) === null || _metadataProvider$get2 === void 0 ? void 0 : _metadataProvider$get2.sopInstanceUID;
+        if (refSop !== sopInstanceUID) {
+          continue;
+        }
+        if (targetFrame === undefined) {
+          return refId;
+        }
+        const refFrame = (_getFrameNumberFromIm2 = getFrameNumberFromImageId(refId)) !== null && _getFrameNumberFromIm2 !== void 0 ? _getFrameNumberFromIm2 : 1;
+        if (refFrame === targetFrame) {
+          return refId;
+        }
+      }
+    }
+  }
+  return undefined;
+}
+function ensureImageIdMapsEntry(imageId, referencedImageIds, imageIdMaps, metadataProvider) {
+  const stackImageId = resolveStackImageId(imageId, referencedImageIds, metadataProvider);
+  if (!stackImageId) {
+    return undefined;
+  }
+  if (imageIdMaps.indices[stackImageId] === undefined) {
+    const index = referencedImageIds.indexOf(stackImageId);
+    if (index === -1) {
+      return undefined;
+    }
+    imageIdMaps.indices[stackImageId] = index;
+    imageIdMaps.metadata[stackImageId] = imageIdMaps.metadata[stackImageId] || metadataProvider.get('instance', stackImageId);
+  }
+  return stackImageId;
+}
+function chunkPixelData(pixelData) {
+  let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  const _options$maxBytesPerC = options.maxBytesPerChunk,
+    maxBytesPerChunk = _options$maxBytesPerC === void 0 ? Number.POSITIVE_INFINITY : _options$maxBytesPerC;
+  if (pixelData.length <= maxBytesPerChunk) {
+    return [pixelData];
+  }
+  const chunks = [];
+  for (let offset = 0; offset < pixelData.length; offset += maxBytesPerChunk) {
+    chunks.push(pixelData.subarray(offset, offset + maxBytesPerChunk));
+  }
+  return chunks;
+}
+function normalizeDecodedPixelData(pixelData) {
+  if (Array.isArray(pixelData)) {
+    if (pixelData.length === 1) {
+      return normalizeDecodedPixelData(pixelData[0]);
+    }
+    const hasUint16Frame = pixelData.some(frame => frame instanceof Uint16Array);
+    if (hasUint16Frame) {
+      const normalizedFrames = pixelData.map(frame => frame instanceof Uint16Array ? frame : new Uint16Array(frame));
+      const totalLength = normalizedFrames.reduce((acc, frame) => acc + frame.length, 0);
+      const combined = new Uint16Array(totalLength);
+      let offset = 0;
+      for (const frame of normalizedFrames) {
+        combined.set(frame, offset);
+        offset += frame.length;
+      }
+      return combined;
+    }
+    const normalizedFrames = pixelData.map(frame => frame instanceof Uint8Array ? frame : new Uint8Array(frame));
+    const totalLength = normalizedFrames.reduce((acc, frame) => acc + frame.length, 0);
+    const combined = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const frame of normalizedFrames) {
+      combined.set(frame, offset);
+      offset += frame.length;
+    }
+    return combined;
+  }
+  if (pixelData instanceof Uint8Array || pixelData instanceof Uint16Array) {
+    return pixelData;
+  }
+  return new Uint8Array(pixelData);
+}
+function getExpectedVoxelCount(multiframe) {
+  var _multiframe$PerFrameF;
+  const numberOfFrames = Number(multiframe.NumberOfFrames) || ((_multiframe$PerFrameF = multiframe.PerFrameFunctionalGroupsSequence) === null || _multiframe$PerFrameF === void 0 ? void 0 : _multiframe$PerFrameF.length) || 1;
+  return multiframe.Rows * multiframe.Columns * numberOfFrames;
+}
+const DEFAULT_SEG_FRAME_DECODE_CONCURRENCY = 16;
+async function mapWithConcurrency(items, limit, fn) {
+  const results = new Array(items.length);
+  let nextIndex = 0;
+  const worker = async () => {
+    while (nextIndex < items.length) {
+      const index = nextIndex++;
+      results[index] = await fn(items[index], index);
+    }
+  };
+  const poolSize = Math.max(1, Math.min(limit, items.length));
+  await Promise.all(Array.from({
+    length: poolSize
+  }, worker));
+  return results;
+}
+function getSegNumberOfFrames(multiframe) {
+  const fromTag = Number(multiframe.NumberOfFrames);
+  if (fromTag > 0) {
+    return fromTag;
+  }
+  const perFrame = multiframe.PerFrameFunctionalGroupsSequence;
+  if (Array.isArray(perFrame) && perFrame.length > 0) {
+    return perFrame.length;
+  }
+  return 1;
+}
+function expandWadorsFrameImageIds(segImageId, numberOfFrames) {
+  const frameMatch = segImageId.match(/(.*\/frames\/)(\d+)(.*)$/);
+  if (!frameMatch || numberOfFrames <= 1) {
+    return [segImageId];
+  }
+  const prefix = frameMatch[1];
+  const suffix = frameMatch[3] || '';
+  const frameImageIds = [];
+  for (let frameNumber = 1; frameNumber <= numberOfFrames; frameNumber++) {
+    frameImageIds.push("".concat(prefix).concat(frameNumber).concat(suffix));
+  }
+  return frameImageIds;
+}
+const WADO_URI_FRAME_SCHEME = /^(wadouri:|dicomfile:)/;
+function expandWadoUriFrameImageIds(segImageId, numberOfFrames) {
+  if (numberOfFrames <= 1 || !WADO_URI_FRAME_SCHEME.test(segImageId)) {
+    return [segImageId];
+  }
+  const base = segImageId.split('&frame=')[0].split('?frame=')[0];
+  const separator = base.includes('?') ? '&' : '?';
+  const frameImageIds = [];
+  for (let frameNumber = 1; frameNumber <= numberOfFrames; frameNumber++) {
+    frameImageIds.push("".concat(base).concat(separator, "frame=").concat(frameNumber));
+  }
+  return frameImageIds;
+}
+function resolveFrameImageIds(_ref3) {
+  let segImageId = _ref3.segImageId,
+    numberOfFrames = _ref3.numberOfFrames,
+    frameImageIds = _ref3.frameImageIds,
+    getFrameImageId = _ref3.getFrameImageId;
+  if (frameImageIds !== null && frameImageIds !== void 0 && frameImageIds.length) {
+    return frameImageIds;
+  }
+  if (getFrameImageId) {
+    return Array.from({
+      length: numberOfFrames
+    }, (_, index) => getFrameImageId(segImageId, index + 1));
+  }
+  const wadorsFrameIds = expandWadorsFrameImageIds(segImageId, numberOfFrames);
+  if (wadorsFrameIds.length > 1) {
+    return wadorsFrameIds;
+  }
+  const wadoUriFrameIds = expandWadoUriFrameImageIds(segImageId, numberOfFrames);
+  if (wadoUriFrameIds.length > 1) {
+    return wadoUriFrameIds;
+  }
+  if (numberOfFrames > 1) {
+    throw new Error("Cannot derive per-frame imageIds for multiframe SEG \"".concat(segImageId, "\" ") + "(".concat(numberOfFrames, " frames): its imageId scheme is not WADO-RS ") + "(\".../frames/N\") or WADO-URI (\"?frame=N\"/\"&frame=N\"). Supply " + "options.frameImageIds or options.getFrameImageId for this data source.");
+  }
+  return [segImageId];
+}
+function unpackFramePixelDataIfNeeded(framePixelData, multiframe, sliceLength) {
+  const bitsStored = Number(multiframe.BitsStored);
+  if (bitsStored === 1 && framePixelData.length < sliceLength) {
+    const packed = framePixelData instanceof Uint8Array ? framePixelData : new Uint8Array(framePixelData);
+    return unpackBinaryFrameFromPacked(packed, sliceLength);
+  }
+  return framePixelData;
+}
+function ensureInstanceOnMetadataProvider(metadataProvider, segImageId, multiframe) {
+  if (metadataProvider.get('instance', segImageId)) {
+    return;
+  }
+  if (metadataProvider.addCustomMetadata) {
+    metadataProvider.addCustomMetadata(segImageId, 'instance', multiframe);
+    return;
+  }
+  if (metadataProvider.add) {
+    metadataProvider.add(segImageId, 'instance', multiframe);
+  }
+}
+async function defaultDecodeFrameImageData(frameImageId, _frameNumber) {
+  var _segImage$getPixelDat;
+  const segImage = await imageLoader.loadImage(frameImageId);
+  return segImage === null || segImage === void 0 || (_segImage$getPixelDat = segImage.getPixelData) === null || _segImage$getPixelDat === void 0 ? void 0 : _segImage$getPixelDat.call(segImage);
+}
+async function decodeSegPixelDataFromFrameIds(_ref4) {
+  let segImageId = _ref4.segImageId,
+    multiframe = _ref4.multiframe,
+    frameImageIds = _ref4.frameImageIds,
+    getFrameImageId = _ref4.getFrameImageId,
+    _ref4$decodeImageData = _ref4.decodeImageData,
+    decodeImageData = _ref4$decodeImageData === void 0 ? defaultDecodeFrameImageData : _ref4$decodeImageData,
+    _ref4$concurrency = _ref4.concurrency,
+    concurrency = _ref4$concurrency === void 0 ? DEFAULT_SEG_FRAME_DECODE_CONCURRENCY : _ref4$concurrency;
+  const rows = Number(multiframe.Rows);
+  const columns = Number(multiframe.Columns);
+  const sliceLength = rows * columns;
+  const numberOfFrames = getSegNumberOfFrames(multiframe);
+  const expectedVoxelCount = getExpectedVoxelCount(multiframe);
+  const resolvedFrameImageIds = resolveFrameImageIds({
+    segImageId,
+    numberOfFrames,
+    frameImageIds,
+    getFrameImageId
+  });
+  if (numberOfFrames <= 1) {
+    const frameImageId = resolvedFrameImageIds[0] || segImageId;
+    const framePixelData = await decodeImageData(frameImageId, 1);
+    if (!framePixelData) {
+      throw new Error("No decoded pixel data found for SEG imageId: ".concat(frameImageId));
+    }
+    const normalized = normalizeDecodedPixelData(framePixelData);
+    const decodedPixelData = unpackFramePixelDataIfNeeded(normalized, multiframe, sliceLength);
+    return {
+      pixelDataChunks: [decodedPixelData],
+      expectedVoxelCount
+    };
+  }
+  const perFramePixelData = await mapWithConcurrency(resolvedFrameImageIds.slice(0, numberOfFrames), concurrency, async (frameImageId, frameIndex) => {
+    const frameNumber = frameIndex + 1;
+    if (!frameImageId) {
+      throw new Error("Missing SEG frame imageId at frame ".concat(frameNumber, " (expected ").concat(numberOfFrames, " frame imageIds)"));
+    }
+    const framePixelData = await decodeImageData(frameImageId, frameNumber);
+    if (!framePixelData) {
+      throw new Error("No decoded pixel data found for SEG frame imageId: ".concat(frameImageId));
+    }
+    let normalizedFrame = normalizeDecodedPixelData(framePixelData);
+    normalizedFrame = unpackFramePixelDataIfNeeded(normalizedFrame, multiframe, sliceLength);
+    return normalizedFrame.subarray(0, sliceLength);
+  });
+  return {
+    pixelDataChunks: perFramePixelData,
+    expectedVoxelCount
+  };
+}
+const updateSegmentsOnFrame = _ref5 => {
+  let segmentsOnFrame = _ref5.segmentsOnFrame,
+    imageIdIndex = _ref5.imageIdIndex,
+    segmentIndex = _ref5.segmentIndex;
   if (!segmentsOnFrame[imageIdIndex]) {
     segmentsOnFrame[imageIdIndex] = [];
   }
   segmentsOnFrame[imageIdIndex].push(segmentIndex);
 };
-const updateSegmentsPixelIndices = _ref2 => {
-  let segmentsPixelIndices = _ref2.segmentsPixelIndices,
-    segmentIndex = _ref2.segmentIndex,
-    imageIdIndex = _ref2.imageIdIndex,
-    indexCache = _ref2.indexCache;
+const updateSegmentsPixelIndices = _ref6 => {
+  let segmentsPixelIndices = _ref6.segmentsPixelIndices,
+    segmentIndex = _ref6.segmentIndex,
+    imageIdIndex = _ref6.imageIdIndex,
+    indexCache = _ref6.indexCache;
   if (!segmentsPixelIndices.has(segmentIndex)) {
     segmentsPixelIndices.set(segmentIndex, {});
   }
@@ -32,13 +364,17 @@ const updateSegmentsPixelIndices = _ref2 => {
   segmentIndexObject[imageIdIndex] = indexCache;
   segmentsPixelIndices.set(segmentIndex, segmentIndexObject);
 };
-const extractInfoFromPerFrameFunctionalGroups = _ref3 => {
-  let PerFrameFunctionalGroups = _ref3.PerFrameFunctionalGroups,
-    sequenceIndex = _ref3.sequenceIndex,
-    sopUIDImageIdIndexMap = _ref3.sopUIDImageIdIndexMap,
-    multiframe = _ref3.multiframe;
-  const referencedSOPInstanceUid = PerFrameFunctionalGroups.DerivationImageSequence[0].SourceImageSequence[0].ReferencedSOPInstanceUID;
-  const referencedImageId = sopUIDImageIdIndexMap[referencedSOPInstanceUid];
+const extractInfoFromPerFrameFunctionalGroups = _ref7 => {
+  let PerFrameFunctionalGroups = _ref7.PerFrameFunctionalGroups,
+    sequenceIndex = _ref7.sequenceIndex,
+    sopUIDImageIdIndexMap = _ref7.sopUIDImageIdIndexMap,
+    multiframe = _ref7.multiframe;
+  const derivationImageSequence = PerFrameFunctionalGroups === null || PerFrameFunctionalGroups === void 0 ? void 0 : PerFrameFunctionalGroups.DerivationImageSequence;
+  const normalizedDerivationImageSequence = Array.isArray(derivationImageSequence) ? derivationImageSequence[0] : derivationImageSequence;
+  const sourceImageSequence = normalizedDerivationImageSequence === null || normalizedDerivationImageSequence === void 0 ? void 0 : normalizedDerivationImageSequence.SourceImageSequence;
+  const normalizedSourceImageSequence = Array.isArray(sourceImageSequence) ? sourceImageSequence[0] : sourceImageSequence;
+  const referencedSOPInstanceUid = normalizedSourceImageSequence === null || normalizedSourceImageSequence === void 0 ? void 0 : normalizedSourceImageSequence.ReferencedSOPInstanceUID;
+  const referencedImageId = referencedSOPInstanceUid && normalizedSourceImageSequence ? getImageIdOfSourceImageBySourceImageSequence(normalizedSourceImageSequence, sopUIDImageIdIndexMap) : undefined;
   const segmentIndex = getSegmentIndex(multiframe, sequenceIndex);
   return {
     referencedSOPInstanceUid,
@@ -46,17 +382,46 @@ const extractInfoFromPerFrameFunctionalGroups = _ref3 => {
     segmentIndex
   };
 };
-async function createLabelmapsFromBufferInternal(referencedImageIds, arrayBuffer, metadataProvider, options) {
-  const _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;
-  const dicomData = DicomMessage.readFile(arrayBuffer);
-  const dataset = DicomMetaDictionary.naturalizeDataset(dicomData.dict);
-  dataset._meta = DicomMetaDictionary.namifyDataset(dicomData.meta);
-  const multiframe = Normalizer.normalizeToDataset([dataset]);
+const getReferencedImageIdFromPerFrameGroup = _ref8 => {
+  let perFrameFunctionalGroup = _ref8.perFrameFunctionalGroup,
+    sopUIDImageIdIndexMap = _ref8.sopUIDImageIdIndexMap;
+  const derivationImageSequence = perFrameFunctionalGroup === null || perFrameFunctionalGroup === void 0 ? void 0 : perFrameFunctionalGroup.DerivationImageSequence;
+  const normalizedDerivationImageSequence = Array.isArray(derivationImageSequence) ? derivationImageSequence[0] : derivationImageSequence;
+  const sourceImageSequence = normalizedDerivationImageSequence === null || normalizedDerivationImageSequence === void 0 ? void 0 : normalizedDerivationImageSequence.SourceImageSequence;
+  const normalizedSourceImageSequence = Array.isArray(sourceImageSequence) ? sourceImageSequence[0] : sourceImageSequence;
+  const referencedSOPInstanceUID = normalizedSourceImageSequence === null || normalizedSourceImageSequence === void 0 ? void 0 : normalizedSourceImageSequence.ReferencedSOPInstanceUID;
+  if (!referencedSOPInstanceUID || !normalizedSourceImageSequence) {
+    return;
+  }
+  return getImageIdOfSourceImageBySourceImageSequence(normalizedSourceImageSequence, sopUIDImageIdIndexMap);
+};
+async function createLabelmapsFromSegImageIds(referencedImageIds, segImageId, metadataProvider, options) {
+  const _ref9 = options !== null && options !== void 0 ? options : {},
+    _ref9$tolerance = _ref9.tolerance,
+    tolerance = _ref9$tolerance === void 0 ? 1e-3 : _ref9$tolerance,
+    _ref9$TypedArrayConst = _ref9.TypedArrayConstructor,
+    TypedArrayConstructor = _ref9$TypedArrayConst === void 0 ? Uint8Array : _ref9$TypedArrayConst,
+    maxBytesPerChunk = _ref9.maxBytesPerChunk,
+    _ref9$parserType = _ref9.parserType,
+    parserType = _ref9$parserType === void 0 ? 'bitmap' : _ref9$parserType,
+    frameImageIds = _ref9.frameImageIds,
+    getFrameImageId = _ref9.getFrameImageId,
+    _ref9$decodeImageData = _ref9.decodeImageData,
+    decodeImageData = _ref9$decodeImageData === void 0 ? defaultDecodeFrameImageData : _ref9$decodeImageData,
+    _ref9$concurrency = _ref9.concurrency,
+    concurrency = _ref9$concurrency === void 0 ? DEFAULT_SEG_FRAME_DECODE_CONCURRENCY : _ref9$concurrency,
+    _ref9$multiframe = _ref9.multiframe,
+    providedMultiframe = _ref9$multiframe === void 0 ? undefined : _ref9$multiframe;
+  let multiframe = providedMultiframe;
+  if (!multiframe) {
+    var _instanceMeta$dataset;
+    const instanceMeta = metadataProvider.get('instance', segImageId);
+    if (!instanceMeta) {
+      throw new Error("No instance metadata found for SEG imageId: ".concat(segImageId, ". Ensure the SEG instance is registered in the metadata provider (e.g. after loading the image)."));
+    }
+    multiframe = (_instanceMeta$dataset = instanceMeta.dataset) !== null && _instanceMeta$dataset !== void 0 ? _instanceMeta$dataset : instanceMeta;
+  }
+  prepareSegMultiframeMetadata(multiframe);
   const imagePlaneModule = metadataProvider.get('imagePlaneModule', referencedImageIds[0]);
   const generalSeriesModule = metadataProvider.get('generalSeriesModule', referencedImageIds[0]);
   const SeriesInstanceUID = generalSeriesModule.seriesInstanceUID;
@@ -66,32 +431,38 @@ async function createLabelmapsFromBufferInternal(referencedImageIds, arrayBuffer
   const ImageOrientationPatient = Array.isArray(imagePlaneModule.rowCosines) ? [...imagePlaneModule.rowCosines, ...imagePlaneModule.columnCosines] : [imagePlaneModule.rowCosines.x, imagePlaneModule.rowCosines.y, imagePlaneModule.rowCosines.z, imagePlaneModule.columnCosines.x, imagePlaneModule.columnCosines.y, imagePlaneModule.columnCosines.z];
   const validOrientations = getValidOrientations(ImageOrientationPatient);
   const segMetadata = getSegmentMetadata(multiframe, SeriesInstanceUID);
-  const TransferSyntaxUID = multiframe._meta.TransferSyntaxUID.Value[0];
-  let pixelData;
-  let pixelDataChunks;
-  if (TransferSyntaxUID === '1.2.840.10008.1.2.5') {
-    const rleEncodedFrames = Array.isArray(multiframe.PixelData) ? multiframe.PixelData : [multiframe.PixelData];
-    pixelData = decode(rleEncodedFrames, multiframe.Rows, multiframe.Columns);
-    if (multiframe.BitsStored === 1) {
-      console.warn('No implementation for rle + bit packing.');
-      return;
-    }
-    pixelDataChunks = [pixelData];
-  } else {
-    pixelDataChunks = unpackPixelData(multiframe, {
+  const _await$decodeSegPixel = await decodeSegPixelDataFromFrameIds({
+      segImageId,
+      multiframe,
+      frameImageIds,
+      getFrameImageId,
+      decodeImageData,
+      concurrency
+    }),
+    pixelDataChunks = _await$decodeSegPixel.pixelDataChunks,
+    expectedVoxelCount = _await$decodeSegPixel.expectedVoxelCount;
+  const sliceLength = multiframe.Rows * multiframe.Columns;
+  let resolvedPixelDataChunks = pixelDataChunks;
+  if (Number(multiframe.BitsStored) === 1 && pixelDataChunks.length === 1 && pixelDataChunks[0].length < expectedVoxelCount) {
+    const packed = pixelDataChunks[0];
+    const unpacked = unpackBinaryFrameFromPacked(packed instanceof Uint8Array ? packed : new Uint8Array(packed), sliceLength);
+    resolvedPixelDataChunks = chunkPixelData(unpacked, {
       maxBytesPerChunk
     });
-    if (!pixelDataChunks) {
-      throw new Error('Fractional segmentations are not yet supported');
-    }
+  }
+  const totalSamples = resolvedPixelDataChunks.reduce((sum, chunk) => sum + chunk.length, 0);
+  const decodedFrameCount = Math.max(1, Math.floor(totalSamples / sliceLength));
+  if (multiframe.SegmentationType === 'FRACTIONAL' && !isPseudoBinaryFractionalFromChunks(resolvedPixelDataChunks, multiframe.MaximumFractionalValue)) {
+    throw new Error('Fractional segmentations are not yet supported');
+  }
+  let finalPixelDataChunks = resolvedPixelDataChunks;
+  if (maxBytesPerChunk && maxBytesPerChunk < Number.POSITIVE_INFINITY) {
+    finalPixelDataChunks = resolvedPixelDataChunks.flatMap(chunk => chunkPixelData(chunk, {
+      maxBytesPerChunk
+    }));
   }
   const orientation = checkOrientation(multiframe, validOrientations, [imagePlaneModule.rows, imagePlaneModule.columns, referencedImageIds.length], tolerance);
-  const sopUIDImageIdIndexMap = referencedImageIds.reduce((acc, imageId) => {
-    const _metadataProvider$get = metadataProvider.get('generalImageModule', imageId),
-      sopInstanceUID = _metadataProvider$get.sopInstanceUID;
-    acc[sopInstanceUID] = imageId;
-    return acc;
-  }, {});
+  const sopUIDImageIdIndexMap = buildSopUIDImageIdIndexMap(referencedImageIds, metadataProvider);
   let insertFunction;
   switch (orientation) {
     case 'Planar':
@@ -119,7 +490,7 @@ async function createLabelmapsFromBufferInternal(referencedImageIds, arrayBuffer
   const _await$insertFunction = await insertFunction({
       segmentsOnFrame,
       labelMapImages,
-      pixelDataChunks,
+      pixelDataChunks: finalPixelDataChunks,
       multiframe,
       referencedImageIds,
       validOrientations,
@@ -128,7 +499,9 @@ async function createLabelmapsFromBufferInternal(referencedImageIds, arrayBuffer
       segmentsPixelIndices,
       sopUIDImageIdIndexMap,
       imageIdMaps,
-      TypedArrayConstructor
+      TypedArrayConstructor,
+      parserType,
+      decodedFrameCount
     }),
     hasOverlappingSegments = _await$insertFunction.hasOverlappingSegments,
     arrayOfLabelMapImages = _await$insertFunction.arrayOfLabelMapImages;
@@ -145,38 +518,46 @@ async function createLabelmapsFromBufferInternal(referencedImageIds, arrayBuffer
     overlappingSegments: hasOverlappingSegments
   };
 }
-const throttledTriggerLoadProgressEvent = utilities$1.throttle(percentComplete => {
+const throttledTriggerLoadProgressEvent = utilities.throttle(percentComplete => {
   triggerEvent(eventTarget, Events.SEGMENTATION_LOAD_PROGRESS, {
     percentComplete
   });
 }, 200);
-function insertPixelDataPlanar(_ref4) {
-  let segmentsOnFrame = _ref4.segmentsOnFrame,
-    labelMapImages = _ref4.labelMapImages,
-    pixelDataChunks = _ref4.pixelDataChunks,
-    multiframe = _ref4.multiframe,
-    referencedImageIds = _ref4.referencedImageIds,
-    validOrientations = _ref4.validOrientations,
-    metadataProvider = _ref4.metadataProvider,
-    tolerance = _ref4.tolerance,
-    segmentsPixelIndices = _ref4.segmentsPixelIndices,
-    sopUIDImageIdIndexMap = _ref4.sopUIDImageIdIndexMap,
-    imageIdMaps = _ref4.imageIdMaps;
+function insertPixelDataPlanar(_ref0) {
+  let segmentsOnFrame = _ref0.segmentsOnFrame,
+    labelMapImages = _ref0.labelMapImages,
+    pixelDataChunks = _ref0.pixelDataChunks,
+    multiframe = _ref0.multiframe,
+    referencedImageIds = _ref0.referencedImageIds,
+    validOrientations = _ref0.validOrientations,
+    metadataProvider = _ref0.metadataProvider,
+    tolerance = _ref0.tolerance,
+    segmentsPixelIndices = _ref0.segmentsPixelIndices,
+    sopUIDImageIdIndexMap = _ref0.sopUIDImageIdIndexMap,
+    imageIdMaps = _ref0.imageIdMaps,
+    parserType = _ref0.parserType,
+    decodedFrameCount = _ref0.decodedFrameCount;
   const SharedFunctionalGroupsSequence = multiframe.SharedFunctionalGroupsSequence,
     PerFrameFunctionalGroupsSequence = multiframe.PerFrameFunctionalGroupsSequence,
     Rows = multiframe.Rows,
     Columns = multiframe.Columns;
   const sharedImageOrientationPatient = SharedFunctionalGroupsSequence.PlaneOrientationSequence ? SharedFunctionalGroupsSequence.PlaneOrientationSequence.ImageOrientationPatient : undefined;
   const sliceLength = Columns * Rows;
-  const groupsLen = PerFrameFunctionalGroupsSequence.length;
+  const metadataFrameCount = Number(multiframe.NumberOfFrames) || PerFrameFunctionalGroupsSequence.length;
+  const groupsLenFromMetadata = PerFrameFunctionalGroupsSequence.length || metadataFrameCount;
+  const groupsLen = typeof decodedFrameCount === 'number' ? Math.min(groupsLenFromMetadata, decodedFrameCount) : groupsLenFromMetadata;
   let overlapping = false;
   return new Promise(resolve => {
     const percentImagesPerChunk = 0.1;
     const imagesPerChunk = Math.ceil(groupsLen * percentImagesPerChunk);
     const processChunk = firstIndex => {
       for (let i = firstIndex; i < firstIndex + imagesPerChunk && i < groupsLen; i++) {
+        var _PerFrameFunctionalGr;
         const PerFrameFunctionalGroups = PerFrameFunctionalGroupsSequence[i];
-        const ImageOrientationPatientI = sharedImageOrientationPatient || PerFrameFunctionalGroups.PlaneOrientationSequence.ImageOrientationPatient;
+        const ImageOrientationPatientI = sharedImageOrientationPatient || (PerFrameFunctionalGroups === null || PerFrameFunctionalGroups === void 0 || (_PerFrameFunctionalGr = PerFrameFunctionalGroups.PlaneOrientationSequence) === null || _PerFrameFunctionalGr === void 0 ? void 0 : _PerFrameFunctionalGr.ImageOrientationPatient);
+        if (!ImageOrientationPatientI) {
+          throw new Error("SEG frame ".concat(i + 1, " is missing ImageOrientationPatient in per-frame and shared functional groups."));
+        }
         const view = readFromUnpackedChunks(pixelDataChunks, i * sliceLength, sliceLength);
         const pixelDataI2D = ndarray(view, [Rows, Columns]);
         const alignedPixelDataI = alignPixelDataWithSourceData(pixelDataI2D, ImageOrientationPatientI, validOrientations, tolerance);
@@ -190,16 +571,25 @@ function insertPixelDataPlanar(_ref4) {
         if (!segmentsPixelIndices.has(segmentIndex)) {
           segmentsPixelIndices.set(segmentIndex, {});
         }
-        const imageId = findReferenceSourceImageId(multiframe, i, referencedImageIds, metadataProvider, tolerance, sopUIDImageIdIndexMap);
+        let imageId = findReferenceSourceImageId(multiframe, i, referencedImageIds, metadataProvider, tolerance, sopUIDImageIdIndexMap);
         if (!imageId) {
           console.warn("Image not present in stack, can't import frame : " + i + '.');
-          return;
+          continue;
+        }
+        const stackImageId = ensureImageIdMapsEntry(imageId, referencedImageIds, imageIdMaps, metadataProvider);
+        if (!stackImageId) {
+          console.warn("Image not present in stack, can't import frame : ".concat(i, "."));
+          continue;
+        }
+        const sourceImageMetadata = imageIdMaps.metadata[stackImageId];
+        if (!sourceImageMetadata) {
+          console.warn("No instance metadata for referenced image at frame : ".concat(i, "."));
+          continue;
         }
-        const 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. ');
         }
-        const imageIdIndex = imageIdMaps.indices[imageId];
+        const imageIdIndex = imageIdMaps.indices[stackImageId];
         const labelmapImage = labelMapImages[imageIdIndex];
         const labelmap2DView = labelmapImage.getPixelData();
         const imageVoxelManager = labelmapImage.voxelManager;
@@ -260,26 +650,43 @@ function insertPixelDataPlanar(_ref4) {
       const pfSeq = multiframe.PerFrameFunctionalGroupsSequence;
       const sharedPlaneOrientation = (_multiframe$SharedFun = multiframe.SharedFunctionalGroupsSequence.PlaneOrientationSequence) === null || _multiframe$SharedFun === void 0 ? void 0 : _multiframe$SharedFun.ImageOrientationPatient;
       for (let i = firstIndex; i < firstIndex + imagesPerChunk && i < groupsLen; i++) {
+        var _PerFrameFunctionalGr2;
         const PerFrameFunctionalGroups = pfSeq[i];
-        const ImageOrientationPatientI = sharedPlaneOrientation || PerFrameFunctionalGroups.PlaneOrientationSequence.ImageOrientationPatient;
-        const view = pixelDataChunks.subarray(i * sliceLength, (i + 1) * sliceLength);
+        const ImageOrientationPatientI = sharedPlaneOrientation || (PerFrameFunctionalGroups === null || PerFrameFunctionalGroups === void 0 || (_PerFrameFunctionalGr2 = PerFrameFunctionalGroups.PlaneOrientationSequence) === null || _PerFrameFunctionalGr2 === void 0 ? void 0 : _PerFrameFunctionalGr2.ImageOrientationPatient) || validOrientations[0];
+        const view = readFromUnpackedChunks(pixelDataChunks, i * sliceLength, sliceLength);
         const pixelDataI2D = ndarray(view, [Rows, Columns]);
         const alignedPixelDataI = alignPixelDataWithSourceData(pixelDataI2D, ImageOrientationPatientI, validOrientations, tolerance);
         if (!alignedPixelDataI) {
           throw new Error('Individual Labelmap SEG frames are out of plane with respect to the first SEG frame. ' + 'This is not yet supported. Aborting segmentation loading.');
         }
-        const imageId = findReferenceSourceImageId(multiframe, i, referencedImageIds, metadataProvider, tolerance, sopUIDImageIdIndexMap);
+        let imageId = findReferenceSourceImageId(multiframe, i, referencedImageIds, metadataProvider, tolerance, sopUIDImageIdIndexMap);
         if (!imageId) {
+          imageId = getReferencedImageIdFromPerFrameGroup({
+            perFrameFunctionalGroup: PerFrameFunctionalGroups,
+            sopUIDImageIdIndexMap
+          });
+        }
+        if (!imageId) {
+          console.warn("Image not present in stack, can't import frame : ".concat(i, "."));
+          continue;
+        }
+        const stackImageId = ensureImageIdMapsEntry(imageId, referencedImageIds, imageIdMaps, metadataProvider);
+        if (!stackImageId) {
           console.warn("Image not present in stack, can't import frame : ".concat(i, "."));
           continue;
         }
-        const sourceImageMetadata = imageIdMaps.metadata[imageId];
+        const sourceImageMetadata = imageIdMaps.metadata[stackImageId];
+        if (!sourceImageMetadata) {
+          console.warn("No instance metadata for referenced image at frame : ".concat(i, "."));
+          continue;
+        }
         if (Rows !== sourceImageMetadata.Rows || Columns !== sourceImageMetadata.Columns) {
           throw new Error('Individual Labelmap 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 imageIdIndex = imageIdMaps.indices[imageId];
+        const imageIdIndex = imageIdMaps.indices[stackImageId];
         const labelmapImage = labelMapImages[imageIdIndex];
         const labelmap2DView = labelmapImage.getPixelData();
+        const imageVoxelManager = labelmapImage.voxelManager;
         const data = alignedPixelDataI.data;
         let segmentsOnFrameArr = segmentsOnFrame[imageIdIndex];
         if (!segmentsOnFrameArr) {
@@ -290,7 +697,11 @@ function insertPixelDataPlanar(_ref4) {
         for (let k = 0, len = data.length; k < len; ++k) {
           const segIdx = data[k];
           if (segIdx !== 0) {
-            labelmap2DView[k] = segIdx;
+            if (imageVoxelManager) {
+              imageVoxelManager.setAtIndex(k, segIdx);
+            } else {
+              labelmap2DView[k] = segIdx;
+            }
             if (!segSet.has(segIdx)) {
               segmentsOnFrameArr.push(segIdx);
               segSet.add(segIdx);
@@ -317,23 +728,24 @@ function insertPixelDataPlanar(_ref4) {
         });
       }
     };
-    if (multiframe.SegmentationType === 'LABELMAP') {
+    const isLabelmapSegmentation = parserType === 'labelmap' || multiframe.SOPClassUID === LABELMAP_SEG_SOP_CLASS_UID || multiframe.SegmentationType === 'LABELMAP';
+    if (isLabelmapSegmentation) {
       processLabelmapChunk(0);
     } else {
       processChunk(0);
     }
   });
 }
-const getAlignedPixelData = _ref5 => {
-  let sharedImageOrientationPatient = _ref5.sharedImageOrientationPatient,
-    PerFrameFunctionalGroups = _ref5.PerFrameFunctionalGroups,
-    pixelDataChunks = _ref5.pixelDataChunks,
-    sequenceIndex = _ref5.sequenceIndex,
-    sliceLength = _ref5.sliceLength,
-    Rows = _ref5.Rows,
-    Columns = _ref5.Columns,
-    validOrientations = _ref5.validOrientations,
-    tolerance = _ref5.tolerance;
+const getAlignedPixelData = _ref1 => {
+  let sharedImageOrientationPatient = _ref1.sharedImageOrientationPatient,
+    PerFrameFunctionalGroups = _ref1.PerFrameFunctionalGroups,
+    pixelDataChunks = _ref1.pixelDataChunks,
+    sequenceIndex = _ref1.sequenceIndex,
+    sliceLength = _ref1.sliceLength,
+    Rows = _ref1.Rows,
+    Columns = _ref1.Columns,
+    validOrientations = _ref1.validOrientations,
+    tolerance = _ref1.tolerance;
   const ImageOrientationPatientI = sharedImageOrientationPatient || PerFrameFunctionalGroups.PlaneOrientationSequence.ImageOrientationPatient;
   const view = readFromUnpackedChunks(pixelDataChunks, sequenceIndex * sliceLength, sliceLength);
   const pixelDataI2D = ndarray(view, [Rows, Columns]);
@@ -343,19 +755,19 @@ const getAlignedPixelData = _ref5 => {
   }
   return alignedPixelDataI;
 };
-const checkImageDimensions = _ref6 => {
-  let metadataProvider = _ref6.metadataProvider,
-    imageId = _ref6.imageId,
-    Rows = _ref6.Rows,
-    Columns = _ref6.Columns;
+const checkImageDimensions = _ref10 => {
+  let metadataProvider = _ref10.metadataProvider,
+    imageId = _ref10.imageId,
+    Rows = _ref10.Rows,
+    Columns = _ref10.Columns;
   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 = _ref7.arrayOfSegmentData,
-    referencedImageIds = _ref7.referencedImageIds;
+const getArrayOfLabelMapImagesWithSegmentData = _ref11 => {
+  let arrayOfSegmentData = _ref11.arrayOfSegmentData,
+    referencedImageIds = _ref11.referencedImageIds;
   let largestArray = [];
   for (let i = 0; i < arrayOfSegmentData.length; i++) {
     const segmentData = arrayOfSegmentData[i];
@@ -378,18 +790,18 @@ const getArrayOfLabelMapImagesWithSegmentData = _ref7 => {
     return labelMapImages;
   });
 };
-function insertOverlappingPixelDataPlanar(_ref8) {
-  let segmentsOnFrame = _ref8.segmentsOnFrame,
-    labelMapImages = _ref8.labelMapImages,
-    pixelDataChunks = _ref8.pixelDataChunks,
-    multiframe = _ref8.multiframe,
-    referencedImageIds = _ref8.referencedImageIds,
-    validOrientations = _ref8.validOrientations,
-    metadataProvider = _ref8.metadataProvider,
-    tolerance = _ref8.tolerance,
-    segmentsPixelIndices = _ref8.segmentsPixelIndices,
-    sopUIDImageIdIndexMap = _ref8.sopUIDImageIdIndexMap,
-    imageIdMaps = _ref8.imageIdMaps;
+function insertOverlappingPixelDataPlanar(_ref12) {
+  let segmentsOnFrame = _ref12.segmentsOnFrame,
+    labelMapImages = _ref12.labelMapImages,
+    pixelDataChunks = _ref12.pixelDataChunks,
+    multiframe = _ref12.multiframe,
+    referencedImageIds = _ref12.referencedImageIds,
+    validOrientations = _ref12.validOrientations,
+    metadataProvider = _ref12.metadataProvider,
+    tolerance = _ref12.tolerance,
+    segmentsPixelIndices = _ref12.segmentsPixelIndices,
+    sopUIDImageIdIndexMap = _ref12.sopUIDImageIdIndexMap,
+    imageIdMaps = _ref12.imageIdMaps;
   const SharedFunctionalGroupsSequence = multiframe.SharedFunctionalGroupsSequence,
     PerFrameFunctionalGroupsSequence = multiframe.PerFrameFunctionalGroupsSequence,
     Rows = multiframe.Rows,
@@ -422,22 +834,22 @@ function insertOverlappingPixelDataPlanar(_ref8) {
     hasOverlappingSegments: true
   };
 }
-const getArrayOfSegmentData = _ref9 => {
-  let sliceLength = _ref9.sliceLength,
-    Rows = _ref9.Rows,
-    Columns = _ref9.Columns,
-    validOrientations = _ref9.validOrientations,
-    metadataProvider = _ref9.metadataProvider,
-    imageIdMaps = _ref9.imageIdMaps,
-    segmentsOnFrame = _ref9.segmentsOnFrame,
-    tolerance = _ref9.tolerance,
-    pixelDataChunks = _ref9.pixelDataChunks,
-    PerFrameFunctionalGroupsSequence = _ref9.PerFrameFunctionalGroupsSequence,
-    labelMapImages = _ref9.labelMapImages,
-    sopUIDImageIdIndexMap = _ref9.sopUIDImageIdIndexMap,
-    multiframe = _ref9.multiframe,
-    sharedImageOrientationPatient = _ref9.sharedImageOrientationPatient,
-    segmentsPixelIndices = _ref9.segmentsPixelIndices;
+const getArrayOfSegmentData = _ref13 => {
+  let sliceLength = _ref13.sliceLength,
+    Rows = _ref13.Rows,
+    Columns = _ref13.Columns,
+    validOrientations = _ref13.validOrientations,
+    metadataProvider = _ref13.metadataProvider,
+    imageIdMaps = _ref13.imageIdMaps,
+    segmentsOnFrame = _ref13.segmentsOnFrame,
+    tolerance = _ref13.tolerance,
+    pixelDataChunks = _ref13.pixelDataChunks,
+    PerFrameFunctionalGroupsSequence = _ref13.PerFrameFunctionalGroupsSequence,
+    labelMapImages = _ref13.labelMapImages,
+    sopUIDImageIdIndexMap = _ref13.sopUIDImageIdIndexMap,
+    multiframe = _ref13.multiframe,
+    sharedImageOrientationPatient = _ref13.sharedImageOrientationPatient,
+    segmentsPixelIndices = _ref13.segmentsPixelIndices;
   const arrayOfSegmentData = [];
   const numberOfSegments = multiframe.SegmentSequence.length;
   for (let currentSegmentIndex = 1; currentSegmentIndex <= numberOfSegments; ++currentSegmentIndex) {
@@ -466,23 +878,23 @@ const getArrayOfSegmentData = _ref9 => {
   }
   return arrayOfSegmentData;
 };
-const getSegmentData = _ref0 => {
-  let PerFrameFunctionalGroupsSequence = _ref0.PerFrameFunctionalGroupsSequence,
-    labelMapImages = _ref0.labelMapImages,
-    sopUIDImageIdIndexMap = _ref0.sopUIDImageIdIndexMap,
-    multiframe = _ref0.multiframe,
-    segmentIndex = _ref0.segmentIndex,
-    sliceLength = _ref0.sliceLength,
-    Rows = _ref0.Rows,
-    Columns = _ref0.Columns,
-    validOrientations = _ref0.validOrientations,
-    tolerance = _ref0.tolerance,
-    pixelDataChunks = _ref0.pixelDataChunks,
-    sharedImageOrientationPatient = _ref0.sharedImageOrientationPatient,
-    metadataProvider = _ref0.metadataProvider,
-    imageIdMaps = _ref0.imageIdMaps,
-    segmentsOnFrame = _ref0.segmentsOnFrame,
-    segmentsPixelIndices = _ref0.segmentsPixelIndices;
+const getSegmentData = _ref14 => {
+  let PerFrameFunctionalGroupsSequence = _ref14.PerFrameFunctionalGroupsSequence,
+    labelMapImages = _ref14.labelMapImages,
+    sopUIDImageIdIndexMap = _ref14.sopUIDImageIdIndexMap,
+    multiframe = _ref14.multiframe,
+    segmentIndex = _ref14.segmentIndex,
+    sliceLength = _ref14.sliceLength,
+    Rows = _ref14.Rows,
+    Columns = _ref14.Columns,
+    validOrientations = _ref14.validOrientations,
+    tolerance = _ref14.tolerance,
+    pixelDataChunks = _ref14.pixelDataChunks,
+    sharedImageOrientationPatient = _ref14.sharedImageOrientationPatient,
+    metadataProvider = _ref14.metadataProvider,
+    imageIdMaps = _ref14.imageIdMaps,
+    segmentsOnFrame = _ref14.segmentsOnFrame,
+    segmentsPixelIndices = _ref14.segmentsPixelIndices;
   const segmentData = [];
   for (let currentLabelMapImageIndex = 0; currentLabelMapImageIndex < labelMapImages.length; currentLabelMapImageIndex++) {
     const currentLabelMapImage = labelMapImages[currentLabelMapImageIndex];
@@ -547,5 +959,25 @@ const getSegmentData = _ref0 => {
   }
   return segmentData;
 };
+async function createLabelmapsFromDICOMBuffer(referencedImageIds, arrayBuffer, metadataProvider) {
+  var _options$segImageId;
+  let options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  const dicomData = DicomMessage.readFile(arrayBuffer);
+  const dataset = DicomMetaDictionary.naturalizeDataset(dicomData.dict);
+  dataset._meta = DicomMetaDictionary.namifyDataset(dicomData.meta);
+  const multiframe = Normalizer.normalizeToDataset([dataset]);
+  const segImageId = (_options$segImageId = options.segImageId) !== null && _options$segImageId !== void 0 ? _options$segImageId : BUFFER_SEG_IMAGE_ID;
+  ensureInstanceOnMetadataProvider(metadataProvider, segImageId, multiframe);
+  const numberOfFrames = getSegNumberOfFramesFromDataset(multiframe);
+  const frameImageIds = Array.from({
+    length: numberOfFrames
+  }, (_, index) => "".concat(segImageId, "#frame=").concat(index + 1));
+  const decodeImageData = createDecodeImageDataFromMultiframe(multiframe);
+  return createLabelmapsFromSegImageIds(referencedImageIds, segImageId, metadataProvider, _objectSpread(_objectSpread({}, options), {}, {
+    frameImageIds,
+    decodeImageData,
+    multiframe
+  }));
+}
 
-export { createLabelmapsFromBufferInternal, insertOverlappingPixelDataPlanar, insertPixelDataPlanar };
+export { buildSopUIDImageIdIndexMap, createLabelmapsFromDICOMBuffer, createLabelmapsFromSegImageIds, decodeSegPixelDataFromFrameIds, insertOverlappingPixelDataPlanar, insertPixelDataPlanar, isPseudoBinaryFractional, resolveFrameImageIds };