@abasb75/dicom-parser 0.0.0-test2 → 0.0.0-test20a

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@abasb75/dicom-parser",
-    "version": "0.0.0-test2",
+    "version": "0.0.0-test20a",
     "description": "a javascript powerfull dicom parser",
     "main": "index.js",
     "type": "module",
@@ -16,7 +16,7 @@
     "license": "ISC",
     "repository": {
         "type": "git",
-        "url": "git+https://github.com/abasb75/dicom-parser/raction.git"
+        "url": "https://github.com/abasb75/dicom-parser.git"
     },
     "bugs": {
         "url": "https://github.com/abasb75/dicom-parser/issues"

package/types.d.ts

@@ -0,0 +1,96 @@
+import Dataset from "./Dataset";
+import Tag from "./Tag";
+interface Tags {
+    [key: string]: Tag;
+}
+interface DicomDate {
+    year: string | number;
+    month: string | number;
+    day: string | number;
+}
+interface DicomTime {
+    hour: string | number;
+    minute: string | number;
+    second: string | number;
+}
+interface DicomDateTime extends DicomDate, DicomTime {
+}
+type DicomDataset = Dataset;
+type PixelArray = Int16Array | Uint16Array | Int32Array | Uint32Array | Int8Array | Uint8Array | Float32Array;
+interface DicomVOILutModule {
+    voiLUTFunction: string;
+    windowWidth: number | undefined;
+    windowCenter: number | undefined;
+    voiLUTSequence: unknown;
+    lutDescriptor: any;
+    lutExplanation: any;
+    lutData: any;
+    windowCenterAndWidthExplanation: string;
+}
+interface DicomPatientModule {
+    patientName: string;
+    patientID: string;
+    typeofPatientID: string;
+    patientSex: string;
+    patientBirthDate: string;
+    patientAge: string;
+    patientSize: string;
+    otherPatientIDs: string;
+    otherPatientNames: string;
+    patientWeight: string;
+}
+interface DicomPixelModule {
+    photometricInterpretation: string;
+    numberOfFrames: number | undefined;
+    pixelRepresentation: number | undefined;
+    pixeSpacing: any | undefined;
+    rows: number | number | undefined;
+    columns: number | number | undefined;
+    bitsAllocated: number | undefined;
+    highBit: number | undefined;
+    bitsStored: number | undefined;
+    samplesPerPixel: number | undefined;
+    pixelDataProviderURL: any;
+    pixelPaddingRangeLimit: any;
+    extendedOffsetTable: any;
+    extendedOffsetTableLengths: any;
+    pixelAspectRatio: any;
+    planarConfiguration: number | undefined;
+    redPaletteColorLookupTableDescriptor: unknown;
+    greenPaletteColorLookupTableDescriptor: unknown;
+    bluePaletteColorLookupTableDescriptor: unknown;
+    alphaPaletteColorLookupTableDescriptor: unknown;
+    redPaletteColorLookupTableData: any;
+    greenPaletteColorLookupTableData: any;
+    bluePaletteColorLookupTableData: any;
+    alphaPaletteColorLookupTableData: any;
+    segmentedRedPaletteColorLookupTableData: any;
+    segmentedGreenPaletteColorLookupTableData: any;
+    segmentedBluePaletteColorLookupTableData: any;
+    segmentedAlphaPaletteColorLookupTableData: any;
+}
+interface DicomScalingModule {
+    rescaleSlope: number | undefined;
+    rescaleIntercept: number | undefined;
+    modality: string;
+}
+interface PixelDataDecodeOptions {
+    pixelData: DataView;
+    bitsAllocated: number;
+    pixelRepresentation: number;
+    littleEndian: boolean;
+    dataset?: Dataset;
+}
+interface PaletteColorDataColor {
+    data: number[];
+    firstInputValueMapped: number;
+    lutEntries: number;
+    bitsPerEntry: number;
+}
+interface PaletteColorData {
+    red: PaletteColorDataColor | undefined;
+    green: PaletteColorDataColor | undefined;
+    blue: PaletteColorDataColor | undefined;
+    alpha: PaletteColorDataColor | undefined;
+}
+export type { Tags, DicomTime, DicomDate, DicomDateTime, DicomDataset, DicomVOILutModule, DicomPatientModule, DicomPixelModule, DicomScalingModule, PixelArray, PixelDataDecodeOptions, PaletteColorData, PaletteColorDataColor, };

package/types.js

@@ -0,0 +1 @@
+export {};

package/utils/PaletteColor.d.ts

@@ -0,0 +1,10 @@
+import Dataset from "../Dataset";
+import { PaletteColorData } from "../types";
+declare class PaletteColor {
+    static get(dataset: Dataset): PaletteColorData | undefined;
+    private static getData;
+    private static get16Array;
+    private static get8Array;
+    private static segmentedDataToData;
+}
+export default PaletteColor;

package/utils/PaletteColor.js

@@ -0,0 +1,155 @@
+var PaletteColor = /** @class */ (function () {
+    function PaletteColor() {
+    }
+    Object.defineProperty(PaletteColor, "get", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (dataset) {
+            var _a = dataset.pixelModule, redPaletteColorLookupTableData = _a.redPaletteColorLookupTableData, redPaletteColorLookupTableDescriptor = _a.redPaletteColorLookupTableDescriptor, segmentedRedPaletteColorLookupTableData = _a.segmentedRedPaletteColorLookupTableData, greenPaletteColorLookupTableData = _a.greenPaletteColorLookupTableData, greenPaletteColorLookupTableDescriptor = _a.greenPaletteColorLookupTableDescriptor, segmentedGreenPaletteColorLookupTableData = _a.segmentedGreenPaletteColorLookupTableData, bluePaletteColorLookupTableData = _a.bluePaletteColorLookupTableData, bluePaletteColorLookupTableDescriptor = _a.bluePaletteColorLookupTableDescriptor, segmentedAlphaPaletteColorLookupTableData = _a.segmentedAlphaPaletteColorLookupTableData, alphaPaletteColorLookupTableData = _a.alphaPaletteColorLookupTableData, alphaPaletteColorLookupTableDescriptor = _a.alphaPaletteColorLookupTableDescriptor, segmentedBluePaletteColorLookupTableData = _a.segmentedBluePaletteColorLookupTableData, bitsAllocated = _a.bitsAllocated;
+            if (!bitsAllocated || ![8, 16].includes(bitsAllocated)) {
+                return undefined;
+            }
+            var littleEndian = dataset.littleEndian;
+            var red = PaletteColor.getData(redPaletteColorLookupTableDescriptor, redPaletteColorLookupTableData, segmentedRedPaletteColorLookupTableData, bitsAllocated, littleEndian);
+            var green = PaletteColor.getData(greenPaletteColorLookupTableDescriptor, greenPaletteColorLookupTableData, segmentedGreenPaletteColorLookupTableData, bitsAllocated, littleEndian);
+            var blue = PaletteColor.getData(bluePaletteColorLookupTableDescriptor, bluePaletteColorLookupTableData, segmentedBluePaletteColorLookupTableData, bitsAllocated, littleEndian);
+            var alpha = PaletteColor.getData(alphaPaletteColorLookupTableDescriptor, alphaPaletteColorLookupTableData, segmentedAlphaPaletteColorLookupTableData, bitsAllocated, littleEndian);
+            return {
+                red: red,
+                green: green,
+                blue: blue,
+                alpha: alpha,
+            };
+        }
+    });
+    Object.defineProperty(PaletteColor, "getData", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (descriptor, paletteData, segmentedPaletteData, bitsAllocated, littleEndian) {
+            var _a;
+            if (!Array.isArray(descriptor)
+                || descriptor.length < 3) {
+                return undefined;
+            }
+            var tableDataArray = null;
+            var lutEntries = descriptor[0] || Math.pow(2, 16);
+            var firstInputValueMapped = descriptor[1];
+            var bitsPerEntry = descriptor[2];
+            if (![8, 16].includes(bitsPerEntry)) {
+                return undefined;
+            }
+            if (paletteData) {
+                tableDataArray = bitsPerEntry === 16
+                    ? PaletteColor.get16Array(paletteData, bitsAllocated, littleEndian)
+                    : PaletteColor.get8Array(paletteData);
+            }
+            else if (segmentedPaletteData) {
+                var segmentedTableDataArray = bitsPerEntry === 16
+                    ? PaletteColor.get16Array(segmentedPaletteData, bitsAllocated, littleEndian)
+                    : PaletteColor.get8Array(segmentedPaletteData);
+                tableDataArray = (_a = PaletteColor.segmentedDataToData(segmentedTableDataArray, lutEntries)) === null || _a === void 0 ? void 0 : _a.tableData;
+            }
+            if (!tableDataArray) {
+                return undefined;
+            }
+            return {
+                data: tableDataArray,
+                firstInputValueMapped: firstInputValueMapped,
+                lutEntries: lutEntries,
+                bitsPerEntry: bitsPerEntry
+            };
+        }
+    });
+    Object.defineProperty(PaletteColor, "get16Array", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (paletteData, bitsAllocated, littleEndian) {
+            var array = [];
+            for (var i = 0; i < paletteData.byteLength; i += 2) {
+                if (bitsAllocated === 8) {
+                    array.push(paletteData.getUint16(i, littleEndian) >> 8);
+                }
+                else {
+                    array.push(paletteData.getUint16(i, littleEndian));
+                }
+            }
+            return array;
+        }
+    });
+    Object.defineProperty(PaletteColor, "get8Array", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (paletteData) {
+            var array = [];
+            for (var i = 0; i < paletteData.byteLength; i++) {
+                array.push(paletteData.getUint8(i));
+            }
+            return array;
+        }
+    });
+    Object.defineProperty(PaletteColor, "segmentedDataToData", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (segmentedTableData, lutEntries, segmentedTableDataOffset, valuedTableData, valuedTableDataOffset, stopIndex, prevLastValue) {
+            var tableData = valuedTableData
+                ? valuedTableData : new Array(lutEntries);
+            var segmentedDataOffset = segmentedTableDataOffset || 0;
+            var tableDataOffset = valuedTableDataOffset || 0;
+            var lastValue = prevLastValue || undefined;
+            while (segmentedDataOffset < (stopIndex || segmentedTableData.length)) {
+                var op = segmentedTableData[segmentedDataOffset];
+                segmentedDataOffset++;
+                var len = segmentedTableData[segmentedDataOffset];
+                segmentedDataOffset++;
+                if (op === 2) {
+                    console.log({ op: op });
+                }
+                switch (op) {
+                    case 0:
+                        for (var i = 0; i < len; i++) {
+                            tableData[tableDataOffset] = segmentedTableData[segmentedDataOffset];
+                            segmentedDataOffset++;
+                            tableDataOffset++;
+                        }
+                        lastValue = tableData[segmentedDataOffset - 1] & 0xFFFF;
+                        break;
+                    case 1:
+                        if (typeof lastValue !== "number") {
+                            return null;
+                        }
+                        var newValue = segmentedTableData[segmentedDataOffset];
+                        segmentedDataOffset++;
+                        for (var i = 1; i <= len; i++) {
+                            tableData[tableDataOffset] = (lastValue + ((newValue - lastValue) / len));
+                            tableDataOffset++;
+                        }
+                        lastValue = newValue & 0xFFFF;
+                        break;
+                    case 2: // untested
+                        if (typeof lastValue !== "number") {
+                            return null;
+                        }
+                        var startPosition = (segmentedTableData[segmentedDataOffset] & 0xffff)
+                            | ((segmentedTableData[segmentedDataOffset + 1] & 0xffff) << 16);
+                        segmentedDataOffset += 2;
+                        var res = PaletteColor.segmentedDataToData(segmentedTableData, lutEntries, startPosition, tableData, tableDataOffset, startPosition + len, lastValue);
+                        lastValue = res === null || res === void 0 ? void 0 : res.lastValue;
+                        tableData = res === null || res === void 0 ? void 0 : res.tableData;
+                        segmentedDataOffset = res === null || res === void 0 ? void 0 : res.segmentedDataOffset;
+                        tableDataOffset = res === null || res === void 0 ? void 0 : res.tableDataOffset;
+                        break;
+                    default:
+                        return null;
+                }
+            }
+            return { tableData: tableData, lastValue: lastValue, segmentedDataOffset: segmentedDataOffset, tableDataOffset: tableDataOffset };
+        }
+    });
+    return PaletteColor;
+}());
+export default PaletteColor;

package/utils/PixelData.d.ts

@@ -0,0 +1,14 @@
+import Dataset from "../Dataset";
+declare class PixelData {
+    static get(dataset: Dataset, frame?: number): Promise<DataView>;
+    private static _getixelDataViews;
+    private static _encapsulatePixelDatas;
+    private static _concatArrayBuffers;
+    private static _makeBasicOffsetTable;
+    private static _makeBasicOfsetTableForJPEGImages;
+    private static _isJPEG;
+    private static _isJPEG2000;
+    private static _makeFragments;
+    private static bitToByte;
+}
+export default PixelData;

package/utils/PixelData.js

@@ -0,0 +1,285 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var PixelData = /** @class */ (function () {
+    function PixelData() {
+    }
+    Object.defineProperty(PixelData, "get", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (dataset_1) {
+            return __awaiter(this, arguments, void 0, function (dataset, frame) {
+                var pixelData;
+                if (frame === void 0) { frame = 0; }
+                return __generator(this, function (_a) {
+                    pixelData = PixelData._getixelDataViews(dataset, frame);
+                    return [2 /*return*/, pixelData];
+                });
+            });
+        }
+    });
+    Object.defineProperty(PixelData, "_getixelDataViews", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (dataset, frameIndex) {
+            var _a;
+            var pixelDataElement = dataset.tags['0x7FE00010'] || dataset.tags['0x7FE00008'] || dataset.tags['0x7FE00009'];
+            if (!pixelDataElement) {
+                throw new Error("dicom has not pixels");
+            }
+            var numberOfFrames = dataset.pixelModule.numberOfFrames || 1;
+            if (pixelDataElement.valueLength === 0xFFFFFFFF) {
+                return PixelData._encapsulatePixelDatas(dataset, pixelDataElement, frameIndex);
+            }
+            else {
+                var _b = dataset === null || dataset === void 0 ? void 0 : dataset.pixelModule, columns = _b.columns, rows = _b.rows, samplesPerPixel = _b.samplesPerPixel, bitsAllocated = _b.bitsAllocated;
+                var frameLen = 0;
+                if ((_a = dataset.pixelModule) === null || _a === void 0 ? void 0 : _a.numberOfFrames) {
+                    frameLen = pixelDataElement.valueLength / numberOfFrames;
+                }
+                else if (columns && rows && samplesPerPixel && bitsAllocated) {
+                    var bytesAllocated = PixelData.bitToByte(bitsAllocated);
+                    frameLen = rows * columns * bytesAllocated * samplesPerPixel;
+                }
+                else {
+                    frameLen = pixelDataElement.valueLength / numberOfFrames;
+                }
+                frameLen = Math.min(frameLen, pixelDataElement.valueLength);
+                var offset = pixelDataElement.offset + (frameLen * frameIndex);
+                return new DataView(dataset.dataView.buffer.slice(offset, offset + frameLen));
+            }
+        }
+    });
+    Object.defineProperty(PixelData, "_encapsulatePixelDatas", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (dataset, pixelDataElement, frameIndex) {
+            if (!dataset.basicOffsetTable) {
+                dataset.basicOffsetTable = PixelData._makeBasicOffsetTable(dataset, pixelDataElement);
+            }
+            if (!dataset.basicOffsetTable || dataset.basicOffsetTable.length - 1 < frameIndex) {
+                throw new Error("not frame index found.");
+            }
+            var offset = dataset.basicOffsetTable[frameIndex];
+            var nextFrameOffset = dataset.basicOffsetTable.length > frameIndex + 1 ? dataset.basicOffsetTable[frameIndex + 1] : -1;
+            var fragments = [];
+            while (true) {
+                if (nextFrameOffset > 0 && offset >= nextFrameOffset) {
+                    break;
+                }
+                var group = dataset.dataView.getUint16(offset, dataset.littleEndian);
+                offset += 2;
+                var element = dataset.dataView.getUint16(offset, dataset.littleEndian);
+                offset += 2;
+                if (group !== 0xFFFE || element !== 0xE000) {
+                    break;
+                }
+                var len = dataset.dataView.getUint32(offset, dataset.littleEndian);
+                offset += 4;
+                fragments.push(dataset.dataView.buffer.slice(offset, offset + len));
+                offset += len;
+            }
+            if (fragments.length < 1) {
+                throw new Error("image not created");
+            }
+            var buffer = fragments[0];
+            for (var i = 1; i < fragments.length; i++) {
+                buffer = PixelData._concatArrayBuffers(buffer, fragments[i]);
+            }
+            return new DataView(buffer);
+        }
+    });
+    Object.defineProperty(PixelData, "_concatArrayBuffers", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (buffer1, buffer2) {
+            var tmp = new Uint8Array(buffer1.byteLength + buffer2.byteLength);
+            tmp.set(new Uint8Array(buffer1), 0);
+            tmp.set(new Uint8Array(buffer2), buffer1.byteLength);
+            return tmp.buffer;
+        }
+    });
+    ;
+    Object.defineProperty(PixelData, "_makeBasicOffsetTable", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (dataset, pixelDataElement) {
+            var offset = pixelDataElement.offset;
+            var group = dataset.dataView.getUint16(offset, dataset.littleEndian);
+            offset += 2;
+            var element = dataset.dataView.getUint16(offset, dataset.littleEndian);
+            offset += 2;
+            if (group !== 0xFFFE && element !== 0xE000) {
+                throw new Error("is not basic table");
+            }
+            var len = dataset.dataView.getUint32(offset, dataset.littleEndian);
+            offset += 4;
+            var basicOffsetTable = [];
+            var basicOffsetIndex = offset + len;
+            if (len > 0) {
+                for (var i = 0; i < len; i += 4) {
+                    basicOffsetTable.push(basicOffsetIndex + dataset.dataView.getUint16(offset, dataset.littleEndian));
+                    offset += 4;
+                }
+                return basicOffsetTable;
+            }
+            var basicOffsetTableElement = dataset.tags['0x7FE00001'];
+            if (basicOffsetTableElement && basicOffsetTableElement.valueLength > 0) {
+                for (var i = 0; i < len; i += 4) {
+                    offset = basicOffsetTableElement.offset;
+                    basicOffsetTable.push(basicOffsetIndex + dataset.dataView.getUint16(offset, dataset.littleEndian));
+                    offset += 4;
+                }
+                return basicOffsetTable;
+            }
+            var numberOfFrames = dataset.pixelModule.numberOfFrames || 1;
+            if (numberOfFrames === 1) {
+                return [basicOffsetIndex];
+            }
+            var fragments = this._makeFragments(dataset, basicOffsetIndex);
+            if (fragments.length === numberOfFrames) {
+                return fragments.map(function (fragment) { return fragment.offset; });
+            }
+            return PixelData._makeBasicOfsetTableForJPEGImages(dataset, fragments);
+        }
+    });
+    Object.defineProperty(PixelData, "_makeBasicOfsetTableForJPEGImages", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (dataset, fragments) {
+            var basicOffsetTable = [];
+            for (var i = 0; i < fragments.length; i++) {
+                var fragment = fragments[i];
+                if (PixelData._isJPEG(fragment.offset + 8, dataset.dataView)
+                    || PixelData._isJPEG2000(fragment.offset + 8, dataset.dataView)) {
+                    basicOffsetTable.push(fragment.offset);
+                }
+            }
+            return basicOffsetTable;
+        }
+    });
+    Object.defineProperty(PixelData, "_isJPEG", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (position, dataView) {
+            var magic1 = dataView.getUint8(position);
+            var magic2 = dataView.getUint8(position + 1);
+            if (magic1 === 0xFF && magic2 === 0xD8) {
+                return true;
+            }
+            return false;
+        }
+    });
+    Object.defineProperty(PixelData, "_isJPEG2000", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (position, dataView) {
+            var magics2 = [0xFF, 0x4F, 0xFF, 0x51];
+            for (var i = 0; i < magics2.length; i++) {
+                var finded = dataView.getUint8(position + i);
+                if (finded !== magics2[i]) {
+                    break;
+                }
+                else if (i === magics2.length - 1) {
+                    return true;
+                }
+            }
+            var magics = [0x00, 0x00, 0x00, 0x0C, 0x6A, 0x50, 0x20, 0x20, 0x0D, 0x0A, 0x87, 0x0A];
+            for (var i = 0; i < magics.length; i++) {
+                var finded = dataView.getInt8(position + i);
+                if (finded !== magics[i]) {
+                    break;
+                }
+                else if (i === magics2.length - 1) {
+                    return true;
+                }
+            }
+            return false;
+        }
+    });
+    Object.defineProperty(PixelData, "_makeFragments", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (dataset, basicOffsetIndex) {
+            var fragments = [];
+            var offset = basicOffsetIndex;
+            var dataView = dataset.dataView;
+            while (true) {
+                if (offset >= dataView.byteLength) {
+                    break;
+                }
+                var group = dataset.dataView.getUint16(offset, dataset.littleEndian);
+                offset += 2;
+                var element = dataset.dataView.getUint16(offset, dataset.littleEndian);
+                offset += 2;
+                if (group !== 0xFFFE || element !== 0xE000) {
+                    break;
+                }
+                var len = dataset.dataView.getUint16(offset, dataset.littleEndian);
+                offset += 4;
+                var fragment = {
+                    offset: offset - 8,
+                    len: len,
+                };
+                fragments.push(fragment);
+                offset += len;
+            }
+            return fragments;
+        }
+    });
+    Object.defineProperty(PixelData, "bitToByte", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (bit) {
+            if (bit <= 8) {
+                return bit / 8;
+            }
+            return Math.ceil(bit / 8);
+        }
+    });
+    return PixelData;
+}());
+export default PixelData;