@cornerstonejs/adapters 5.4.10 → 5.4.12

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

@@ -0,0 +1,17 @@
+export function getReferencedFrameNumber(imageId: string, metadata: object): number | undefined;
+export function getReferencedSourceImageSequenceItem(image: {
+    imageId?: string;
+}, metadata: object): {
+    ReferencedSOPInstanceUID: string;
+    ReferencedFrameNumber?: number;
+};
+export function normalizeSharedFunctionalGroupsSequence(dataset: any): void;
+export function applyPerFrameFunctionalGroups(dataset: object, frames: Array<{
+    referencedSegmentNumber?: number;
+    sourceImageSequenceItem: {
+        ReferencedSOPInstanceUID: string;
+        ReferencedFrameNumber?: number;
+    };
+    planeOrientationSequence?: object;
+    planePositionSequence?: object;
+}>): void;

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

@@ -0,0 +1,116 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import _objectWithoutProperties from '@babel/runtime/helpers/objectWithoutProperties';
+import { Enums, utilities } from '@cornerstonejs/core';
+
+const _excluded = ["SegmentIdentificationSequence"];
+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;
+
+/**
+ * Resolves the 1-based DICOM frame number referenced by an imageId.
+ *
+ * Prefer the metadata provider's own frame extraction when it offers one — it
+ * understands the full set of imageId shapes the host app produces (wadors
+ * `/frames/N` as well as `?frame=N` / `&frame=N`). Fall back to the core
+ * FrameRange helper (handles `/frames/N` and `frameNumber=N`) so that
+ * provider-agnostic callers still resolve multi-frame references. A one-off
+ * `/[?&]frame=/` regex silently drops the wadors form, so it must not be used.
+ *
+ * @param {string} imageId
+ * @param {object} metadata - metadata provider
+ * @returns {number|undefined}
+ */
+function getReferencedFrameNumber(imageId, metadata) {
+  var _metadata$getFrameInf;
+  if (!imageId) {
+    return undefined;
+  }
+  const providerFrame = metadata === null || metadata === void 0 || (_metadata$getFrameInf = metadata.getFrameInformationFromURL) === null || _metadata$getFrameInf === void 0 ? void 0 : _metadata$getFrameInf.call(metadata, imageId);
+  const frameNumber = providerFrame != null ? Number(providerFrame) : utilities.FrameRange.imageIdToFrameStart(imageId);
+  return Number.isFinite(frameNumber) ? frameNumber : undefined;
+}
+
+/**
+ * Builds a SourceImageSequence item (ReferencedSOPInstanceUID + optional
+ * ReferencedFrameNumber) for a cornerstone image, using the shared frame
+ * extraction so all SEG export paths resolve multi-frame references identically.
+ *
+ * @param {{ imageId?: string }} image
+ * @param {object} metadata - metadata provider
+ * @returns {{ ReferencedSOPInstanceUID: string, ReferencedFrameNumber?: number }}
+ */
+function getReferencedSourceImageSequenceItem(image, metadata) {
+  var _metadata$get;
+  const imageData = (metadata === null || metadata === void 0 || (_metadata$get = metadata.get) === null || _metadata$get === void 0 ? void 0 : _metadata$get.call(metadata, MetadataModules.IMAGE_DATA, image === null || image === void 0 ? void 0 : image.imageId)) || {};
+  const referencedFrameNumber = getReferencedFrameNumber(image === null || image === void 0 ? void 0 : image.imageId, metadata);
+  const item = {
+    ReferencedSOPInstanceUID: imageData.SOPInstanceUID
+  };
+  if (Number.isFinite(referencedFrameNumber) && referencedFrameNumber > 0) {
+    item.ReferencedFrameNumber = referencedFrameNumber;
+  }
+  return item;
+}
+function normalizeSharedFunctionalGroupsSequence(dataset) {
+  const shared = dataset.SharedFunctionalGroupsSequence;
+  if (Array.isArray(shared) && shared.length > 0) {
+    dataset.SharedFunctionalGroupsSequence = shared[0];
+  } else if (!shared || typeof shared !== 'object') {
+    dataset.SharedFunctionalGroupsSequence = {};
+  }
+}
+
+/**
+ * @param {object} dataset - SEG dataset
+ * @param {Array<{
+ *   referencedSegmentNumber?: number,
+ *   sourceImageSequenceItem: { ReferencedSOPInstanceUID: string, ReferencedFrameNumber?: number },
+ *   planeOrientationSequence?: object,
+ *   planePositionSequence?: object,
+ * }>} frames
+ *
+ * `referencedSegmentNumber` drives the per-frame `SegmentIdentificationSequence`
+ * macro (one segment per frame — BINARY SEGs). Omit it for LABELMAP SEGs: there a
+ * single frame carries many segment labels as pixel values, so the standard
+ * forbids the macro and a fixed `ReferencedSegmentNumber` would be wrong for any
+ * label other than the one hard-coded.
+ */
+function applyPerFrameFunctionalGroups(dataset, frames) {
+  normalizeSharedFunctionalGroupsSequence(dataset);
+  const validFrames = frames.filter(frame => {
+    var _frame$sourceImageSeq;
+    return frame === null || frame === void 0 || (_frame$sourceImageSeq = frame.sourceImageSequenceItem) === null || _frame$sourceImageSeq === void 0 ? void 0 : _frame$sourceImageSeq.ReferencedSOPInstanceUID;
+  });
+  const existing = dataset.PerFrameFunctionalGroupsSequence;
+  const existingList = Array.isArray(existing) ? existing : [];
+  const nextSequence = validFrames.map((frame, index) => {
+    const prior = existingList[index] && typeof existingList[index] === 'object' ? existingList[index] : {};
+
+    // Drop any inherited SegmentIdentificationSequence when this frame has no
+    // referencedSegmentNumber (LABELMAP path) so the macro is truly absent.
+    prior.SegmentIdentificationSequence;
+      const priorRest = _objectWithoutProperties(prior, _excluded);
+    const group = _objectSpread(_objectSpread({}, priorRest), {}, {
+      DerivationImageSequence: [{
+        SourceImageSequence: [frame.sourceImageSequenceItem]
+      }]
+    });
+    if (frame.referencedSegmentNumber != null) {
+      group.SegmentIdentificationSequence = {
+        ReferencedSegmentNumber: frame.referencedSegmentNumber
+      };
+    }
+    if (frame.planeOrientationSequence) {
+      group.PlaneOrientationSequence = frame.planeOrientationSequence;
+    }
+    if (frame.planePositionSequence) {
+      group.PlanePositionSequence = frame.planePositionSequence;
+    }
+    return group;
+  });
+  dataset.PerFrameFunctionalGroupsSequence = nextSequence;
+  dataset.NumberOfFrames = nextSequence.length;
+}
+
+export { applyPerFrameFunctionalGroups, getReferencedFrameNumber, getReferencedSourceImageSequenceItem, normalizeSharedFunctionalGroupsSequence };

package/dist/esm/adapters/Cornerstone3D/encodePixelData.d.ts

@@ -0,0 +1,46 @@
+declare const RLE_LOSSLESS_TRANSFER_SYNTAX_UID = "1.2.840.10008.1.2.5";
+declare const EXPLICIT_VR_LITTLE_ENDIAN_TRANSFER_SYNTAX_UID: any;
+declare function getSegNumberOfFramesFromDataset(multiframe: Record<string, unknown>): number;
+declare function decodeSegFramesFromMultiframe(multiframe: Record<string, unknown>): ArrayLike<number>[];
+declare function createDecodeImageDataFromMultiframe(multiframe: Record<string, unknown>): (_frameImageId: string, frameNumber: number) => Promise<ArrayLike<number>>;
+declare function unpackBinaryFrameFromPacked(packed: Uint8Array, samplesPerFrame: number): Uint8Array;
+declare function getBitmapFramesFromDataset(dataset: {
+    NumberOfFrames?: number | string;
+    Rows?: number | string;
+    Columns?: number | string;
+    BitsAllocated?: number | string;
+    PixelData?: unknown;
+}): {
+    frames: Uint8Array[];
+    bitsAllocated: number;
+} | {
+    frames: Uint16Array[];
+    bitsAllocated: number;
+};
+declare function packBits(samples: ArrayLike<number>, rowLength?: number): Uint8Array;
+declare function bitPackBinaryFrame(frame: ArrayLike<number>): Uint8Array;
+declare function encodeFrameToRle(frame: ArrayLike<number>, bitsAllocated: number, columns?: number): ArrayBufferLike;
+export declare function isUncompressedSegTransferSyntax(transferSyntaxUID: string): boolean;
+type EncodeFramesToTransferSyntaxArgs = {
+    transferSyntaxUID: string;
+    bitsAllocated: number;
+    columns?: number;
+} & ({
+    frames: ArrayLike<number>[];
+    buildFrame?: never;
+    frameCount?: never;
+} | {
+    frames?: never;
+    buildFrame: (frameIndex: number) => ArrayLike<number>;
+    frameCount: number;
+});
+export declare function encodeFramesToTransferSyntax(args: EncodeFramesToTransferSyntaxArgs): {
+    transferSyntaxUID: string;
+    pixelDataVR: string;
+    pixelData: Uint8Array | Uint16Array;
+} | {
+    transferSyntaxUID: string;
+    pixelDataVR: string;
+    pixelData: ArrayBuffer[];
+};
+export { RLE_LOSSLESS_TRANSFER_SYNTAX_UID, EXPLICIT_VR_LITTLE_ENDIAN_TRANSFER_SYNTAX_UID, getBitmapFramesFromDataset, bitPackBinaryFrame, unpackBinaryFrameFromPacked, decodeSegFramesFromMultiframe, createDecodeImageDataFromMultiframe, getSegNumberOfFramesFromDataset, packBits, encodeFrameToRle, };

package/dist/esm/adapters/Cornerstone3D/encodePixelData.js

@@ -0,0 +1,440 @@
+import { constants } from 'dcmjs';
+
+const RLE_LOSSLESS_TRANSFER_SYNTAX_UID = '1.2.840.10008.1.2.5';
+const EXPLICIT_VR_LITTLE_ENDIAN_TRANSFER_SYNTAX_UID = constants.EXPLICIT_LITTLE_ENDIAN;
+function getTransferSyntaxUid(multiframe) {
+  var _meta$TransferSyntaxU;
+  const meta = multiframe._meta;
+  const fromMeta = meta === null || meta === void 0 || (_meta$TransferSyntaxU = meta.TransferSyntaxUID) === null || _meta$TransferSyntaxU === void 0 || (_meta$TransferSyntaxU = _meta$TransferSyntaxU.Value) === null || _meta$TransferSyntaxU === void 0 ? void 0 : _meta$TransferSyntaxU[0];
+  if (fromMeta) {
+    return fromMeta;
+  }
+  if (typeof multiframe.TransferSyntaxUID === 'string') {
+    return multiframe.TransferSyntaxUID;
+  }
+  return EXPLICIT_VR_LITTLE_ENDIAN_TRANSFER_SYNTAX_UID;
+}
+function getSegNumberOfFramesFromDataset(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 decodeRlePackBitsSegment(data, start, end, outLength) {
+  const out = new Uint8Array(outLength);
+  let outIndex = 0;
+  let inIndex = start;
+  while (inIndex < end && outIndex < outLength) {
+    const n = data[inIndex++];
+    if (n >= 0 && n <= 127) {
+      for (let i = 0; i < n + 1 && outIndex < outLength; ++i) {
+        out[outIndex++] = data[inIndex++] & 0xff;
+      }
+    } else if (n <= -1 && n >= -127) {
+      const value = data[inIndex++] & 0xff;
+      for (let j = 0; j < -n + 1 && outIndex < outLength; ++j) {
+        out[outIndex++] = value;
+      }
+    }
+  }
+  return out;
+}
+function decodeRleLosslessToPackedBytes(rleData, packedByteLength) {
+  const frameData = rleData instanceof Uint8Array ? rleData : new Uint8Array(rleData);
+  const header = new DataView(frameData.buffer, frameData.byteOffset, frameData.byteLength);
+  const data = new Int8Array(frameData.buffer, frameData.byteOffset, frameData.byteLength);
+  const numSegments = header.getInt32(0, true);
+  if (numSegments !== 1) {
+    throw new Error("Expected a single RLE segment for SEG re-encode, got ".concat(numSegments));
+  }
+  const start = header.getInt32(4, true);
+  let end = header.getInt32(8, true);
+  if (end === 0) {
+    end = frameData.length;
+  }
+  return decodeRlePackBitsSegment(data, start, end, packedByteLength);
+}
+function decodeRleMultiByteFrame(rleData, samplesPerFrame, bitsAllocated) {
+  const frameData = rleData instanceof Uint8Array ? rleData : new Uint8Array(rleData);
+  const header = new DataView(frameData.buffer, frameData.byteOffset, frameData.byteLength);
+  const data = new Int8Array(frameData.buffer, frameData.byteOffset, frameData.byteLength);
+  const numSegments = header.getInt32(0, true);
+  const bytesPerSample = Math.ceil(bitsAllocated / 8);
+  if (numSegments !== bytesPerSample) {
+    throw new Error("Expected ".concat(bytesPerSample, " RLE segment(s) for ").concat(bitsAllocated, "-bit SEG, got ").concat(numSegments));
+  }
+  const segmentStart = index => header.getInt32(4 + index * 4, true);
+  if (bitsAllocated <= 8) {
+    return decodeRlePackBitsSegment(data, segmentStart(0), frameData.length, samplesPerFrame);
+  }
+  const highStart = segmentStart(0);
+  const lowStart = segmentStart(1);
+  const highBytes = decodeRlePackBitsSegment(data, highStart, lowStart, samplesPerFrame);
+  const lowBytes = decodeRlePackBitsSegment(data, lowStart, frameData.length, samplesPerFrame);
+  const frame = new Uint16Array(samplesPerFrame);
+  for (let i = 0; i < samplesPerFrame; i++) {
+    frame[i] = (highBytes[i] << 8 | lowBytes[i]) & 0xffff;
+  }
+  return frame;
+}
+function decodeSegFramesFromMultiframe(multiframe) {
+  const rows = Number(multiframe.Rows);
+  const columns = Number(multiframe.Columns);
+  const samplesPerFrame = rows * columns;
+  const bitsAllocated = Number(multiframe.BitsAllocated);
+  const numberOfFrames = getSegNumberOfFramesFromDataset(multiframe);
+  const transferSyntaxUid = getTransferSyntaxUid(multiframe);
+  if (!multiframe.PixelData) {
+    throw new Error('SEG dataset has no PixelData');
+  }
+  if (bitsAllocated === 1) {
+    if (transferSyntaxUid === RLE_LOSSLESS_TRANSFER_SYNTAX_UID) {
+      const encodedFrames = Array.isArray(multiframe.PixelData) ? multiframe.PixelData : [multiframe.PixelData];
+      const bytesPerFrame = getBytesForBinaryFrame(samplesPerFrame);
+      const frames = [];
+      for (let frameIndex = 0; frameIndex < numberOfFrames; frameIndex++) {
+        const rleFrame = encodedFrames[frameIndex];
+        if (!rleFrame) {
+          frames.push(new Uint8Array(samplesPerFrame));
+          continue;
+        }
+        const packed = decodeRleLosslessToPackedBytes(rleFrame, bytesPerFrame);
+        frames.push(unpackBinaryFrameFromPacked(packed, samplesPerFrame));
+      }
+      return frames;
+    }
+    return getBitmapFramesFromDataset(multiframe).frames;
+  }
+  if (transferSyntaxUid === RLE_LOSSLESS_TRANSFER_SYNTAX_UID) {
+    const encodedFrames = Array.isArray(multiframe.PixelData) ? multiframe.PixelData : [multiframe.PixelData];
+    const frames = [];
+    for (let frameIndex = 0; frameIndex < numberOfFrames; frameIndex++) {
+      const rleFrame = encodedFrames[frameIndex];
+      if (!rleFrame) {
+        frames.push(bitsAllocated <= 8 ? new Uint8Array(samplesPerFrame) : new Uint16Array(samplesPerFrame));
+        continue;
+      }
+      frames.push(decodeRleMultiByteFrame(rleFrame, samplesPerFrame, bitsAllocated));
+    }
+    return frames;
+  }
+  return getBitmapFramesFromDataset(multiframe).frames;
+}
+function createDecodeImageDataFromMultiframe(multiframe) {
+  let cachedFrames = null;
+  return async (_frameImageId, frameNumber) => {
+    if (!cachedFrames) {
+      cachedFrames = decodeSegFramesFromMultiframe(multiframe);
+    }
+    const frame = cachedFrames[frameNumber - 1];
+    if (!frame) {
+      throw new Error("No SEG frame at index ".concat(frameNumber));
+    }
+    return frame;
+  };
+}
+function getBytesForBinaryFrame(numPixels) {
+  return Math.ceil(numPixels / 8);
+}
+function asUint8PixelData(pixelData) {
+  if (pixelData instanceof Uint8Array) {
+    return pixelData;
+  }
+  if (pixelData instanceof ArrayBuffer) {
+    return new Uint8Array(pixelData);
+  }
+  if (Array.isArray(pixelData)) {
+    if (pixelData.length === 1) {
+      return new Uint8Array(pixelData[0]);
+    }
+    throw new Error('Multiframe encapsulated PixelData fragments cannot be converted to binary frames for re-encoding');
+  }
+  return new Uint8Array(pixelData);
+}
+function normalizeBinaryFrameTo01(frame) {
+  const normalized = new Uint8Array(frame.length);
+  for (let i = 0; i < frame.length; i++) {
+    normalized[i] = frame[i] ? 1 : 0;
+  }
+  return normalized;
+}
+function unpackBinaryFrameFromPacked(packed, samplesPerFrame) {
+  const frame = new Uint8Array(samplesPerFrame);
+  for (let i = 0; i < samplesPerFrame; i++) {
+    const bytePos = i >> 3;
+    const bitPos = i % 8;
+    frame[i] = packed[bytePos] & 1 << bitPos ? 1 : 0;
+  }
+  return frame;
+}
+function unpackBinaryFrameFromContinuousPack(packed, samplesPerFrame, frameIndex) {
+  const frame = new Uint8Array(samplesPerFrame);
+  const bitOffset = frameIndex * samplesPerFrame;
+  for (let i = 0; i < samplesPerFrame; i++) {
+    const bitIndex = bitOffset + i;
+    const bytePos = bitIndex >> 3;
+    const bitPos = bitIndex % 8;
+    frame[i] = packed[bytePos] & 1 << bitPos ? 1 : 0;
+  }
+  return frame;
+}
+function getBitmapFramesFromDataset(dataset) {
+  const numberOfFrames = Number(dataset.NumberOfFrames) || 1;
+  const rows = Number(dataset.Rows);
+  const columns = Number(dataset.Columns);
+  const samplesPerFrame = rows * columns;
+  const bitsAllocated = Number(dataset.BitsAllocated);
+  if (!dataset.PixelData) {
+    throw new Error('Bitmap SEG dataset has no PixelData');
+  }
+  if (bitsAllocated === 1) {
+    const buffer = asUint8PixelData(dataset.PixelData);
+    const bytesPerFrame = getBytesForBinaryFrame(samplesPerFrame);
+    const unpackedFrameBytes = samplesPerFrame * numberOfFrames;
+    const perFramePackedBytes = bytesPerFrame * numberOfFrames;
+    const continuousPackedBytes = getBytesForBinaryFrame(samplesPerFrame * numberOfFrames);
+    const frames = [];
+    if (buffer.length === unpackedFrameBytes) {
+      for (let frameIndex = 0; frameIndex < numberOfFrames; frameIndex++) {
+        const start = frameIndex * samplesPerFrame;
+        frames.push(normalizeBinaryFrameTo01(buffer.subarray(start, start + samplesPerFrame)));
+      }
+    } else if (buffer.length === perFramePackedBytes) {
+      for (let frameIndex = 0; frameIndex < numberOfFrames; frameIndex++) {
+        const framePacked = buffer.subarray(frameIndex * bytesPerFrame, (frameIndex + 1) * bytesPerFrame);
+        frames.push(unpackBinaryFrameFromPacked(framePacked, samplesPerFrame));
+      }
+    } else if (buffer.length === continuousPackedBytes) {
+      for (let frameIndex = 0; frameIndex < numberOfFrames; frameIndex++) {
+        frames.push(unpackBinaryFrameFromContinuousPack(buffer, samplesPerFrame, frameIndex));
+      }
+    } else {
+      throw new Error("Unexpected 1-bit SEG PixelData length ".concat(buffer.length, " for ").concat(numberOfFrames, " frame(s) of ").concat(samplesPerFrame, " pixels"));
+    }
+    return {
+      frames,
+      bitsAllocated
+    };
+  }
+  if (bitsAllocated <= 8) {
+    const buffer = asUint8PixelData(dataset.PixelData);
+    const frames = [];
+    for (let frameIndex = 0; frameIndex < numberOfFrames; frameIndex++) {
+      const start = frameIndex * samplesPerFrame;
+      frames.push(buffer.slice(start, start + samplesPerFrame));
+    }
+    return {
+      frames,
+      bitsAllocated
+    };
+  }
+  let buffer;
+  if (dataset.PixelData instanceof Uint16Array) {
+    buffer = dataset.PixelData;
+  } else {
+    const bytes = asUint8PixelData(dataset.PixelData);
+    buffer = new Uint16Array(bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength));
+  }
+  const frames = [];
+  for (let frameIndex = 0; frameIndex < numberOfFrames; frameIndex++) {
+    const start = frameIndex * samplesPerFrame;
+    frames.push(buffer.slice(start, start + samplesPerFrame));
+  }
+  return {
+    frames,
+    bitsAllocated
+  };
+}
+function packBitsRange(samples, start, end, output) {
+  let i = start;
+  while (i < end) {
+    let replicateRunLength = 1;
+    while (i + replicateRunLength < end && replicateRunLength < 128 && samples[i + replicateRunLength] === samples[i]) {
+      replicateRunLength++;
+    }
+    if (replicateRunLength >= 2) {
+      output.push(257 - replicateRunLength, samples[i] & 0xff);
+      i += replicateRunLength;
+      continue;
+    }
+    const literalStart = i;
+    i++;
+    while (i < end) {
+      replicateRunLength = 1;
+      while (i + replicateRunLength < end && replicateRunLength < 128 && samples[i + replicateRunLength] === samples[i]) {
+        replicateRunLength++;
+      }
+      if (replicateRunLength >= 2 || i - literalStart >= 128) {
+        break;
+      }
+      i++;
+    }
+    const literalLength = i - literalStart;
+    output.push(literalLength - 1);
+    for (let j = literalStart; j < i; j++) {
+      output.push(samples[j] & 0xff);
+    }
+  }
+}
+function packBits(samples, rowLength) {
+  const output = [];
+  const total = samples.length;
+  if (rowLength && rowLength > 0 && total % rowLength === 0) {
+    for (let start = 0; start < total; start += rowLength) {
+      packBitsRange(samples, start, start + rowLength, output);
+    }
+  } else {
+    packBitsRange(samples, 0, total, output);
+  }
+  return Uint8Array.from(output);
+}
+function bitPackBinaryFrame(frame) {
+  const packedLength = Math.ceil(frame.length / 8);
+  const packed = new Uint8Array(packedLength);
+  for (let i = 0; i < frame.length; i++) {
+    if (frame[i]) {
+      packed[i >> 3] |= 1 << i % 8;
+    }
+  }
+  return packed;
+}
+function concatUint8Frames(frames) {
+  const totalLength = frames.reduce((sum, frame) => sum + frame.length, 0);
+  const combined = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const frame of frames) {
+    for (let i = 0; i < frame.length; i++) {
+      combined[offset + i] = frame[i] & 0xff;
+    }
+    offset += frame.length;
+  }
+  return combined;
+}
+function concatUint16Frames(frames) {
+  const totalLength = frames.reduce((sum, frame) => sum + frame.length, 0);
+  const combined = new Uint16Array(totalLength);
+  let offset = 0;
+  for (const frame of frames) {
+    for (let i = 0; i < frame.length; i++) {
+      combined[offset + i] = frame[i] & 0xffff;
+    }
+    offset += frame.length;
+  }
+  return combined;
+}
+function getRleSegmentsForFrame(frame, bitsAllocated) {
+  if (bitsAllocated === 1) {
+    return [bitPackBinaryFrame(frame)];
+  }
+  if (bitsAllocated === 8) {
+    const segment = new Uint8Array(frame.length);
+    for (let i = 0; i < frame.length; i++) {
+      segment[i] = frame[i] & 0xff;
+    }
+    return [segment];
+  }
+  if (bitsAllocated === 16) {
+    const highByteSegment = new Uint8Array(frame.length);
+    const lowByteSegment = new Uint8Array(frame.length);
+    for (let i = 0; i < frame.length; i++) {
+      const sample = frame[i] & 0xffff;
+      highByteSegment[i] = sample >> 8 & 0xff;
+      lowByteSegment[i] = sample & 0xff;
+    }
+    return [highByteSegment, lowByteSegment];
+  }
+  throw new Error("Unsupported bitsAllocated for RLE encoding: ".concat(bitsAllocated, ". Expected 1, 8, or 16."));
+}
+function encodeFrameToRle(frame, bitsAllocated, columns) {
+  const segmentPlanes = getRleSegmentsForFrame(frame, bitsAllocated);
+  if (segmentPlanes.length > 15) {
+    throw new Error("RLE segment count ".concat(segmentPlanes.length, " exceeds DICOM maximum of 15 segments"));
+  }
+  const rowLength = columns && columns > 0 ? bitsAllocated === 1 ? columns % 8 === 0 ? columns / 8 : undefined : columns : undefined;
+  const encodedSegments = segmentPlanes.map(segment => {
+    const encoded = packBits(segment, rowLength);
+    if (encoded.length % 2 === 0) {
+      return encoded;
+    }
+    const padded = new Uint8Array(encoded.length + 1);
+    padded.set(encoded, 0);
+    return padded;
+  });
+  const header = new DataView(new ArrayBuffer(64));
+  header.setUint32(0, encodedSegments.length, true);
+  let offset = 64;
+  for (let i = 0; i < encodedSegments.length; i++) {
+    header.setUint32((i + 1) * 4, offset, true);
+    offset += encodedSegments[i].length;
+  }
+  const frameBytes = new Uint8Array(offset);
+  frameBytes.set(new Uint8Array(header.buffer), 0);
+  let writeOffset = 64;
+  for (let i = 0; i < encodedSegments.length; i++) {
+    frameBytes.set(encodedSegments[i], writeOffset);
+    writeOffset += encodedSegments[i].length;
+  }
+  return frameBytes.buffer;
+}
+function isUncompressedSegTransferSyntax(transferSyntaxUID) {
+  return transferSyntaxUID === EXPLICIT_VR_LITTLE_ENDIAN_TRANSFER_SYNTAX_UID;
+}
+function resolveFrameAtIndex(args, frameIndex) {
+  if (args.frames) {
+    return args.frames[frameIndex];
+  }
+  return args.buildFrame(frameIndex);
+}
+function materializeAllFrames(args) {
+  var _args$frames$length, _args$frames;
+  const frameCount = (_args$frames$length = (_args$frames = args.frames) === null || _args$frames === void 0 ? void 0 : _args$frames.length) !== null && _args$frames$length !== void 0 ? _args$frames$length : args.frameCount;
+  return Array.from({
+    length: frameCount
+  }, (_, frameIndex) => resolveFrameAtIndex(args, frameIndex));
+}
+function encodeCompressedFrameToTransferSyntax(frame, transferSyntaxUID, bitsAllocated, columns) {
+  if (transferSyntaxUID === RLE_LOSSLESS_TRANSFER_SYNTAX_UID) {
+    return encodeFrameToRle(frame, bitsAllocated, columns);
+  }
+  throw new Error("Unsupported compressed transfer syntax for SEG encoding: ".concat(transferSyntaxUID, ". ") + "Supported: ".concat(RLE_LOSSLESS_TRANSFER_SYNTAX_UID));
+}
+function encodeFramesToTransferSyntax(args) {
+  var _args$frames$length2, _args$frames2;
+  const transferSyntaxUID = args.transferSyntaxUID,
+    bitsAllocated = args.bitsAllocated,
+    columns = args.columns;
+  const frameCount = (_args$frames$length2 = (_args$frames2 = args.frames) === null || _args$frames2 === void 0 ? void 0 : _args$frames2.length) !== null && _args$frames$length2 !== void 0 ? _args$frames$length2 : args.frameCount;
+  if (isUncompressedSegTransferSyntax(transferSyntaxUID)) {
+    const frames = materializeAllFrames(args);
+    if (bitsAllocated === 1) {
+      const packedFrames = frames.map(frame => bitPackBinaryFrame(frame));
+      const combinedPacked = concatUint8Frames(packedFrames);
+      return {
+        transferSyntaxUID,
+        pixelDataVR: 'OW',
+        pixelData: combinedPacked
+      };
+    }
+    return {
+      transferSyntaxUID,
+      pixelDataVR: bitsAllocated <= 8 ? 'OB' : 'OW',
+      pixelData: bitsAllocated <= 8 ? concatUint8Frames(frames) : concatUint16Frames(frames)
+    };
+  }
+  const pixelData = [];
+  for (let frameIndex = 0; frameIndex < frameCount; frameIndex++) {
+    pixelData.push(encodeCompressedFrameToTransferSyntax(resolveFrameAtIndex(args, frameIndex), transferSyntaxUID, bitsAllocated, columns));
+  }
+  return {
+    transferSyntaxUID,
+    pixelDataVR: 'OB',
+    pixelData
+  };
+}
+
+export { EXPLICIT_VR_LITTLE_ENDIAN_TRANSFER_SYNTAX_UID, RLE_LOSSLESS_TRANSFER_SYNTAX_UID, bitPackBinaryFrame, createDecodeImageDataFromMultiframe, decodeSegFramesFromMultiframe, encodeFrameToRle, encodeFramesToTransferSyntax, getBitmapFramesFromDataset, getSegNumberOfFramesFromDataset, isUncompressedSegTransferSyntax, packBits, unpackBinaryFrameFromPacked };

package/dist/esm/version.d.ts

@@ -1 +1 @@
-export declare const version = "5.4.10";
+export declare const version = "5.4.12";

package/dist/esm/version.js

@@ -1,3 +1,3 @@
-const version = '5.4.10';
+const version = '5.4.12';
 
 export { version };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/adapters",
-  "version": "5.4.10",
+  "version": "5.4.12",
   "description": "Adapters for Cornerstone3D to/from formats including DICOM SR and others",
   "module": "./dist/esm/index.js",
   "types": "./dist/esm/index.d.ts",
@@ -94,17 +94,17 @@
   "dependencies": {
     "@babel/runtime-corejs2": "7.26.10",
     "buffer": "6.0.3",
-    "dcmjs": "0.50.1",
+    "dcmjs": "0.52.0",
     "gl-matrix": "3.4.3",
     "ndarray": "1.0.19"
   },
   "devDependencies": {
-    "@cornerstonejs/core": "5.4.10",
-    "@cornerstonejs/tools": "5.4.10"
+    "@cornerstonejs/core": "5.4.12",
+    "@cornerstonejs/tools": "5.4.12"
   },
   "peerDependencies": {
-    "@cornerstonejs/core": "5.4.10",
-    "@cornerstonejs/tools": "5.4.10"
+    "@cornerstonejs/core": "5.4.12",
+    "@cornerstonejs/tools": "5.4.12"
   },
-  "gitHead": "523becb5856f2b6bb5f58c08eb2b5c66bd0b17e1"
+  "gitHead": "0b67d01ebc033cc338c3612c1237b5d94025cac2"
 }