@cornerstonejs/adapters 0.1.2 → 0.1.4

package/src/adapters/Cornerstone/Segmentation_4X.js

@@ -0,0 +1,1543 @@
+import { log, utilities, normalizers, derivations } from "dcmjs";
+import ndarray from "ndarray";
+import cloneDeep from "lodash.clonedeep";
+
+const {
+    rotateDirectionCosinesInPlane,
+    flipImageOrientationPatient: flipIOP,
+    flipMatrix2D,
+    rotateMatrix902D,
+    nearlyEqual
+} = utilities.orientation;
+
+const { datasetToBlob, BitArray, DicomMessage, DicomMetaDictionary } =
+    utilities;
+
+const { Normalizer } = normalizers;
+const { Segmentation: SegmentationDerivation } = derivations;
+
+const { encode, decode } = utilities.compression;
+
+const Segmentation = {
+    generateSegmentation,
+    generateToolState,
+    fillSegmentation
+};
+
+export default Segmentation;
+
+/**
+ *
+ * @typedef {Object} BrushData
+ * @property {Object} toolState - The cornerstoneTools global toolState.
+ * @property {Object[]} segments - The cornerstoneTools segment metadata that corresponds to the
+ *                                 seriesInstanceUid.
+ */
+
+const generateSegmentationDefaultOptions = {
+    includeSliceSpacing: true,
+    rleEncode: true
+};
+
+/**
+ * generateSegmentation - Generates cornerstoneTools brush data, given a stack of
+ * imageIds, images and the cornerstoneTools brushData.
+ *
+ * @param  {object[]} images An array of cornerstone images that contain the source
+ *                           data under `image.data.byteArray.buffer`.
+ * @param  {Object|Object[]} inputLabelmaps3D The cornerstone `Labelmap3D` object, or an array of objects.
+ * @param  {Object} userOptions Options to pass to the segmentation derivation and `fillSegmentation`.
+ * @returns {Blob}
+ */
+function generateSegmentation(images, inputLabelmaps3D, userOptions = {}) {
+    const isMultiframe = images[0].imageId.includes("?frame");
+    const segmentation = _createSegFromImages(
+        images,
+        isMultiframe,
+        userOptions
+    );
+
+    return fillSegmentation(segmentation, inputLabelmaps3D, userOptions);
+}
+
+/**
+ * fillSegmentation - Fills a derived segmentation dataset with cornerstoneTools `LabelMap3D` data.
+ *
+ * @param  {object[]} segmentation An empty segmentation derived dataset.
+ * @param  {Object|Object[]} inputLabelmaps3D The cornerstone `Labelmap3D` object, or an array of objects.
+ * @param  {Object} userOptions Options object to override default options.
+ * @returns {Blob}           description
+ */
+function fillSegmentation(segmentation, inputLabelmaps3D, userOptions = {}) {
+    const options = Object.assign(
+        {},
+        generateSegmentationDefaultOptions,
+        userOptions
+    );
+
+    // Use another variable so we don't redefine labelmaps3D.
+    const labelmaps3D = Array.isArray(inputLabelmaps3D)
+        ? inputLabelmaps3D
+        : [inputLabelmaps3D];
+
+    let numberOfFrames = 0;
+    const referencedFramesPerLabelmap = [];
+
+    for (
+        let labelmapIndex = 0;
+        labelmapIndex < labelmaps3D.length;
+        labelmapIndex++
+    ) {
+        const labelmap3D = labelmaps3D[labelmapIndex];
+        const { labelmaps2D, metadata } = labelmap3D;
+
+        const referencedFramesPerSegment = [];
+
+        for (let i = 1; i < metadata.length; i++) {
+            if (metadata[i]) {
+                referencedFramesPerSegment[i] = [];
+            }
+        }
+
+        for (let i = 0; i < labelmaps2D.length; i++) {
+            const labelmap2D = labelmaps2D[i];
+
+            if (labelmaps2D[i]) {
+                const { segmentsOnLabelmap } = labelmap2D;
+
+                segmentsOnLabelmap.forEach(segmentIndex => {
+                    if (segmentIndex !== 0) {
+                        referencedFramesPerSegment[segmentIndex].push(i);
+                        numberOfFrames++;
+                    }
+                });
+            }
+        }
+
+        referencedFramesPerLabelmap[labelmapIndex] = referencedFramesPerSegment;
+    }
+
+    segmentation.setNumberOfFrames(numberOfFrames);
+
+    for (
+        let labelmapIndex = 0;
+        labelmapIndex < labelmaps3D.length;
+        labelmapIndex++
+    ) {
+        const referencedFramesPerSegment =
+            referencedFramesPerLabelmap[labelmapIndex];
+
+        const labelmap3D = labelmaps3D[labelmapIndex];
+        const { metadata } = labelmap3D;
+
+        for (
+            let segmentIndex = 1;
+            segmentIndex < referencedFramesPerSegment.length;
+            segmentIndex++
+        ) {
+            const referencedFrameIndicies =
+                referencedFramesPerSegment[segmentIndex];
+
+            if (referencedFrameIndicies) {
+                // Frame numbers start from 1.
+                const referencedFrameNumbers = referencedFrameIndicies.map(
+                    element => {
+                        return element + 1;
+                    }
+                );
+                const segmentMetadata = metadata[segmentIndex];
+                const labelmaps = _getLabelmapsFromRefernecedFrameIndicies(
+                    labelmap3D,
+                    referencedFrameIndicies
+                );
+
+                segmentation.addSegmentFromLabelmap(
+                    segmentMetadata,
+                    labelmaps,
+                    segmentIndex,
+                    referencedFrameNumbers
+                );
+            }
+        }
+    }
+
+    if (options.rleEncode) {
+        const rleEncodedFrames = encode(
+            segmentation.dataset.PixelData,
+            numberOfFrames,
+            segmentation.dataset.Rows,
+            segmentation.dataset.Columns
+        );
+
+        // Must use fractional now to RLE encode, as the DICOM standard only allows BitStored && BitsAllocated
+        // to be 1 for BINARY. This is not ideal and there should be a better format for compression in this manner
+        // added to the standard.
+        segmentation.assignToDataset({
+            BitsAllocated: "8",
+            BitsStored: "8",
+            HighBit: "7",
+            SegmentationType: "FRACTIONAL",
+            SegmentationFractionalType: "PROBABILITY",
+            MaximumFractionalValue: "255"
+        });
+
+        segmentation.dataset._meta.TransferSyntaxUID = {
+            Value: ["1.2.840.10008.1.2.5"],
+            vr: "UI"
+        };
+        segmentation.dataset._vrMap.PixelData = "OB";
+        segmentation.dataset.PixelData = rleEncodedFrames;
+    } else {
+        // If no rleEncoding, at least bitpack the data.
+        segmentation.bitPackPixelData();
+    }
+
+    const segBlob = datasetToBlob(segmentation.dataset);
+
+    return segBlob;
+}
+
+function _getLabelmapsFromRefernecedFrameIndicies(
+    labelmap3D,
+    referencedFrameIndicies
+) {
+    const { labelmaps2D } = labelmap3D;
+
+    const labelmaps = [];
+
+    for (let i = 0; i < referencedFrameIndicies.length; i++) {
+        const frame = referencedFrameIndicies[i];
+
+        labelmaps.push(labelmaps2D[frame].pixelData);
+    }
+
+    return labelmaps;
+}
+
+/**
+ * _createSegFromImages - description
+ *
+ * @param  {Object[]} images    An array of the cornerstone image objects.
+ * @param  {Boolean} isMultiframe Whether the images are multiframe.
+ * @returns {Object}              The Seg derived dataSet.
+ */
+function _createSegFromImages(images, isMultiframe, options) {
+    const datasets = [];
+
+    if (isMultiframe) {
+        const image = images[0];
+        const arrayBuffer = image.data.byteArray.buffer;
+
+        const dicomData = DicomMessage.readFile(arrayBuffer);
+        const dataset = DicomMetaDictionary.naturalizeDataset(dicomData.dict);
+
+        dataset._meta = DicomMetaDictionary.namifyDataset(dicomData.meta);
+
+        datasets.push(dataset);
+    } else {
+        for (let i = 0; i < images.length; i++) {
+            const image = images[i];
+            const arrayBuffer = image.data.byteArray.buffer;
+            const dicomData = DicomMessage.readFile(arrayBuffer);
+            const dataset = DicomMetaDictionary.naturalizeDataset(
+                dicomData.dict
+            );
+
+            dataset._meta = DicomMetaDictionary.namifyDataset(dicomData.meta);
+            datasets.push(dataset);
+        }
+    }
+
+    const multiframe = Normalizer.normalizeToDataset(datasets);
+
+    return new SegmentationDerivation([multiframe], options);
+}
+
+/**
+ * generateToolState - Given a set of cornrstoneTools imageIds and a Segmentation buffer,
+ * derive cornerstoneTools toolState and brush metadata.
+ *
+ * @param  {string[]} imageIds - An array of the imageIds.
+ * @param  {ArrayBuffer} arrayBuffer - The SEG arrayBuffer.
+ * @param  {*} metadataProvider.
+ * @param  {bool} skipOverlapping - skip checks for overlapping segs, default value false.
+ * @param  {number} tolerance - default value 1.e-3.
+ *
+ * @return {[]ArrayBuffer}a list of array buffer for each labelMap
+ * @return {Object} an object from which the segment metadata can be derived
+ * @return {[][][]} 2D list containing the track of segments per frame
+ * @return {[][][]} 3D list containing the track of segments per frame for each labelMap
+ *                  (available only for the overlapping case).
+ */
+function generateToolState(
+    imageIds,
+    arrayBuffer,
+    metadataProvider,
+    skipOverlapping = false,
+    tolerance = 1e-3
+) {
+    const dicomData = DicomMessage.readFile(arrayBuffer);
+    const dataset = DicomMetaDictionary.naturalizeDataset(dicomData.dict);
+    dataset._meta = DicomMetaDictionary.namifyDataset(dicomData.meta);
+    const multiframe = Normalizer.normalizeToDataset([dataset]);
+
+    const imagePlaneModule = metadataProvider.get(
+        "imagePlaneModule",
+        imageIds[0]
+    );
+
+    const generalSeriesModule = metadataProvider.get(
+        "generalSeriesModule",
+        imageIds[0]
+    );
+
+    const SeriesInstanceUID = generalSeriesModule.seriesInstanceUID;
+
+    if (!imagePlaneModule) {
+        console.warn("Insufficient metadata, imagePlaneModule missing.");
+    }
+
+    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
+          ];
+
+    // Get IOP from ref series, compute supported orientations:
+    const validOrientations = getValidOrientations(ImageOrientationPatient);
+
+    const sliceLength = multiframe.Columns * multiframe.Rows;
+    const segMetadata = getSegmentMetadata(multiframe, SeriesInstanceUID);
+
+    const TransferSyntaxUID = multiframe._meta.TransferSyntaxUID.Value[0];
+
+    let pixelData;
+
+    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 + bitbacking.");
+
+            return;
+        }
+    } else {
+        pixelData = unpackPixelData(multiframe);
+
+        if (!pixelData) {
+            throw new Error("Fractional segmentations are not yet supported");
+        }
+    }
+
+    const orientation = checkOrientation(
+        multiframe,
+        validOrientations,
+        [imagePlaneModule.rows, imagePlaneModule.columns, imageIds.length],
+        tolerance
+    );
+
+    let overlapping = false;
+    if (!skipOverlapping) {
+        overlapping = checkSEGsOverlapping(
+            pixelData,
+            multiframe,
+            imageIds,
+            validOrientations,
+            metadataProvider,
+            tolerance
+        );
+    }
+
+    let insertFunction;
+
+    switch (orientation) {
+        case "Planar":
+            if (overlapping) {
+                insertFunction = insertOverlappingPixelDataPlanar;
+            } else {
+                insertFunction = insertPixelDataPlanar;
+            }
+            break;
+        case "Perpendicular":
+            //insertFunction = insertPixelDataPerpendicular;
+            throw new Error(
+                "Segmentations orthogonal to the acquisition plane of the source data are not yet supported."
+            );
+        case "Oblique":
+            throw new Error(
+                "Segmentations oblique to the acquisition plane of the source data are not yet supported."
+            );
+    }
+
+    /* if SEGs are overlapping:
+    1) the labelmapBuffer will contain M volumes which have non-overlapping segments;
+    2) segmentsOnFrame will have M * numberOfFrames values to track in which labelMap are the segments;
+    3) insertFunction will return the number of LabelMaps
+    4) generateToolState return is an array*/
+
+    const segmentsOnFrameArray = [];
+    segmentsOnFrameArray[0] = [];
+    const segmentsOnFrame = [];
+
+    const arrayBufferLength = sliceLength * imageIds.length * 2; // 2 bytes per label voxel in cst4.
+    const labelmapBufferArray = [];
+    labelmapBufferArray[0] = new ArrayBuffer(arrayBufferLength);
+
+    insertFunction(
+        segmentsOnFrame,
+        segmentsOnFrameArray,
+        labelmapBufferArray,
+        pixelData,
+        multiframe,
+        imageIds,
+        validOrientations,
+        metadataProvider,
+        tolerance
+    );
+
+    return {
+        labelmapBufferArray,
+        segMetadata,
+        segmentsOnFrame,
+        segmentsOnFrameArray
+    };
+}
+
+// function insertPixelDataPerpendicular(
+//     segmentsOnFrame,
+//     labelmapBuffer,
+//     pixelData,
+//     multiframe,
+//     imageIds,
+//     validOrientations,
+//     metadataProvider
+// ) {
+//     const {
+//         SharedFunctionalGroupsSequence,
+//         PerFrameFunctionalGroupsSequence,
+//         Rows,
+//         Columns
+//     } = multiframe;
+
+//     const firstImagePlaneModule = metadataProvider.get(
+//         "imagePlaneModule",
+//         imageIds[0]
+//     );
+
+//     const lastImagePlaneModule = metadataProvider.get(
+//         "imagePlaneModule",
+//         imageIds[imageIds.length - 1]
+//     );
+
+//     console.log(firstImagePlaneModule);
+//     console.log(lastImagePlaneModule);
+
+//     const corners = [
+//         ...getCorners(firstImagePlaneModule),
+//         ...getCorners(lastImagePlaneModule)
+//     ];
+
+//     console.log(`corners:`);
+//     console.log(corners);
+
+//     const indexToWorld = mat4.create();
+
+//     const ippFirstFrame = firstImagePlaneModule.imagePositionPatient;
+//     const rowCosines = Array.isArray(firstImagePlaneModule.rowCosines)
+//         ? [...firstImagePlaneModule.rowCosines]
+//         : [
+//               firstImagePlaneModule.rowCosines.x,
+//               firstImagePlaneModule.rowCosines.y,
+//               firstImagePlaneModule.rowCosines.z
+//           ];
+
+//     const columnCosines = Array.isArray(firstImagePlaneModule.columnCosines)
+//         ? [...firstImagePlaneModule.columnCosines]
+//         : [
+//               firstImagePlaneModule.columnCosines.x,
+//               firstImagePlaneModule.columnCosines.y,
+//               firstImagePlaneModule.columnCosines.z
+//           ];
+
+//     const { pixelSpacing } = firstImagePlaneModule;
+
+//     mat4.set(
+//         indexToWorld,
+//         // Column 1
+//         0,
+//         0,
+//         0,
+//         ippFirstFrame[0],
+//         // Column 2
+//         0,
+//         0,
+//         0,
+//         ippFirstFrame[1],
+//         // Column 3
+//         0,
+//         0,
+//         0,
+//         ippFirstFrame[2],
+//         // Column 4
+//         0,
+//         0,
+//         0,
+//         1
+//     );
+
+//     // TODO -> Get origin and (x,y,z) increments to build a translation matrix:
+//     // TODO -> Equation C.7.6.2.1-1
+
+//     // | cx*di rx* Xx 0 |  |x|
+//     // | cy*di ry Xy 0 |  |y|
+//     // | cz*di rz Xz 0 |  |z|
+//     // | tx ty tz 1 |  |1|
+
+//     // const [
+//     //     0, 0 , 0 , 0,
+//     //     0, 0 , 0 , 0,
+//     //     0, 0 , 0 , 0,
+//     //     ipp[0], ipp[1] , ipp[2] , 1,
+//     // ]
+
+//     // Each frame:
+
+//     // Find which corner the first voxel lines up with (one of 8 corners.)
+
+//     // Find how i,j,k orient with respect to source volume.
+//     // Go through each frame, find location in source to start, and whether to increment +/ix,+/-y,+/-z
+//     //   through each voxel.
+
+//     // [1,0,0,0,1,0]
+
+//     // const [
+
+//     // ]
+
+//     // Invert transformation matrix to get worldToIndex
+
+//     // Apply world to index on each point to fill up the matrix.
+
+//     // const sharedImageOrientationPatient = SharedFunctionalGroupsSequence.PlaneOrientationSequence
+//     //     ? SharedFunctionalGroupsSequence.PlaneOrientationSequence
+//     //           .ImageOrientationPatient
+//     //     : undefined;
+//     // const sliceLength = Columns * Rows;
+// }
+
+// function getCorners(imagePlaneModule) {
+//     // console.log(imagePlaneModule);
+
+//     const {
+//         rows,
+//         columns,
+//         rowCosines,
+//         columnCosines,
+//         imagePositionPatient: ipp,
+//         rowPixelSpacing,
+//         columnPixelSpacing
+//     } = imagePlaneModule;
+
+//     const rowLength = columns * columnPixelSpacing;
+//     const columnLength = rows * rowPixelSpacing;
+
+//     const entireRowVector = [
+//         rowLength * columnCosines[0],
+//         rowLength * columnCosines[1],
+//         rowLength * columnCosines[2]
+//     ];
+
+//     const entireColumnVector = [
+//         columnLength * rowCosines[0],
+//         columnLength * rowCosines[1],
+//         columnLength * rowCosines[2]
+//     ];
+
+//     const topLeft = [ipp[0], ipp[1], ipp[2]];
+//     const topRight = [
+//         topLeft[0] + entireRowVector[0],
+//         topLeft[1] + entireRowVector[1],
+//         topLeft[2] + entireRowVector[2]
+//     ];
+//     const bottomLeft = [
+//         topLeft[0] + entireColumnVector[0],
+//         topLeft[1] + entireColumnVector[1],
+//         topLeft[2] + entireColumnVector[2]
+//     ];
+
+//     const bottomRight = [
+//         bottomLeft[0] + entireRowVector[0],
+//         bottomLeft[1] + entireRowVector[1],
+//         bottomLeft[2] + entireRowVector[2]
+//     ];
+
+//     return [topLeft, topRight, bottomLeft, bottomRight];
+// }
+
+/**
+ * Find the reference frame of the segmentation frame in the source data.
+ *
+ * @param  {Object}      multiframe        dicom metadata
+ * @param  {Int}         frameSegment      frame dicom index
+ * @param  {String[]}    imageIds          A list of imageIds.
+ * @param  {Object}      metadataProvider  A Cornerstone metadataProvider to query
+ *                                         metadata from imageIds.
+ * @param  {Float}       tolerance         The tolerance parameter
+ *
+ * @returns {String}     Returns the imageId
+ */
+function findReferenceSourceImageId(
+    multiframe,
+    frameSegment,
+    imageIds,
+    metadataProvider,
+    tolerance
+) {
+    let imageId = undefined;
+
+    if (!multiframe) {
+        return imageId;
+    }
+
+    const {
+        FrameOfReferenceUID,
+        PerFrameFunctionalGroupsSequence,
+        SourceImageSequence,
+        ReferencedSeriesSequence
+    } = multiframe;
+
+    if (
+        !PerFrameFunctionalGroupsSequence ||
+        PerFrameFunctionalGroupsSequence.length === 0
+    ) {
+        return imageId;
+    }
+
+    const PerFrameFunctionalGroup =
+        PerFrameFunctionalGroupsSequence[frameSegment];
+
+    if (!PerFrameFunctionalGroup) {
+        return imageId;
+    }
+
+    let frameSourceImageSequence = undefined;
+    if (SourceImageSequence && SourceImageSequence.length !== 0) {
+        frameSourceImageSequence = SourceImageSequence[frameSegment];
+    } else if (PerFrameFunctionalGroup.DerivationImageSequence) {
+        let DerivationImageSequence =
+            PerFrameFunctionalGroup.DerivationImageSequence;
+        if (Array.isArray(DerivationImageSequence)) {
+            if (DerivationImageSequence.length !== 0) {
+                DerivationImageSequence = DerivationImageSequence[0];
+            } else {
+                DerivationImageSequence = undefined;
+            }
+        }
+
+        if (DerivationImageSequence) {
+            frameSourceImageSequence =
+                DerivationImageSequence.SourceImageSequence;
+            if (Array.isArray(frameSourceImageSequence)) {
+                if (frameSourceImageSequence.length !== 0) {
+                    frameSourceImageSequence = frameSourceImageSequence[0];
+                } else {
+                    frameSourceImageSequence = undefined;
+                }
+            }
+        }
+    }
+
+    if (frameSourceImageSequence) {
+        imageId = getImageIdOfSourceImagebySourceImageSequence(
+            frameSourceImageSequence,
+            imageIds,
+            metadataProvider
+        );
+    }
+
+    if (imageId === undefined && ReferencedSeriesSequence) {
+        const referencedSeriesSequence = Array.isArray(ReferencedSeriesSequence)
+            ? ReferencedSeriesSequence[0]
+            : ReferencedSeriesSequence;
+        const ReferencedSeriesInstanceUID =
+            referencedSeriesSequence.SeriesInstanceUID;
+
+        imageId = getImageIdOfSourceImagebyGeometry(
+            ReferencedSeriesInstanceUID,
+            FrameOfReferenceUID,
+            PerFrameFunctionalGroup,
+            imageIds,
+            metadataProvider,
+            tolerance
+        );
+    }
+
+    return imageId;
+}
+
+/**
+ * Checks if there is any overlapping segmentations.
+ *  @returns {boolean} Returns a flag if segmentations overlapping
+ */
+
+function checkSEGsOverlapping(
+    pixelData,
+    multiframe,
+    imageIds,
+    validOrientations,
+    metadataProvider,
+    tolerance
+) {
+    const {
+        SharedFunctionalGroupsSequence,
+        PerFrameFunctionalGroupsSequence,
+        SegmentSequence,
+        Rows,
+        Columns
+    } = multiframe;
+
+    let numberOfSegs = SegmentSequence.length;
+    if (numberOfSegs < 2) {
+        return false;
+    }
+
+    const sharedImageOrientationPatient =
+        SharedFunctionalGroupsSequence.PlaneOrientationSequence
+            ? SharedFunctionalGroupsSequence.PlaneOrientationSequence
+                  .ImageOrientationPatient
+            : undefined;
+    const sliceLength = Columns * Rows;
+    const groupsLen = PerFrameFunctionalGroupsSequence.length;
+
+    /** sort groupsLen to have all the segments for each frame in an array
+     * frame 2 : 1, 2
+     * frame 4 : 1, 3
+     * frame 5 : 4
+     */
+
+    let frameSegmentsMapping = new Map();
+    for (let frameSegment = 0; frameSegment < groupsLen; ++frameSegment) {
+        const segmentIndex = getSegmentIndex(multiframe, frameSegment);
+        if (segmentIndex === undefined) {
+            console.warn(
+                "Could not retrieve the segment index for frame segment " +
+                    frameSegment +
+                    ", skipping this frame."
+            );
+            continue;
+        }
+
+        const imageId = findReferenceSourceImageId(
+            multiframe,
+            frameSegment,
+            imageIds,
+            metadataProvider,
+            tolerance
+        );
+
+        if (!imageId) {
+            console.warn(
+                "Image not present in stack, can't import frame : " +
+                    frameSegment +
+                    "."
+            );
+            continue;
+        }
+
+        const imageIdIndex = imageIds.findIndex(element => element === imageId);
+
+        if (frameSegmentsMapping.has(imageIdIndex)) {
+            let segmentArray = frameSegmentsMapping.get(imageIdIndex);
+            if (!segmentArray.includes(frameSegment)) {
+                segmentArray.push(frameSegment);
+                frameSegmentsMapping.set(imageIdIndex, segmentArray);
+            }
+        } else {
+            frameSegmentsMapping.set(imageIdIndex, [frameSegment]);
+        }
+    }
+
+    for (let [, role] of frameSegmentsMapping.entries()) {
+        let temp2DArray = new Uint16Array(sliceLength).fill(0);
+
+        for (let i = 0; i < role.length; ++i) {
+            const frameSegment = role[i];
+
+            const PerFrameFunctionalGroups =
+                PerFrameFunctionalGroupsSequence[frameSegment];
+
+            const ImageOrientationPatientI =
+                sharedImageOrientationPatient ||
+                PerFrameFunctionalGroups.PlaneOrientationSequence
+                    .ImageOrientationPatient;
+
+            const pixelDataI2D = ndarray(
+                new Uint8Array(
+                    pixelData.buffer,
+                    frameSegment * sliceLength,
+                    sliceLength
+                ),
+                [Rows, Columns]
+            );
+
+            const alignedPixelDataI = alignPixelDataWithSourceData(
+                pixelDataI2D,
+                ImageOrientationPatientI,
+                validOrientations,
+                tolerance
+            );
+
+            if (!alignedPixelDataI) {
+                console.warn(
+                    "Individual SEG frames are out of plane with respect to the first SEG frame, this is not yet supported, skipping this frame."
+                );
+                continue;
+            }
+
+            const data = alignedPixelDataI.data;
+            for (let j = 0, len = data.length; j < len; ++j) {
+                if (data[j] !== 0) {
+                    temp2DArray[j]++;
+                    if (temp2DArray[j] > 1) {
+                        return true;
+                    }
+                }
+            }
+        }
+    }
+
+    return false;
+}
+
+function insertOverlappingPixelDataPlanar(
+    segmentsOnFrame,
+    segmentsOnFrameArray,
+    labelmapBufferArray,
+    pixelData,
+    multiframe,
+    imageIds,
+    validOrientations,
+    metadataProvider,
+    tolerance
+) {
+    const {
+        SharedFunctionalGroupsSequence,
+        PerFrameFunctionalGroupsSequence,
+        Rows,
+        Columns
+    } = multiframe;
+
+    const sharedImageOrientationPatient =
+        SharedFunctionalGroupsSequence.PlaneOrientationSequence
+            ? SharedFunctionalGroupsSequence.PlaneOrientationSequence
+                  .ImageOrientationPatient
+            : undefined;
+    const sliceLength = Columns * Rows;
+    const arrayBufferLength = sliceLength * imageIds.length * 2; // 2 bytes per label voxel in cst4.
+
+    // indicate the number of labelMaps
+    let M = 1;
+
+    // indicate the current labelMap array index;
+    let m = 0;
+
+    // temp array for checking overlaps
+    let tempBuffer = labelmapBufferArray[m].slice(0);
+
+    // temp list for checking overlaps
+    let tempSegmentsOnFrame = cloneDeep(segmentsOnFrameArray[m]);
+
+    /** split overlapping SEGs algorithm for each segment:
+     *  A) copy the labelmapBuffer in the array with index 0
+     *  B) add the segment pixel per pixel on the copied buffer from (A)
+     *  C) if no overlap, copy the results back on the orignal array from (A)
+     *  D) if overlap, repeat increasing the index m up to M (if out of memory, add new buffer in the array and M++);
+     */
+
+    let numberOfSegs = multiframe.SegmentSequence.length;
+    for (
+        let segmentIndexToProcess = 1;
+        segmentIndexToProcess <= numberOfSegs;
+        ++segmentIndexToProcess
+    ) {
+        for (
+            let i = 0, groupsLen = PerFrameFunctionalGroupsSequence.length;
+            i < groupsLen;
+            ++i
+        ) {
+            const PerFrameFunctionalGroups =
+                PerFrameFunctionalGroupsSequence[i];
+
+            const segmentIndex = getSegmentIndex(multiframe, i);
+            if (segmentIndex === undefined) {
+                throw new Error(
+                    "Could not retrieve the segment index. Aborting segmentation loading."
+                );
+            }
+
+            if (segmentIndex !== segmentIndexToProcess) {
+                continue;
+            }
+
+            const ImageOrientationPatientI =
+                sharedImageOrientationPatient ||
+                PerFrameFunctionalGroups.PlaneOrientationSequence
+                    .ImageOrientationPatient;
+
+            const pixelDataI2D = ndarray(
+                new Uint8Array(pixelData.buffer, i * sliceLength, sliceLength),
+                [Rows, Columns]
+            );
+
+            const alignedPixelDataI = alignPixelDataWithSourceData(
+                pixelDataI2D,
+                ImageOrientationPatientI,
+                validOrientations,
+                tolerance
+            );
+
+            if (!alignedPixelDataI) {
+                throw new Error(
+                    "Individual 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,
+                imageIds,
+                metadataProvider,
+                tolerance
+            );
+
+            if (!imageId) {
+                console.warn(
+                    "Image not present in stack, can't import frame : " +
+                        i +
+                        "."
+                );
+                continue;
+            }
+
+            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 imageIdIndex = imageIds.findIndex(
+                element => element === imageId
+            );
+            const byteOffset = sliceLength * 2 * imageIdIndex; // 2 bytes/pixel
+
+            const labelmap2DView = new Uint16Array(
+                tempBuffer,
+                byteOffset,
+                sliceLength
+            );
+
+            const data = alignedPixelDataI.data;
+
+            let segmentOnFrame = false;
+            for (let j = 0, len = alignedPixelDataI.data.length; j < len; ++j) {
+                if (data[j]) {
+                    if (labelmap2DView[j] !== 0) {
+                        m++;
+                        if (m >= M) {
+                            labelmapBufferArray[m] = new ArrayBuffer(
+                                arrayBufferLength
+                            );
+                            segmentsOnFrameArray[m] = [];
+                            M++;
+                        }
+                        tempBuffer = labelmapBufferArray[m].slice(0);
+                        tempSegmentsOnFrame = cloneDeep(
+                            segmentsOnFrameArray[m]
+                        );
+
+                        i = 0;
+                        break;
+                    } else {
+                        labelmap2DView[j] = segmentIndex;
+                        segmentOnFrame = true;
+                    }
+                }
+            }
+
+            if (segmentOnFrame) {
+                if (!tempSegmentsOnFrame[imageIdIndex]) {
+                    tempSegmentsOnFrame[imageIdIndex] = [];
+                }
+
+                tempSegmentsOnFrame[imageIdIndex].push(segmentIndex);
+
+                if (!segmentsOnFrame[imageIdIndex]) {
+                    segmentsOnFrame[imageIdIndex] = [];
+                }
+
+                segmentsOnFrame[imageIdIndex].push(segmentIndex);
+            }
+        }
+
+        labelmapBufferArray[m] = tempBuffer.slice(0);
+        segmentsOnFrameArray[m] = cloneDeep(tempSegmentsOnFrame);
+
+        // reset temp variables/buffers for new segment
+        m = 0;
+        tempBuffer = labelmapBufferArray[m].slice(0);
+        tempSegmentsOnFrame = cloneDeep(segmentsOnFrameArray[m]);
+    }
+}
+
+const getSegmentIndex = (multiframe, frame) => {
+    const { PerFrameFunctionalGroupsSequence, SharedFunctionalGroupsSequence } =
+        multiframe;
+    const PerFrameFunctionalGroups = PerFrameFunctionalGroupsSequence[frame];
+    return PerFrameFunctionalGroups &&
+        PerFrameFunctionalGroups.SegmentIdentificationSequence
+        ? PerFrameFunctionalGroups.SegmentIdentificationSequence
+              .ReferencedSegmentNumber
+        : SharedFunctionalGroupsSequence.SegmentIdentificationSequence
+        ? SharedFunctionalGroupsSequence.SegmentIdentificationSequence
+              .ReferencedSegmentNumber
+        : undefined;
+};
+
+function insertPixelDataPlanar(
+    segmentsOnFrame,
+    segmentsOnFrameArray,
+    labelmapBufferArray,
+    pixelData,
+    multiframe,
+    imageIds,
+    validOrientations,
+    metadataProvider,
+    tolerance
+) {
+    const {
+        SharedFunctionalGroupsSequence,
+        PerFrameFunctionalGroupsSequence,
+        Rows,
+        Columns
+    } = multiframe;
+
+    const sharedImageOrientationPatient =
+        SharedFunctionalGroupsSequence.PlaneOrientationSequence
+            ? SharedFunctionalGroupsSequence.PlaneOrientationSequence
+                  .ImageOrientationPatient
+            : undefined;
+    const sliceLength = Columns * Rows;
+
+    for (
+        let i = 0, groupsLen = PerFrameFunctionalGroupsSequence.length;
+        i < groupsLen;
+        ++i
+    ) {
+        const PerFrameFunctionalGroups = PerFrameFunctionalGroupsSequence[i];
+
+        const ImageOrientationPatientI =
+            sharedImageOrientationPatient ||
+            PerFrameFunctionalGroups.PlaneOrientationSequence
+                .ImageOrientationPatient;
+
+        const pixelDataI2D = ndarray(
+            new Uint8Array(pixelData.buffer, i * sliceLength, sliceLength),
+            [Rows, Columns]
+        );
+
+        const alignedPixelDataI = alignPixelDataWithSourceData(
+            pixelDataI2D,
+            ImageOrientationPatientI,
+            validOrientations,
+            tolerance
+        );
+
+        if (!alignedPixelDataI) {
+            throw new Error(
+                "Individual SEG frames are out of plane with respect to the first SEG frame. " +
+                    "This is not yet supported. Aborting segmentation loading."
+            );
+        }
+
+        const segmentIndex = getSegmentIndex(multiframe, i);
+        if (segmentIndex === undefined) {
+            throw new Error(
+                "Could not retrieve the segment index. Aborting segmentation loading."
+            );
+        }
+
+        const imageId = findReferenceSourceImageId(
+            multiframe,
+            i,
+            imageIds,
+            metadataProvider,
+            tolerance
+        );
+
+        if (!imageId) {
+            console.warn(
+                "Image not present in stack, can't import frame : " + i + "."
+            );
+            continue;
+        }
+
+        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 imageIdIndex = imageIds.findIndex(element => element === imageId);
+        const byteOffset = sliceLength * 2 * imageIdIndex; // 2 bytes/pixel
+
+        const labelmap2DView = new Uint16Array(
+            labelmapBufferArray[0],
+            byteOffset,
+            sliceLength
+        );
+
+        const data = alignedPixelDataI.data;
+        for (let j = 0, len = alignedPixelDataI.data.length; j < len; ++j) {
+            if (data[j]) {
+                for (let x = j; x < len; ++x) {
+                    if (data[x]) {
+                        labelmap2DView[x] = segmentIndex;
+                    }
+                }
+
+                if (!segmentsOnFrame[imageIdIndex]) {
+                    segmentsOnFrame[imageIdIndex] = [];
+                }
+
+                segmentsOnFrame[imageIdIndex].push(segmentIndex);
+
+                break;
+            }
+        }
+    }
+}
+
+function checkOrientation(
+    multiframe,
+    validOrientations,
+    sourceDataDimensions,
+    tolerance
+) {
+    const { SharedFunctionalGroupsSequence, PerFrameFunctionalGroupsSequence } =
+        multiframe;
+
+    const sharedImageOrientationPatient =
+        SharedFunctionalGroupsSequence.PlaneOrientationSequence
+            ? SharedFunctionalGroupsSequence.PlaneOrientationSequence
+                  .ImageOrientationPatient
+            : undefined;
+
+    // Check if in plane.
+    const PerFrameFunctionalGroups = PerFrameFunctionalGroupsSequence[0];
+
+    const iop =
+        sharedImageOrientationPatient ||
+        PerFrameFunctionalGroups.PlaneOrientationSequence
+            .ImageOrientationPatient;
+
+    const inPlane = validOrientations.some(operation =>
+        compareArrays(iop, operation, tolerance)
+    );
+
+    if (inPlane) {
+        return "Planar";
+    }
+
+    if (
+        checkIfPerpendicular(iop, validOrientations[0], tolerance) &&
+        sourceDataDimensions.includes(multiframe.Rows) &&
+        sourceDataDimensions.includes(multiframe.Columns)
+    ) {
+        // Perpendicular and fits on same grid.
+        return "Perpendicular";
+    }
+
+    return "Oblique";
+}
+
+/**
+ * checkIfPerpendicular - Returns true if iop1 and iop2 are perpendicular
+ * within a tolerance.
+ *
+ * @param  {Number[6]} iop1 An ImageOrientationPatient array.
+ * @param  {Number[6]} iop2 An ImageOrientationPatient array.
+ * @param  {Number} tolerance.
+ * @return {Boolean} True if iop1 and iop2 are equal.
+ */
+function checkIfPerpendicular(iop1, iop2, tolerance) {
+    const absDotColumnCosines = Math.abs(
+        iop1[0] * iop2[0] + iop1[1] * iop2[1] + iop1[2] * iop2[2]
+    );
+    const absDotRowCosines = Math.abs(
+        iop1[3] * iop2[3] + iop1[4] * iop2[4] + iop1[5] * iop2[5]
+    );
+
+    return (
+        (absDotColumnCosines < tolerance ||
+            Math.abs(absDotColumnCosines - 1) < tolerance) &&
+        (absDotRowCosines < tolerance ||
+            Math.abs(absDotRowCosines - 1) < tolerance)
+    );
+}
+
+/**
+ * unpackPixelData - Unpacks bitpacked pixelData if the Segmentation is BINARY.
+ *
+ * @param  {Object} multiframe The multiframe dataset.
+ * @return {Uint8Array}      The unpacked pixelData.
+ */
+function unpackPixelData(multiframe) {
+    const segType = multiframe.SegmentationType;
+
+    let data;
+    if (Array.isArray(multiframe.PixelData)) {
+        data = multiframe.PixelData[0];
+    } else {
+        data = multiframe.PixelData;
+    }
+
+    if (data === undefined) {
+        log.error("This segmentation pixeldata is undefined.");
+    }
+
+    if (segType === "BINARY") {
+        return BitArray.unpack(data);
+    }
+
+    const pixelData = new Uint8Array(data);
+
+    const max = multiframe.MaximumFractionalValue;
+    const onlyMaxAndZero =
+        pixelData.find(element => element !== 0 && element !== max) ===
+        undefined;
+
+    if (!onlyMaxAndZero) {
+        // This is a fractional segmentation, which is not currently supported.
+        return;
+    }
+
+    log.warn(
+        "This segmentation object is actually binary... processing as such."
+    );
+
+    return pixelData;
+}
+
+/**
+ * getImageIdOfSourceImagebySourceImageSequence - Returns the Cornerstone imageId of the source image.
+ *
+ * @param  {Object}   SourceImageSequence  Sequence describing the source image.
+ * @param  {String[]} imageIds             A list of imageIds.
+ * @param  {Object}   metadataProvider     A Cornerstone metadataProvider to query
+ *                                         metadata from imageIds.
+ * @return {String}                        The corresponding imageId.
+ */
+function getImageIdOfSourceImagebySourceImageSequence(
+    SourceImageSequence,
+    imageIds,
+    metadataProvider
+) {
+    const { ReferencedSOPInstanceUID, ReferencedFrameNumber } =
+        SourceImageSequence;
+
+    return ReferencedFrameNumber
+        ? getImageIdOfReferencedFrame(
+              ReferencedSOPInstanceUID,
+              ReferencedFrameNumber,
+              imageIds,
+              metadataProvider
+          )
+        : getImageIdOfReferencedSingleFramedSOPInstance(
+              ReferencedSOPInstanceUID,
+              imageIds,
+              metadataProvider
+          );
+}
+
+/**
+ * getImageIdOfSourceImagebyGeometry - Returns the Cornerstone imageId of the source image.
+ *
+ * @param  {String}    ReferencedSeriesInstanceUID    Referenced series of the source image.
+ * @param  {String}    FrameOfReferenceUID            Frame of reference.
+ * @param  {Object}    PerFrameFunctionalGroup        Sequence describing segmentation reference attributes per frame.
+ * @param  {String[]}  imageIds                       A list of imageIds.
+ * @param  {Object}    metadataProvider               A Cornerstone metadataProvider to query
+ * @param  {Float}     tolerance                      The tolerance parameter
+ *
+ * @return {String}                                   The corresponding imageId.
+ */
+function getImageIdOfSourceImagebyGeometry(
+    ReferencedSeriesInstanceUID,
+    FrameOfReferenceUID,
+    PerFrameFunctionalGroup,
+    imageIds,
+    metadataProvider,
+    tolerance
+) {
+    if (
+        ReferencedSeriesInstanceUID === undefined ||
+        PerFrameFunctionalGroup.PlanePositionSequence === undefined ||
+        PerFrameFunctionalGroup.PlanePositionSequence[0] === undefined ||
+        PerFrameFunctionalGroup.PlanePositionSequence[0]
+            .ImagePositionPatient === undefined
+    ) {
+        return undefined;
+    }
+
+    for (
+        let imageIdsIndexc = 0;
+        imageIdsIndexc < imageIds.length;
+        ++imageIdsIndexc
+    ) {
+        const sourceImageMetadata = metadataProvider.get(
+            "instance",
+            imageIds[imageIdsIndexc]
+        );
+
+        if (
+            sourceImageMetadata === undefined ||
+            sourceImageMetadata.ImagePositionPatient === undefined ||
+            sourceImageMetadata.FrameOfReferenceUID !== FrameOfReferenceUID ||
+            sourceImageMetadata.SeriesInstanceUID !==
+                ReferencedSeriesInstanceUID
+        ) {
+            continue;
+        }
+
+        if (
+            compareArrays(
+                PerFrameFunctionalGroup.PlanePositionSequence[0]
+                    .ImagePositionPatient,
+                sourceImageMetadata.ImagePositionPatient,
+                tolerance
+            )
+        ) {
+            return imageIds[imageIdsIndexc];
+        }
+    }
+}
+
+/**
+ * getImageIdOfReferencedSingleFramedSOPInstance - Returns the imageId
+ * corresponding to the specified sopInstanceUid for single-frame images.
+ *
+ * @param  {String} sopInstanceUid   The sopInstanceUid of the desired image.
+ * @param  {String[]} imageIds         The list of imageIds.
+ * @param  {Object} metadataProvider The metadataProvider to obtain sopInstanceUids
+ *                                 from the cornerstone imageIds.
+ * @return {String}                  The imageId that corresponds to the sopInstanceUid.
+ */
+function getImageIdOfReferencedSingleFramedSOPInstance(
+    sopInstanceUid,
+    imageIds,
+    metadataProvider
+) {
+    return imageIds.find(imageId => {
+        const sopCommonModule = metadataProvider.get(
+            "sopCommonModule",
+            imageId
+        );
+        if (!sopCommonModule) {
+            return;
+        }
+
+        return sopCommonModule.sopInstanceUID === sopInstanceUid;
+    });
+}
+
+/**
+ * getImageIdOfReferencedFrame - Returns the imageId corresponding to the
+ * specified sopInstanceUid and frameNumber for multi-frame images.
+ *
+ * @param  {String} sopInstanceUid   The sopInstanceUid of the desired image.
+ * @param  {Number} frameNumber      The frame number.
+ * @param  {String} imageIds         The list of imageIds.
+ * @param  {Object} metadataProvider The metadataProvider to obtain sopInstanceUids
+ *                                   from the cornerstone imageIds.
+ * @return {String}                  The imageId that corresponds to the sopInstanceUid.
+ */
+function getImageIdOfReferencedFrame(
+    sopInstanceUid,
+    frameNumber,
+    imageIds,
+    metadataProvider
+) {
+    const imageId = imageIds.find(imageId => {
+        const sopCommonModule = metadataProvider.get(
+            "sopCommonModule",
+            imageId
+        );
+        if (!sopCommonModule) {
+            return;
+        }
+
+        const imageIdFrameNumber = Number(imageId.split("frame=")[1]);
+
+        return (
+            //frameNumber is zero indexed for cornerstoneWADOImageLoader image Ids.
+            sopCommonModule.sopInstanceUID === sopInstanceUid &&
+            imageIdFrameNumber === frameNumber - 1
+        );
+    });
+
+    return imageId;
+}
+
+/**
+ * getValidOrientations - returns an array of valid orientations.
+ *
+ * @param  {Number[6]} iop The row (0..2) an column (3..5) direction cosines.
+ * @return {Number[8][6]} An array of valid orientations.
+ */
+function getValidOrientations(iop) {
+    const orientations = [];
+
+    // [0,  1,  2]: 0,   0hf,   0vf
+    // [3,  4,  5]: 90,  90hf,  90vf
+    // [6, 7]:      180, 270
+
+    orientations[0] = iop;
+    orientations[1] = flipIOP.h(iop);
+    orientations[2] = flipIOP.v(iop);
+
+    const iop90 = rotateDirectionCosinesInPlane(iop, Math.PI / 2);
+
+    orientations[3] = iop90;
+    orientations[4] = flipIOP.h(iop90);
+    orientations[5] = flipIOP.v(iop90);
+
+    orientations[6] = rotateDirectionCosinesInPlane(iop, Math.PI);
+    orientations[7] = rotateDirectionCosinesInPlane(iop, 1.5 * Math.PI);
+
+    return orientations;
+}
+
+/**
+ * alignPixelDataWithSourceData -
+ *
+ * @param {Ndarray} pixelData2D - The data to align.
+ * @param {Number[6]} iop - The orientation of the image slice.
+ * @param {Number[8][6]} orientations - An array of valid imageOrientationPatient values.
+ * @param {Number} tolerance.
+ * @return {Ndarray} The aligned pixelData.
+ */
+function alignPixelDataWithSourceData(
+    pixelData2D,
+    iop,
+    orientations,
+    tolerance
+) {
+    if (compareArrays(iop, orientations[0], tolerance)) {
+        return pixelData2D;
+    } else if (compareArrays(iop, orientations[1], tolerance)) {
+        // Flipped vertically.
+
+        // Undo Flip
+        return flipMatrix2D.v(pixelData2D);
+    } else if (compareArrays(iop, orientations[2], tolerance)) {
+        // Flipped horizontally.
+
+        // Unfo flip
+        return flipMatrix2D.h(pixelData2D);
+    } else if (compareArrays(iop, orientations[3], tolerance)) {
+        //Rotated 90 degrees
+
+        // Rotate back
+        return rotateMatrix902D(pixelData2D);
+    } else if (compareArrays(iop, orientations[4], tolerance)) {
+        //Rotated 90 degrees and fliped horizontally.
+
+        // Undo flip and rotate back.
+        return rotateMatrix902D(flipMatrix2D.h(pixelData2D));
+    } else if (compareArrays(iop, orientations[5], tolerance)) {
+        // Rotated 90 degrees and fliped vertically
+
+        // Unfo flip and rotate back.
+        return rotateMatrix902D(flipMatrix2D.v(pixelData2D));
+    } else if (compareArrays(iop, orientations[6], tolerance)) {
+        // Rotated 180 degrees. // TODO -> Do this more effeciently, there is a 1:1 mapping like 90 degree rotation.
+
+        return rotateMatrix902D(rotateMatrix902D(pixelData2D));
+    } else if (compareArrays(iop, orientations[7], tolerance)) {
+        // Rotated 270 degrees
+
+        // Rotate back.
+        return rotateMatrix902D(
+            rotateMatrix902D(rotateMatrix902D(pixelData2D))
+        );
+    }
+}
+
+/**
+ * compareArrays - Returns true if array1 and array2 are equal
+ * within a tolerance.
+ *
+ * @param  {Number[]} array1 - An array.
+ * @param  {Number[]} array2 - An array.
+ * @param {Number} tolerance.
+ * @return {Boolean} True if array1 and array2 are equal.
+ */
+function compareArrays(array1, array2, tolerance) {
+    if (array1.length != array2.length) {
+        return false;
+    }
+
+    for (let i = 0; i < array1.length; ++i) {
+        if (!nearlyEqual(array1[i], array2[i], tolerance)) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+function getSegmentMetadata(multiframe, seriesInstanceUid) {
+    const segmentSequence = multiframe.SegmentSequence;
+    let data = [];
+
+    if (Array.isArray(segmentSequence)) {
+        data = [undefined, ...segmentSequence];
+    } else {
+        // Only one segment, will be stored as an object.
+        data = [undefined, segmentSequence];
+    }
+
+    return {
+        seriesInstanceUid,
+        data
+    };
+}