@cornerstonejs/adapters 4.11.1 → 4.11.3

package/dist/esm/adapters/Cornerstone3D/RTStruct/RTSS.js

@@ -1,20 +1,29 @@
-import { utilities } from '@cornerstonejs/tools';
-import dcmjs from 'dcmjs';
-import getPatientModule from './utilities/getPatientModule.js';
+import { metaData, Enums } from '@cornerstonejs/core';
+import { utilities, annotation } from '@cornerstonejs/tools';
 import getReferencedFrameOfReferenceSequence from './utilities/getReferencedFrameOfReferenceSequence.js';
 import getReferencedSeriesSequence from './utilities/getReferencedSeriesSequence.js';
 import getRTROIObservationsSequence from './utilities/getRTROIObservationsSequence.js';
-import getRTSeriesModule from './utilities/getRTSeriesModule.js';
 import getStructureSetModule from './utilities/getStructureSetModule.js';
+import '../../../utilities/referencedMetadataProvider.js';
+import { createInstance } from '../../../utilities/createInstance.js';
 
 const {
   generateContourSetsFromLabelmap,
   AnnotationToPointData
 } = utilities.contours;
 const {
-  DicomMetaDictionary
-} = dcmjs.data;
-async function generateRTSSFromSegmentations(segmentations, metadataProvider, DicomMetadataStore) {
+  MetadataModules
+} = Enums;
+function generateRTSSFromSegmentations(segmentation, metadataProvider, _DicomMetadataStore) {
+  return generateRTSSFromLabelmap(segmentation, {
+    metadataProvider,
+    _DicomMetadataStore
+  });
+}
+async function generateRTSSFromLabelmap(segmentations, options) {
+  const {
+    metadataProvider = metaData
+  } = options;
   const roiContours = [];
   const contourSets = await generateContourSetsFromLabelmap({
     segmentations
@@ -23,26 +32,17 @@ async function generateRTSSFromSegmentations(segmentations, metadataProvider, Di
     if (contourSet) {
       const contourSequence = [];
       contourSet.sliceContours.forEach(sliceContour => {
-        const sopCommon = metadataProvider.get("sopCommonModule", sliceContour.referencedImageId);
-        const ReferencedSOPClassUID = sopCommon.sopClassUID;
-        const ReferencedSOPInstanceUID = sopCommon.sopInstanceUID;
-        const ContourImageSequence = [{
-          ReferencedSOPClassUID,
-          ReferencedSOPInstanceUID
-        }];
-        const sliceContourPolyData = sliceContour.polyData;
+        const ContourImageSequence = metadataProvider.get('ImageSopInstanceReference', sliceContour.referencedImageId);
+        const {
+          points: polyDataPoints
+        } = sliceContour.polyData;
         sliceContour.contours.forEach((contour, index) => {
           const ContourGeometricType = contour.type;
           const NumberOfContourPoints = contour.contourPoints.length;
           const ContourData = [];
           contour.contourPoints.forEach(point => {
-            const pointData = sliceContourPolyData.points[point];
-            pointData[0] = +pointData[0].toFixed(2);
-            pointData[1] = +pointData[1].toFixed(2);
-            pointData[2] = +pointData[2].toFixed(2);
-            ContourData.push(pointData[0]);
-            ContourData.push(pointData[1]);
-            ContourData.push(pointData[2]);
+            const pointData = polyDataPoints[point];
+            ContourData.push(...pointData.map(v => v.toFixed(2)));
           });
           contourSequence.push({
             ContourImageSequence,
@@ -58,124 +58,116 @@ async function generateRTSSFromSegmentations(segmentations, metadataProvider, Di
         name: segLabel,
         description: segLabel,
         contourSequence,
-        color: contourSet.color,
+        color: contourSet.color.slice(0, 3),
         metadata: contourSet.metadata
       };
       roiContours.push(ROIContour);
     }
   });
-  const rtMetadata = {
-    name: segmentations.label,
-    label: segmentations.label
-  };
-  const dataset = _initializeDataset(rtMetadata, roiContours[0].metadata, metadataProvider);
+  const dataset = _initializeDataset(segmentations, roiContours[0].metadata, options);
   roiContours.forEach((contour, index) => {
     const roiContour = {
       ROIDisplayColor: contour.color || [255, 0, 0],
       ContourSequence: contour.contourSequence,
       ReferencedROINumber: index + 1
     };
-    dataset.StructureSetROISequence.push(getStructureSetModule(contour, index));
+    const segment = segmentations.segments[index + 1];
+    dataset.StructureSetROISequence.push(getStructureSetModule(contour, segment));
+    dataset.RTROIObservationsSequence.push(getRTROIObservationsSequence(segment, index, options));
     dataset.ROIContourSequence.push(roiContour);
-    dataset.ReferencedSeriesSequence = getReferencedSeriesSequence(contour.metadata, index, metadataProvider, DicomMetadataStore);
-    dataset.ReferencedFrameOfReferenceSequence = getReferencedFrameOfReferenceSequence(contour.metadata, metadataProvider, dataset);
+    dataset.ReferencedSeriesSequence = getReferencedSeriesSequence(dataset.ReferencedSeriesSequence, contour.metadata, options);
+    dataset.ReferencedFrameOfReferenceSequence = getReferencedFrameOfReferenceSequence(dataset.ReferencedFrameOfReferenceSequence, contour.metadata);
   });
-  const fileMetaInformationVersionArray = new Uint8Array(2);
-  fileMetaInformationVersionArray[1] = 1;
-  const _meta = {
-    FileMetaInformationVersion: {
-      Value: [fileMetaInformationVersionArray.buffer],
-      vr: "OB"
-    },
-    TransferSyntaxUID: {
-      Value: ["1.2.840.10008.1.2.1"],
-      vr: "UI"
-    },
-    ImplementationClassUID: {
-      Value: [DicomMetaDictionary.uid()],
-      vr: "UI"
-    },
-    ImplementationVersionName: {
-      Value: ["dcmjs"],
-      vr: "SH"
-    }
-  };
-  dataset._meta = _meta;
-  dataset.SpecificCharacterSet = "ISO_IR 192";
+  if (dataset.ReferencedFrameOfReferenceSequence?.length === 1) {
+    dataset.FrameOfReferenceUID = dataset.ReferencedFrameOfReferenceSequence[0].FrameOfReferenceUID;
+  }
   return dataset;
 }
-function generateRTSSFromAnnotations(annotations, metadataProvider, DicomMetadataStore) {
-  const rtMetadata = {
-    name: "RTSS from Annotations",
-    label: "RTSS from Annotations"
-  };
-  const dataset = _initializeDataset(rtMetadata, annotations[0].metadata, metadataProvider);
+function generateRTSSFromAnnotations(segmentations, annotations, options) {
+  const dataset = _initializeDataset(segmentations, annotations[0].metadata, options);
+  const segmentsContour = new Map();
   annotations.forEach((annotation, index) => {
-    const ContourSequence = AnnotationToPointData.convert(annotation, index, metadataProvider);
-    dataset.StructureSetROISequence.push(getStructureSetModule(annotation, index));
-    dataset.ROIContourSequence.push(ContourSequence);
-    dataset.RTROIObservationsSequence.push(getRTROIObservationsSequence(annotation, index));
-    dataset.ReferencedSeriesSequence = getReferencedSeriesSequence(annotation.metadata, index, metadataProvider, DicomMetadataStore);
-    dataset.ReferencedFrameOfReferenceSequence = getReferencedFrameOfReferenceSequence(annotation.metadata, metadataProvider, dataset);
-  });
-  const fileMetaInformationVersionArray = new Uint8Array(2);
-  fileMetaInformationVersionArray[1] = 1;
-  const _meta = {
-    FileMetaInformationVersion: {
-      Value: [fileMetaInformationVersionArray.buffer],
-      vr: "OB"
-    },
-    TransferSyntaxUID: {
-      Value: ["1.2.840.10008.1.2.1"],
-      vr: "UI"
-    },
-    ImplementationClassUID: {
-      Value: [DicomMetaDictionary.uid()],
-      vr: "UI"
-    },
-    ImplementationVersionName: {
-      Value: ["dcmjs"],
-      vr: "SH"
+    const {
+      data: {
+        segmentation
+      }
+    } = annotation;
+    if (!segmentation) {
+      console.warn('Annotation is not a segmentation:', annotation);
+      return;
+    }
+    const {
+      segmentationId,
+      segmentIndex
+    } = segmentation;
+    const key = `${segmentationId}:${segmentIndex}`;
+    let segmentAnnotation = segmentsContour.get(key);
+    if (!segmentAnnotation) {
+      const segment = segmentations.segments[segmentIndex];
+      const structureSetModule = getStructureSetModule(annotation, segment);
+      dataset.StructureSetROISequence.push(structureSetModule);
+      dataset.RTROIObservationsSequence.push(getRTROIObservationsSequence(segment, index, options));
+      segmentAnnotation = {
+        ...segmentation,
+        annotations: [],
+        structureSetModule,
+        segment,
+        roiContourSequence: null
+      };
+      segmentsContour.set(key, segmentAnnotation);
+    }
+    const roiContourSequence = AnnotationToPointData.convert(annotation, segmentAnnotation.segment, metaData);
+    if (segmentAnnotation.roiContourSequence) {
+      segmentAnnotation.roiContourSequence.ContourSequence.push(...roiContourSequence.ContourSequence);
+    } else {
+      dataset.ROIContourSequence.push(roiContourSequence);
+      segmentAnnotation.roiContourSequence = roiContourSequence;
     }
-  };
-  dataset._meta = _meta;
-  dataset.SpecificCharacterSet = "ISO_IR 192";
+    dataset.ReferencedSeriesSequence = getReferencedSeriesSequence(dataset.ReferencedSeriesSequence, annotation.metadata, options);
+    dataset.ReferencedFrameOfReferenceSequence = getReferencedFrameOfReferenceSequence(dataset.ReferencedFrameOfReferenceSequence, annotation.metadata);
+  });
+  if (dataset.ReferencedFrameOfReferenceSequence?.length === 1) {
+    dataset.FrameOfReferenceUID = dataset.ReferencedFrameOfReferenceSequence[0].FrameOfReferenceUID;
+  }
   return dataset;
 }
-function _initializeDataset(rtMetadata, imgMetadata, metadataProvider) {
-  const rtSOPInstanceUID = DicomMetaDictionary.uid();
+function _initializeDataset(segmentation, imgMetadata, options) {
   const {
-    referencedImageId: imageId,
-    FrameOfReferenceUID
+    referencedImageId: studyExemplarImageId
   } = imgMetadata;
+  return createInstance(MetadataModules.RTSS_INSTANCE_DATA, studyExemplarImageId, {
+    StructureSetLabel: segmentation.label,
+    StructureSetName: segmentation.label,
+    SeriesDescription: segmentation.label,
+    _meta: metaData.get(MetadataModules.RTSS_CONTOUR, studyExemplarImageId)
+  }, options);
+}
+function generateRTSSFromContour(segmentations, options) {
   const {
-    studyInstanceUID
-  } = metadataProvider.get("generalSeriesModule", imageId);
-  const patientModule = getPatientModule(imageId, metadataProvider);
-  const rtSeriesModule = getRTSeriesModule(DicomMetaDictionary);
-  return {
-    StructureSetROISequence: [],
-    ROIContourSequence: [],
-    RTROIObservationsSequence: [],
-    ReferencedSeriesSequence: [],
-    ReferencedFrameOfReferenceSequence: [],
-    ...patientModule,
-    ...rtSeriesModule,
-    StudyInstanceUID: studyInstanceUID,
-    SOPClassUID: "1.2.840.10008.5.1.4.1.1.481.3",
-    SOPInstanceUID: rtSOPInstanceUID,
-    Manufacturer: "dcmjs",
-    Modality: "RTSTRUCT",
-    FrameOfReferenceUID,
-    PositionReferenceIndicator: "",
-    StructureSetLabel: rtMetadata.label || "",
-    StructureSetName: rtMetadata.name || "",
-    ReferringPhysicianName: "",
-    OperatorsName: "",
-    StructureSetDate: DicomMetaDictionary.date(),
-    StructureSetTime: DicomMetaDictionary.time(),
-    _meta: null
-  };
+    annotationUIDsMap
+  } = segmentations.representationData.Contour;
+  const annotations = [];
+  for (const annotationSet of annotationUIDsMap.values()) {
+    for (const annotationUID of annotationSet.values()) {
+      const annotation$1 = annotation.state.getAnnotation(annotationUID);
+      if (!annotation$1) {
+        console.error('Unable to find an annotation for UID', annotationUID);
+        continue;
+      }
+      annotations.push(annotation$1);
+    }
+  }
+  return generateRTSSFromAnnotations(segmentations, annotations, options);
+}
+function generateRTSSFromRepresentation(segmentations) {
+  let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  if (segmentations.representationData.Labelmap) {
+    return generateRTSSFromLabelmap(segmentations, options);
+  }
+  if (segmentations.representationData.Contour) {
+    return generateRTSSFromContour(segmentations, options);
+  }
+  throw new Error(`No representation available to save to RTSS: ${Object.keys(segmentations.representationData)}`);
 }
 
-export { generateRTSSFromAnnotations, generateRTSSFromSegmentations };
+export { generateRTSSFromAnnotations, generateRTSSFromContour, generateRTSSFromLabelmap, generateRTSSFromRepresentation, generateRTSSFromSegmentations };

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

@@ -1,4 +1,4 @@
 import { utilities } from "@cornerstonejs/tools";
-import { generateRTSSFromAnnotations, generateRTSSFromSegmentations } from "./RTSS";
+export * from "./RTSS";
 declare const generateContourSetsFromLabelmap: typeof utilities.contours.generateContourSetsFromLabelmap;
-export { generateContourSetsFromLabelmap, generateRTSSFromAnnotations, generateRTSSFromSegmentations };
+export { generateContourSetsFromLabelmap };

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

@@ -1,5 +1,5 @@
 import { utilities } from '@cornerstonejs/tools';
-export { generateRTSSFromAnnotations, generateRTSSFromSegmentations } from './RTSS.js';
+export { generateRTSSFromAnnotations, generateRTSSFromContour, generateRTSSFromLabelmap, generateRTSSFromRepresentation, generateRTSSFromSegmentations } from './RTSS.js';
 
 const {
   generateContourSetsFromLabelmap

package/dist/esm/adapters/Cornerstone3D/RTStruct/utilities/getRTROIObservationsSequence.d.ts

@@ -1,6 +1,6 @@
-export default function getRTROIObservationsSequence(toolData: any, index: any): {
+export default function getRTROIObservationsSequence(segment: any, index: any, options?: any): {
     ObservationNumber: any;
     ReferencedROINumber: any;
-    RTROIInterpretedType: string;
-    ROIInterpreter: string;
+    RTROIInterpretedType: any;
+    ROIInterpreter: any;
 };

package/dist/esm/adapters/Cornerstone3D/RTStruct/utilities/getRTROIObservationsSequence.js

@@ -1,9 +1,9 @@
-function getRTROIObservationsSequence(toolData, index) {
+function getRTROIObservationsSequence(segment, index, options) {
   return {
     ObservationNumber: index + 1,
-    ReferencedROINumber: index + 1,
-    RTROIInterpretedType: "Todo: type",
-    ROIInterpreter: "Todo: interpreter"
+    ReferencedROINumber: segment.segmentIndex ?? index + 1,
+    RTROIInterpretedType: options?.interpretedType || 'ORGAN',
+    ROIInterpreter: options?.observerName || ''
   };
 }
 

package/dist/esm/adapters/Cornerstone3D/RTStruct/utilities/getReferencedFrameOfReferenceSequence.d.ts

@@ -1,11 +1 @@
-export default function getReferencedFrameOfReferenceSequence(metadata: any, metadataProvider: any, dataset: any): {
-    FrameOfReferenceUID: any;
-    RTReferencedStudySequence: {
-        ReferencedSOPClassUID: any;
-        ReferencedSOPInstanceUID: any;
-        RTReferencedSeriesSequence: {
-            SeriesInstanceUID: any;
-            ContourImageSequence: any[];
-        }[];
-    }[];
-}[];
+export default function getReferencedFrameOfReferenceSequence(referencedFrameOfReferenceSequence: any, metadata: any, _options: any): any;

package/dist/esm/adapters/Cornerstone3D/RTStruct/utilities/getReferencedFrameOfReferenceSequence.js

@@ -1,26 +1,16 @@
-function getReferencedFrameOfReferenceSequence(metadata, metadataProvider, dataset) {
+function getReferencedFrameOfReferenceSequence(referencedFrameOfReferenceSequence, metadata, _options) {
   const {
-    referencedImageId: imageId,
     FrameOfReferenceUID
   } = metadata;
-  const instance = metadataProvider.get("instance", imageId);
-  const {
-    SeriesInstanceUID
-  } = instance;
-  const {
-    ReferencedSeriesSequence
-  } = dataset;
-  return [{
-    FrameOfReferenceUID,
-    RTReferencedStudySequence: [{
-      ReferencedSOPClassUID: dataset.SOPClassUID,
-      ReferencedSOPInstanceUID: dataset.SOPInstanceUID,
-      RTReferencedSeriesSequence: [{
-        SeriesInstanceUID,
-        ContourImageSequence: [...ReferencedSeriesSequence[0].ReferencedInstanceSequence]
-      }]
-    }]
-  }];
+  referencedFrameOfReferenceSequence ||= [];
+  let referencedItem = referencedFrameOfReferenceSequence.find(it => it.FrameOfReferenceUID === FrameOfReferenceUID);
+  if (!referencedItem) {
+    referencedItem = {
+      FrameOfReferenceUID
+    };
+    referencedFrameOfReferenceSequence.push(referencedItem);
+  }
+  return referencedFrameOfReferenceSequence;
 }
 
 export { getReferencedFrameOfReferenceSequence as default };

package/dist/esm/adapters/Cornerstone3D/RTStruct/utilities/getReferencedSeriesSequence.d.ts

@@ -1,4 +1 @@
-export default function getReferencedSeriesSequence(metadata: any, _index: any, metadataProvider: any, DicomMetadataStore: any): {
-    SeriesInstanceUID: any;
-    ReferencedInstanceSequence: any[];
-}[];
+export default function getReferencedSeriesSequence(referencedSeriesSequence: any, metadata: any, options?: any): any;

package/dist/esm/adapters/Cornerstone3D/RTStruct/utilities/getReferencedSeriesSequence.js

@@ -1,33 +1,34 @@
-function getReferencedSeriesSequence(metadata, _index, metadataProvider, DicomMetadataStore) {
-  // grab imageId from toolData
+import { metaData, Enums } from '@cornerstonejs/core';
+
+const {
+  MetadataModules
+} = Enums;
+function getReferencedSeriesSequence(referencedSeriesSequence, metadata, options) {
+  const metadataProvider = options?.metadataProvider || metaData;
   const {
     referencedImageId: imageId
   } = metadata;
-  const instance = metadataProvider.get("instance", imageId);
-  const {
-    SeriesInstanceUID,
-    StudyInstanceUID
-  } = instance;
-  const ReferencedSeriesSequence = [];
-  if (SeriesInstanceUID) {
-    const series = DicomMetadataStore.getSeries(StudyInstanceUID, SeriesInstanceUID);
-    const ReferencedSeries = {
-      SeriesInstanceUID,
-      ReferencedInstanceSequence: []
-    };
-    series.instances.forEach(instance => {
-      const {
-        SOPInstanceUID,
-        SOPClassUID
-      } = instance;
-      ReferencedSeries.ReferencedInstanceSequence.push({
-        ReferencedSOPClassUID: SOPClassUID,
-        ReferencedSOPInstanceUID: SOPInstanceUID
-      });
-    });
-    ReferencedSeriesSequence.push(ReferencedSeries);
+  const newReferenceSeq = metadataProvider.get(MetadataModules.REFERENCED_SERIES_REFERENCE, imageId);
+  referencedSeriesSequence ||= [];
+  if (newReferenceSeq) {
+    const {
+      ReferencedSeriesInstanceUID: newSeriesUid,
+      ReferencedInstanceSequence: [{
+        ReferencedSOPInstanceUID: newSopUID
+      }]
+    } = newReferenceSeq;
+    const existingSeries = referencedSeriesSequence.find(it => it.ReferencedSeriesInstanceUID === newSeriesUid);
+    if (!existingSeries) {
+      referencedSeriesSequence.push(newReferenceSeq);
+      return referencedSeriesSequence;
+    }
+    if (existingSeries.ReferencedInstanceSequence.find(it => it.ReferencedSOPInstanceUID === newSopUID)) {
+      return referencedSeriesSequence;
+    }
+    const referencedInstanceSeq = newReferenceSeq.ReferencedInstanceSequence;
+    existingSeries.ReferencedInstanceSequence.push(Array.isArray(referencedInstanceSeq) ? referencedInstanceSeq[0] : referencedInstanceSeq);
   }
-  return ReferencedSeriesSequence;
+  return referencedSeriesSequence;
 }
 
 export { getReferencedSeriesSequence as default };

package/dist/esm/adapters/Cornerstone3D/RTStruct/utilities/getStructureSetModule.d.ts

@@ -1,7 +1,8 @@
-export default function getStructureSetModule(contour: any, index: any): {
+import type { Types as ToolTypes } from '@cornerstonejs/tools';
+export default function getStructureSetModule(contour: ToolTypes.Annotation, segment: any): {
     ROINumber: any;
     ROIName: any;
-    ROIDescription: string;
+    ROIDescription: any;
     ROIGenerationAlgorithm: string;
-    ReferencedFrameOfReferenceUID: any;
+    ReferencedFrameOfReferenceUID: string;
 };

package/dist/esm/adapters/Cornerstone3D/RTStruct/utilities/getStructureSetModule.js

@@ -1,12 +1,12 @@
-function getStructureSetModule(contour, index) {
+function getStructureSetModule(contour, segment) {
   const {
     FrameOfReferenceUID
   } = contour.metadata;
   return {
-    ROINumber: index + 1,
-    ROIName: contour.name || `Todo: name ${index + 1}`,
-    ROIDescription: `Todo: description ${index + 1}`,
-    ROIGenerationAlgorithm: "Todo: algorithm",
+    ROINumber: segment.segmentIndex,
+    ROIName: segment.label,
+    ROIDescription: segment.label,
+    ROIGenerationAlgorithm: 'MANUAL',
     ReferencedFrameOfReferenceUID: FrameOfReferenceUID
   };
 }

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

@@ -1,5 +1,4 @@
 import { utilities } from 'dcmjs';
-import 'buffer';
 import { toScoords } from '../helpers/toScoordType.js';
 import '@cornerstonejs/core';
 import MeasurementReport from './MeasurementReport.js';

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

@@ -1,2 +1,8 @@
-declare function generateSegmentation(images: any, labelmaps: any, metadata: any, options?: {}): any;
+interface IOptions {
+    predecessorImageId?: string;
+}
+type Options = IOptions & {
+    [key: string]: number | boolean | unknown | string;
+};
+declare function generateSegmentation(images: any, labelmaps: any, metadata: any, options?: Options): any;
 export { generateSegmentation };

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

@@ -1,8 +1,12 @@
 import { normalizers, derivations } from 'dcmjs';
+import { Enums } from '@cornerstonejs/core';
 import { fillSegmentation } from '../../Cornerstone/Segmentation_4X.js';
 
 const {
-  Normalizer
+  MetadataModules
+} = Enums;
+const {
+  SEGImageNormalizer
 } = normalizers;
 const {
   Segmentation: SegmentationDerivation
@@ -10,26 +14,59 @@ const {
 function generateSegmentation(images, labelmaps, metadata) {
   let options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
   const segmentation = _createMultiframeSegmentationFromReferencedImages(images, metadata, options);
-  return fillSegmentation(segmentation, labelmaps, options);
+  const segmentationResult = fillSegmentation(segmentation, labelmaps, options);
+  const predecessorImageId = options?.predecessorImageId;
+  if (predecessorImageId) {
+    const predecessor = metadata.get(MetadataModules.PREDECESSOR_SEQUENCE, predecessorImageId);
+    Object.assign(segmentationResult, predecessor);
+  }
+  return segmentationResult;
 }
 function _createMultiframeSegmentationFromReferencedImages(images, metadata, options) {
+  const studyImageId = options?.predecessorImageId || images[0].imageId;
+  const studyData = metadata.get(MetadataModules.STUDY_DATA, studyImageId);
   const datasets = images.map(image => {
-    const instance = metadata.get("instance", image.imageId);
+    const {
+      imageId
+    } = image;
+    const seriesData = metadata.get(MetadataModules.SERIES_DATA, imageId);
+    const imageData = metadata.get(MetadataModules.IMAGE_DATA, imageId);
     return {
-      ...image,
-      ...instance,
-      SOPClassUID: instance.SopClassUID || instance.SOPClassUID,
-      SOPInstanceUID: instance.SopInstanceUID || instance.SOPInstanceUID,
+      ...studyData,
+      ...seriesData,
+      ...imageData,
       PixelData: image.voxelManager.getScalarData(),
+      BitsAllocated: 16,
       _vrMap: {
-        PixelData: "OW"
+        PixelData: 'OW'
       },
       _meta: {}
     };
   });
-  const multiframe = Normalizer.normalizeToDataset(datasets);
+  const isSingleNonMultiFrame = datasets.length === 1 && !(datasets[0].NumberOfFrames > 1);
+  if (isSingleNonMultiFrame) {
+    datasets.push(datasets[0]);
+  }
+  const normalizer = new SEGImageNormalizer(datasets);
+  normalizer.normalize();
+  const {
+    dataset: multiframe
+  } = normalizer;
   if (!multiframe) {
-    throw new Error("Failed to normalize the multiframe dataset, the data is not multi-frame.");
+    throw new Error('Failed to normalize the multiframe dataset, the data is not multi-frame.');
+  }
+  multiframe.SharedFunctionalGroupsSequence ||= {};
+  multiframe.SharedFunctionalGroupsSequence.PixelMeasuresSequence = {};
+  multiframe.PerFrameFunctionalGroupsSequence ||= [];
+  for (let index = 0; index < images.length; index++) {
+    multiframe.PerFrameFunctionalGroupsSequence[index] ||= {
+      PlanePositionSequence: {},
+      PlaneOrientationSequence: {}
+    };
+  }
+  if (isSingleNonMultiFrame) {
+    multiframe.PerFrameFunctionalGroupsSequence = [multiframe.PerFrameFunctionalGroupsSequence[0]];
+    multiframe.NumberOfFrames = 1;
   }
   return new SegmentationDerivation([multiframe], options);
 }

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

@@ -10,3 +10,47 @@ export declare const COMMENT_CODE: {
     meaning: string;
     value: string;
 };
+export declare const fileMetaInformationVersionArray1: Uint8Array;
+export declare const fileMetaInformationVersionArray2: Uint8Array;
+export declare const ImplementationClassUidSRAnnotation = "2.25.2470123695996825859949881583571202391.1.0.1";
+export declare const ImplementationClassRtssContours = "2.25.2470123695996825859949881583571202391.2.0.1";
+export declare const ImplementationVersionName: {
+    Value: string[];
+    vr: string;
+};
+export declare const metaSRAnnotation: {
+    FileMetaInformationVersion: {
+        Value: ArrayBufferLike[];
+        vr: string;
+    };
+    TransferSyntaxUID: {
+        Value: string[];
+        vr: string;
+    };
+    ImplementationClassUID: {
+        Value: string[];
+        vr: string;
+    };
+    ImplementationVersionName: {
+        Value: string[];
+        vr: string;
+    };
+};
+export declare const metaRTSSContour: {
+    ImplementationClassUID: {
+        Value: string[];
+        vr: string;
+    };
+    FileMetaInformationVersion: {
+        Value: ArrayBufferLike[];
+        vr: string;
+    };
+    TransferSyntaxUID: {
+        Value: string[];
+        vr: string;
+    };
+    ImplementationVersionName: {
+        Value: string[];
+        vr: string;
+    };
+};