@abasb75/dicom-parser 0.0.6-test → 0.0.20

package/Parser.js

@@ -1,241 +0,0 @@
-import Dataset from "./Dataset";
-import Tag from "./Tag";
-import Value from "./Value";
-import * as pako from "pako";
-class Parser {
-    constructor(arrayBuffer) {
-        Object.defineProperty(this, "arrayBuffer", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "offset", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "dataView", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "tags", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: {}
-        });
-        Object.defineProperty(this, "dataSet", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "EXEPTED", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: ["OB", "OW", "SQ", "UN", "UT"]
-        });
-        Object.defineProperty(this, "VRS", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: ["AE", "AS", "AT", "CS", "DA", "DS", "DT", "FL", "FD", "IS", "LO", "LT", "OB", "OD", "OF", "OW", "PN", "SH", "SL", "SS", "ST", "TM", "UI", "UL", "UN", "US", "UT", "UC"]
-        });
-        Object.defineProperty(this, "IMPLICT_TRANSFER_SYNTAXES", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: ["1.2.840.10008.1.2"]
-        });
-        Object.defineProperty(this, "BIG_ENDIAN_TRANSFER_SYNTAXES", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: ["1.2.840.10008.1.2.2"]
-        });
-        Object.defineProperty(this, "DEFLATED_TRANSFER_SYNTAXES", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: ["1.2.840.10008.1.2.1.99"]
-        });
-        Object.defineProperty(this, "littleEndian", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: true
-        });
-        Object.defineProperty(this, "implicit", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        Object.defineProperty(this, "transferSyntaxUID", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: ""
-        });
-        // private UNDEFIENED_LEN:number = 0xffffffff;
-        Object.defineProperty(this, "inflated", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        Object.defineProperty(this, "concatArrayBuffers", {
-            enumerable: true,
-            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;
-            }
-        });
-        this.offset = 0;
-        this.arrayBuffer = arrayBuffer;
-        this.dataView = new DataView(arrayBuffer);
-        if (this.arrayBuffer.byteLength < 132) {
-            console.error("is not valid dicom file");
-            return;
-        }
-        const prefix = Value.getString(new Uint8Array(arrayBuffer, 128, 4));
-        if (prefix !== 'DICM') {
-            console.error("is not valid dicom file");
-            return;
-        }
-        this.offset = 132;
-        this.parse();
-    }
-    parse() {
-        this.getNextElement();
-        this.dataSet = new Dataset(this.tags, this.dataView, this.littleEndian);
-        console.log(this.dataSet);
-        this.dataSet.transferSyntaxUID = this.transferSyntaxUID;
-        return this.dataSet;
-    }
-    getDataset() {
-        return this.dataSet;
-    }
-    getNextElement() {
-        if (this.offset >= this.arrayBuffer.byteLength) {
-            return;
-        }
-        const { group, element } = this.getNextGroupAndElement();
-        if (!group && !element) {
-            return;
-        }
-        if (group === 0xFFFE && (element === 0xE0DD || element === 0xE00D || element === 0xE000)) {
-            this.offset += 4;
-            return this.getNextElement();
-        }
-        if (!this.implicit && group !== 0x0002 && this.IMPLICT_TRANSFER_SYNTAXES.includes(this.transferSyntaxUID)) {
-            this.implicit = true;
-        }
-        if (this.littleEndian && group !== 0x0002 && this.BIG_ENDIAN_TRANSFER_SYNTAXES.includes(this.transferSyntaxUID)) {
-            this.littleEndian = false;
-        }
-        if (!this.inflated && group !== 0x0002 && this.DEFLATED_TRANSFER_SYNTAXES.includes(this.transferSyntaxUID)) {
-            this.offset -= 4;
-            const meta = this.dataView.buffer.slice(0, this.offset);
-            const body = this.dataView.buffer.slice(this.offset);
-            const infaltedBody = pako.inflateRaw(body);
-            this.arrayBuffer = this.concatArrayBuffers(meta, infaltedBody);
-            this.dataView = new DataView(this.arrayBuffer);
-            this.inflated = true;
-            return this.getNextElement();
-        }
-        const vr = this.getNextVR(group, element);
-        let len = 0;
-        if (this.implicit) {
-            len = this.dataView.getUint32(this.offset, this.littleEndian);
-            this.offset += 4;
-        }
-        else if (this.EXEPTED.includes(vr)) {
-            this.offset += 2; // skip 2 byte reserved
-            len = this.dataView.getUint32(this.offset, this.littleEndian);
-            this.offset += 4;
-        }
-        else if (this.VRS.includes(vr)) {
-            len = this.dataView.getUint16(this.offset, this.littleEndian);
-            this.offset += 2;
-        }
-        else if ((!vr || !vr.match(/^[A-Z]{2}$/)) && group === 0x0002 && element === 0x0000) {
-            console.log("pyz");
-            this.offset = 132;
-            this.tags = {};
-            this.implicit = true;
-            return this.getNextElement();
-        }
-        else {
-            return;
-        }
-        if (group === 0x0002 && element === 0x0010) {
-            this.transferSyntaxUID = (Value.getString(new Uint8Array(this.arrayBuffer, this.offset, len))).replace('\0', '');
-        }
-        const tag = new Tag(group, element, vr, len, this.offset);
-        const key = tag.generateKey();
-        this.tags[key] = tag;
-        if (len === 0xFFFFFFFF && group === 0x7FE0 && element === 0x0010) {
-            let { group, element } = this.getNextGroupAndElement();
-            while (true) {
-                if (group === 0xFFFE && element === 0xE000) {
-                    const len = this.dataView.getUint32(this.offset, this.littleEndian);
-                    this.offset += 4;
-                    const t = this.getNextGroupAndElement();
-                    group = t.group;
-                    element = t.element;
-                    this.offset += len;
-                }
-                else {
-                    break;
-                }
-            }
-            this.offset -= 4;
-        }
-        if (vr === "SQ") {
-            this.getNextElement();
-        }
-        else {
-            this.offset += len;
-            this.getNextElement();
-        }
-    }
-    getValue(len) {
-        const value = this.arrayBuffer.slice(this.offset, len);
-        this.offset += len;
-        return value;
-    }
-    getNextGroupAndElement() {
-        try {
-            const group = this.dataView.getUint16(this.offset, this.littleEndian);
-            this.offset += 2;
-            const element = this.dataView.getUint16(this.offset, this.littleEndian);
-            this.offset += 2;
-            return { group, element };
-        }
-        catch (_a) {
-            return { group: 0, element: 0 };
-        }
-    }
-    getNextVR(groupInt, elementInt) {
-        if (this.offset >= this.dataView.byteLength) {
-            return "";
-        }
-        if (this.implicit) {
-            return Tag.getTagVRFromDictionary(groupInt, elementInt) || "AA";
-        }
-        const vr = Value.getString(new Uint8Array(this.arrayBuffer, this.offset, 2));
-        this.offset += 2;
-        return vr;
-    }
-}
-export default Parser;

package/PixelData.d.ts

@@ -1,8 +0,0 @@
-import Dataset from "./Dataset";
-declare class PixelData {
-    static get(dataset: Dataset): import("./types").PixelArray[];
-    private static _getUncompressed;
-    private static _getJPEG2000ImageCompression_LosslessOnly;
-    private static _getixelDataViews;
-}
-export default PixelData;

package/PixelData.js

@@ -1,79 +0,0 @@
-import JPEG2000 from "./decoder/JPEG2000";
-import UncompressDecoderr from "./decoder/Uncompressed";
-class PixelData {
-    static get(dataset) {
-        const transferSyntaxUID = dataset.transferSyntaxUID;
-        switch (transferSyntaxUID) {
-            case "1.2.840.10008.1.2.4.90":
-                return PixelData._getJPEG2000ImageCompression_LosslessOnly(dataset);
-            case "1.2.840.10008.1.2":
-            case "1.2.840.10008.1.2.1":
-            case "1.2.840.10008.1.2.2":
-            case "1.2.840.10008.1.2.1.99":
-            default:
-                return PixelData._getUncompressed(dataset);
-        }
-    }
-    static _getUncompressed(dataset) {
-        const bitsAllocated = dataset.pixelModule.bitsAllocated || 1;
-        const pixelRepresentation = dataset.pixelModule.pixelRepresentation || 0;
-        const pixelDataViews = PixelData._getixelDataViews(dataset);
-        return pixelDataViews.map((dataView) => {
-            return UncompressDecoderr.decode({
-                pixelData: dataView,
-                bitsAllocated,
-                pixelRepresentation,
-                littleEndian: dataset.littleEndian,
-            });
-        });
-    }
-    static _getJPEG2000ImageCompression_LosslessOnly(dataset) {
-        const pixelDataViews = PixelData._getixelDataViews(dataset);
-        return pixelDataViews.map((dataView) => {
-            return JPEG2000.decode({
-                pixelData: dataView,
-                bitsAllocated: dataset.pixelModule.bitsAllocated || 1,
-                pixelRepresentation: dataset.pixelModule.pixelRepresentation || 0,
-                littleEndian: dataset.littleEndian,
-            });
-        });
-    }
-    static _getixelDataViews(dataset) {
-        const pixelData = dataset.tags['0x7FE00010'] || dataset.tags['0x7FE00008'] || dataset.tags['0x7FE00009'];
-        const pixelDatas = [];
-        const numberOfFrames = dataset.pixelModule.numberOfFrames || 1;
-        if (pixelData.valueLength === 0xFFFFFFFF) {
-            let offset = pixelData.offset;
-            while (true) {
-                if (offset >= dataset.dataView.byteLength) {
-                    break;
-                }
-                const group = dataset.dataView.getUint16(offset, dataset.littleEndian);
-                offset += 2;
-                const element = dataset.dataView.getUint16(offset, dataset.littleEndian);
-                offset += 2;
-                if (group !== 0xFFFE && element !== 0xE000) {
-                    break;
-                    ;
-                }
-                const len = dataset.dataView.getUint32(offset, dataset.littleEndian);
-                offset += 4;
-                if (len !== 0) {
-                    const dataView = new DataView(dataset.dataView.buffer, offset, len);
-                    pixelDatas.push(dataView);
-                    offset += len;
-                }
-            }
-        }
-        else {
-            const frameLen = pixelData.valueLength / numberOfFrames;
-            for (let i = 0; i < numberOfFrames; i++) {
-                const offset = pixelData.offset + (frameLen * i);
-                const dataView = new DataView(dataset.dataView.buffer, offset, frameLen);
-                pixelDatas.push(dataView);
-            }
-        }
-        return pixelDatas;
-    }
-}
-export default PixelData;

package/Tag.d.ts

@@ -1,17 +0,0 @@
-declare class Tag {
-    name: string;
-    vr: string;
-    group: number;
-    element: number;
-    value: unknown;
-    valueLength: number;
-    offset: number;
-    constructor(group: number, element: number, vr: string, valueLength: number, offset: number, value?: ArrayBuffer, name?: string | null);
-    generateKey(): string;
-    static getTagNameFromDictionary(groupInt: number, elementInt: number): string;
-    static getTagVRFromDictionary(group: number | string, element: number | string): string;
-    static intTo4digitString(int: number): string;
-    static int8digitString(int: number): string;
-    getValue(): void;
-}
-export default Tag;

package/Tag.js

@@ -1,97 +0,0 @@
-import TagsDictionaryEnums from "./enums/TagsDictionary";
-class Tag {
-    constructor(group, element, vr, valueLength, offset, value, name) {
-        Object.defineProperty(this, "name", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "vr", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "group", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "element", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "value", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "valueLength", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "offset", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.group = group;
-        this.element = element;
-        this.vr = vr;
-        this.name = name || Tag.getTagNameFromDictionary(this.group, this.element) || '';
-        this.value = value || undefined;
-        this.valueLength = valueLength;
-        this.offset = offset;
-        if (this.name === '') {
-        }
-    }
-    generateKey() {
-        const group = Tag.intTo4digitString(this.group);
-        const element = Tag.intTo4digitString(this.element);
-        return `0x${group}${element}`;
-    }
-    static getTagNameFromDictionary(groupInt, elementInt) {
-        const group = Tag.intTo4digitString(groupInt);
-        const element = Tag.intTo4digitString(elementInt);
-        const groupItems = TagsDictionaryEnums[group];
-        if (!groupItems)
-            return "";
-        const elementItem = groupItems[element];
-        if (!elementItem)
-            return "";
-        return elementItem[1];
-    }
-    static getTagVRFromDictionary(group, element) {
-        let _group, _element;
-        if (typeof group === "number") {
-            _group = Tag.intTo4digitString(group);
-        }
-        if (typeof element === "number") {
-            _element = Tag.intTo4digitString(element);
-        }
-        const groupItems = TagsDictionaryEnums[_group || group];
-        if (!groupItems)
-            return "";
-        const elementItem = groupItems[_element || element];
-        if (!elementItem)
-            return "";
-        return elementItem[0];
-    }
-    static intTo4digitString(int) {
-        return ('0000' + int.toString(16).toUpperCase()).slice(-4);
-    }
-    static int8digitString(int) {
-        return ('00000000' + int.toString(16).toUpperCase()).slice(-8);
-    }
-    getValue() {
-    }
-}
-export default Tag;

package/Utitlities.d.ts

@@ -1,12 +0,0 @@
-import { PixelArray } from "./types";
-declare class Utilities {
-    static getMinMax(pixelData: PixelArray): {
-        min: number;
-        max: number;
-    };
-    static getLUTwithMinMax(min: number, max: number): {
-        windowWidth: number;
-        windowCenter: number;
-    };
-}
-export default Utilities;

package/Utitlities.js

@@ -1,19 +0,0 @@
-class Utilities {
-    static getMinMax(pixelData) {
-        let min = pixelData[0];
-        let max = pixelData[0];
-        for (let i = 0; i < pixelData.length; i++) {
-            if (pixelData[i] < min)
-                min = pixelData[i];
-            if (pixelData[i] > max)
-                max = pixelData[i];
-        }
-        return { min, max };
-    }
-    static getLUTwithMinMax(min, max) {
-        const windowWidth = max - min;
-        const windowCenter = min + windowWidth / 2;
-        return { windowWidth, windowCenter };
-    }
-}
-export default Utilities;

package/Value.d.ts

@@ -1,12 +0,0 @@
-declare class Value {
-    static byVr(dataView: DataView, offset: number, len: number, vr: string, littleEndian: boolean): string | number | DataView | (string | number)[] | undefined;
-    static CS(dataView: DataView, offset: number, len: number): string | string[];
-    static IS(dataView: DataView, offset: number, len: number): string | number;
-    static DA(dataView: DataView, offset: number, len: number): string;
-    static DS(dataView: DataView, offset: number, len: number): string | number | (string | number)[];
-    static TM(dataView: DataView, offset: number, len: number): string;
-    static US(dataView: DataView, offset: number, len: number, littleEndian?: boolean): number | undefined;
-    static OW(dataView: DataView, offset: number, len: number): DataView;
-    static getString(bytes: Uint8Array | Int8Array | ArrayBuffer): string;
-}
-export default Value;

package/Value.js

@@ -1,103 +0,0 @@
-class Value {
-    static byVr(dataView, offset, len, vr, littleEndian) {
-        switch (vr) {
-            case "CS":
-                return Value.CS(dataView, offset, len);
-            case "US":
-                return Value.US(dataView, offset, len, littleEndian);
-            case "IS":
-                return Value.IS(dataView, offset, len);
-            case "DS":
-                return Value.DS(dataView, offset, len);
-            case "DA":
-                return Value.DA(dataView, offset, len);
-            case "TM":
-                return Value.TM(dataView, offset, len);
-            case "OW":
-            case "OB":
-            case "OD":
-            case "OF":
-                return Value.OW(dataView, offset, len);
-            case "UI":
-            case "SH":
-            case "LO":
-            default:
-                return Value.getString(new Uint8Array(dataView.buffer, offset, len));
-        }
-    }
-    static CS(dataView, offset, len) {
-        let value = Value.getString(new Uint8Array(dataView.buffer, offset, len));
-        const values = value.split("\\");
-        if (values.length === 0) {
-            return value;
-        }
-        else if (values.length === 1) {
-            return values[0];
-        }
-        else {
-            return values;
-        }
-    }
-    static IS(dataView, offset, len) {
-        const value = Value.getString(new Uint8Array(dataView.buffer, offset, len));
-        if (/^[0-9]+$/.exec(value)) {
-            return parseInt(value);
-        }
-        return value;
-    }
-    static DA(dataView, offset, len) {
-        const value = Value.getString(new Uint8Array(dataView.buffer, offset, len));
-        if (/^[0-9]{8}$/.exec(value)) {
-            return `${value.slice(0, 4)}-${value.slice(4, 6)}-${value.slice(6, 8)}`;
-        }
-        return value;
-    }
-    static DS(dataView, offset, len) {
-        let value = Value.getString(new Uint8Array(dataView.buffer, offset, len));
-        const values = value.split("\\").map(v => {
-            if (/^[0-9\-\+]+$/.exec(v)) {
-                return parseInt(v);
-            }
-            else if (/^[0-9\-\+]+\.[0-9]+$/.exec(v)) {
-                return parseFloat(v);
-            }
-            return v;
-        });
-        if (values.length === 0) {
-            return value;
-        }
-        else if (values.length === 1) {
-            return values[0];
-        }
-        else {
-            return values;
-        }
-    }
-    static TM(dataView, offset, len) {
-        let value = Value.getString(new Uint8Array(dataView.buffer, offset, len)).trim().split('.')[0];
-        if (![2, 4, 6].includes(value.length)) {
-            return value;
-        }
-        if (value.length === 4) {
-            value += "00";
-        }
-        else if (value.length === 2) {
-            value += "0000";
-        }
-        return `${value.slice(0, 2)}:${value.slice(2, 4)}:${value.slice(4, 6)}`;
-    }
-    static US(dataView, offset, len, littleEndian = true) {
-        if (len === 2) {
-            return dataView.getUint16(offset, littleEndian);
-        }
-    }
-    static OW(dataView, offset, len) {
-        const buffer = dataView.buffer.slice(offset, len);
-        return new DataView(buffer);
-    }
-    static getString(bytes) {
-        const decoder = new TextDecoder();
-        return decoder.decode(bytes).trim();
-    }
-}
-export default Value;

package/decoder/JPEG2000.d.ts

@@ -1,5 +0,0 @@
-import { PixelDataDecodeOptions } from "../types";
-declare class JPEG2000 {
-    static decode(options: PixelDataDecodeOptions): Uint8Array;
-}
-export default JPEG2000;

package/decoder/JPEG2000.js

@@ -1,10 +0,0 @@
-class JPEG2000 {
-    static decode(options) {
-        console.log("ddss");
-        // let arrayBuffer = options.pixelData.buffer;
-        // let offset = options.pixelData.byteOffset;
-        // const length = options.pixelData.byteLength;
-        return new Uint8Array(options.pixelData.buffer);
-    }
-}
-export default JPEG2000;

package/decoder/Uncompressed.d.ts

@@ -1,6 +0,0 @@
-import { PixelArray, PixelDataDecodeOptions } from "../types";
-declare class UncompressDecoderr {
-    static decode(options: PixelDataDecodeOptions): PixelArray;
-    private static _endianFixer;
-}
-export default UncompressDecoderr;

package/decoder/Uncompressed.js

@@ -1,57 +0,0 @@
-class UncompressDecoderr {
-    static decode(options) {
-        let arrayBuffer = options.pixelData.buffer;
-        let offset = options.pixelData.byteOffset;
-        const length = options.pixelData.byteLength;
-        switch (options.bitsAllocated) {
-            case 8:
-                return UncompressDecoderr._endianFixer(new Uint8Array(arrayBuffer, offset, length), !options.littleEndian);
-            case 16:
-                if (options.pixelRepresentation === 0) {
-                    return UncompressDecoderr._endianFixer(new Uint16Array(arrayBuffer, offset, length / 2), !options.littleEndian);
-                }
-                else {
-                    return UncompressDecoderr._endianFixer(new Int16Array(arrayBuffer, offset, length / 2), !options.littleEndian);
-                }
-            case 32:
-                return UncompressDecoderr._endianFixer(new Float32Array(arrayBuffer, offset, length / 4), !options.littleEndian);
-            default:
-                return new Uint8Array(arrayBuffer);
-        }
-    }
-    static _endianFixer(data, bigEndian = false) {
-        if (!bigEndian) {
-            return data;
-        }
-        if (data instanceof Uint16Array) {
-            const _data = new Uint16Array(data.length);
-            for (let i = 0; i < _data.length; i++) {
-                _data[i] = ((data[i] & 0xFF) << 8) | ((data[i] >> 8) & 0xF);
-            }
-            return _data;
-        }
-        else if (data instanceof Int16Array) {
-            const _data = new Int16Array(data.length);
-            for (let i = 0; i < _data.length; i++) {
-                _data[i] = ((data[i] & 0xFF) << 8) | ((data[i] >> 8) & 0xF);
-            }
-            return _data;
-        }
-        else if (data instanceof Uint32Array) {
-            const _data = new Uint32Array(data.length);
-            for (let i = 0; i < _data.length; i++) {
-                _data[i] = ((data[i] & 0xFF) << 24) | ((data[i] & 0xFF00) << 8) | ((data[i] >> 8) & 0xFF00) | ((data[i] >> 24) & 0xFF);
-            }
-            return _data;
-        }
-        else if (data instanceof Float32Array) {
-            const _data = new Float32Array(data.length);
-            for (let i = 0; i < _data.length; i++) {
-                _data[i] = ((data[i] & 0xFF) << 24) | ((data[i] & 0xFF00) << 8) | ((data[i] >> 8) & 0xFF00) | ((data[i] >> 24) & 0xFF);
-            }
-            return _data;
-        }
-        return data;
-    }
-}
-export default UncompressDecoderr;

package/decoder/decodes/jpx.d.ts

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

package/decoder/decodes/jpx.js

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