@abasb75/dicom-parser 0.0.0-test

package/Dataset.d.ts

@@ -0,0 +1,11 @@
+import { Tags } from "./types";
+declare class Dataset {
+    tags: Tags;
+    arrayBuffer: ArrayBuffer;
+    transferSyntaxUID: string;
+    constructor(tags: Tags, arrayBuffer: ArrayBuffer);
+    getValue(element: number | string, elementId?: number | string, vr?: string): "" | undefined;
+    private _getValue;
+    private _reformatToString;
+}
+export default Dataset;

package/Dataset.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Tag_1 = require("./Tag");
+const Value_1 = require("./Value");
+class Dataset {
+    constructor(tags, arrayBuffer) {
+        Object.defineProperty(this, "tags", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "arrayBuffer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "transferSyntaxUID", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "1.2.840.10008.1.2"
+        });
+        this.tags = tags;
+        this.arrayBuffer = arrayBuffer;
+    }
+    getValue(element, elementId, vr) {
+        var _a;
+        if (!element && !elementId) {
+            return "";
+        }
+        let _group, _element = "";
+        if (typeof element === 'string' && element.length >= 8) {
+            const el = element.replace(/^0[xX]/, '');
+            if (el.length !== 8) {
+                return "";
+            }
+            _group = el.slice(0, 3);
+            _element = el.slice(4, 7);
+        }
+        else if (typeof element === 'number' && element > 0xffff) {
+            const el = Tag_1.default.intTo4digitString(element);
+            _group = el.slice(0, 3);
+            _element = el.slice(4, 7);
+        }
+        else {
+            _group = this._reformatToString(element);
+            _element = this._reformatToString(elementId);
+            if (!_group || _element)
+                return "";
+        }
+        const key = `0x${_group}${_element}`;
+        if (!this.tags[key]) {
+            return "";
+        }
+        const _vr = vr || ((_a = this.tags[key]) === null || _a === void 0 ? void 0 : _a.vr) || Tag_1.default.getTagVRFromDictionary(_group, _element) || "AA";
+        return this._getValue(this.tags[key], _vr);
+    }
+    _getValue(tag, vr = "AA") {
+        const offset = tag.offset;
+        if (!offset)
+            return "";
+        const len = tag.valueLength;
+        const value = this.arrayBuffer.slice(offset, len);
+        const formedValue = Value_1.default.byVr(value, vr);
+        tag.value = formedValue;
+    }
+    _reformatToString(input) {
+        if (!input)
+            return "";
+        if (typeof input === "string") {
+            return input.replace(/^0[xX]/, '');
+        }
+        return Tag_1.default.intTo4digitString(input);
+    }
+}
+exports.default = Dataset;

package/Loader.d.ts

@@ -0,0 +1,8 @@
+declare class Loader {
+    private dicomSrc;
+    private xhr;
+    constructor(dicomSrc?: string);
+    load(dicomSrc?: string | File): Promise<ArrayBuffer | undefined>;
+    cancel(): void;
+}
+export default Loader;

package/Loader.js

@@ -0,0 +1,65 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+class Loader {
+    constructor(dicomSrc) {
+        Object.defineProperty(this, "dicomSrc", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "xhr", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.dicomSrc = dicomSrc;
+        this.xhr = new XMLHttpRequest();
+    }
+    load(dicomSrc) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (typeof dicomSrc === "string") {
+                const dicom = dicomSrc || this.dicomSrc;
+                if (!dicom)
+                    return;
+                return new Promise((resolve, reject) => {
+                    this.xhr.onload = () => {
+                        resolve(this.xhr.response);
+                    };
+                    this.xhr.onerror = () => {
+                        reject(this.xhr);
+                    };
+                    this.xhr.responseType = 'arraybuffer';
+                    this.xhr.open('GET', dicom, true);
+                    this.xhr.send();
+                });
+            }
+            else if (dicomSrc instanceof File) {
+                return new Promise((resolve, reject) => {
+                    dicomSrc.arrayBuffer().then((arrayBuffer) => {
+                        resolve(arrayBuffer);
+                    }).catch(reason => reject(reason));
+                });
+            }
+            return new Promise((resolve, reject) => {
+                if (false)
+                    resolve(new ArrayBuffer(1));
+                reject("dicom source is not valid");
+            });
+        });
+    }
+    cancel() {
+        this.xhr.abort();
+    }
+}
+exports.default = Loader;

package/Parser.d.ts

@@ -0,0 +1,29 @@
+import Dataset from "./Dataset";
+declare class Parser {
+    private arrayBuffer;
+    private offset;
+    private dataView;
+    private tags;
+    private dataSet;
+    private EXEPTED;
+    private VRS;
+    private IMPLICT_TRANSFER_SYNTAXES;
+    private BIG_ENDIAN_TRANSFER_SYNTAXES;
+    private DEFLATED_TRANSFER_SYNTAXES;
+    private littleEndian;
+    private implicit;
+    private transferSyntaxUID;
+    private inflated;
+    constructor(arrayBuffer: ArrayBuffer);
+    parse(): Dataset;
+    getDataset(): Dataset | undefined;
+    getNextTag(): void;
+    getValue(len: number): ArrayBuffer;
+    getNextGroupAndElement(): {
+        group: number;
+        element: number;
+    };
+    getNextVR(groupInt: number, elementInt: number): string;
+    concatArrayBuffers: (buffer1: ArrayBuffer, buffer2: ArrayBuffer) => ArrayBufferLike;
+}
+export default Parser;

package/Parser.js

@@ -0,0 +1,225 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Dataset_1 = require("./Dataset");
+const Tag_1 = require("./Tag");
+const Value_1 = require("./Value");
+const pako_1 = require("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"]
+        });
+        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_1.default.getString(new Uint8Array(arrayBuffer, 128, 4));
+        if (prefix !== 'DICM') {
+            console.error("is not valid dicom file");
+            return;
+        }
+        this.offset = 132;
+        this.parse();
+    }
+    parse() {
+        this.getNextTag();
+        this.dataSet = new Dataset_1.default(this.tags, this.arrayBuffer);
+        console.log(this.dataSet);
+        this.dataSet.transferSyntaxUID = this.transferSyntaxUID;
+        return this.dataSet;
+    }
+    getDataset() {
+        return this.dataSet;
+    }
+    getNextTag() {
+        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.getNextTag();
+        }
+        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_1.default.inflateRaw(body);
+            this.arrayBuffer = this.concatArrayBuffers(meta, infaltedBody);
+            this.dataView = new DataView(this.arrayBuffer);
+            this.inflated = true;
+            return this.getNextTag();
+        }
+        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.getNextTag();
+        }
+        else {
+            console.log("ended", vr);
+            return;
+        }
+        if (group === 0x0002 && element === 0x0010) {
+            console.log("transfer syntax uid", this.transferSyntaxUID);
+            this.transferSyntaxUID = (Value_1.default.getString(new Uint8Array(this.arrayBuffer, this.offset, len))).replace('\0', '');
+        }
+        const tag = new Tag_1.default(group, element, vr, len, this.offset);
+        const key = tag.generateKey();
+        this.tags[key] = tag;
+        if (vr === "SQ") {
+            this.getNextTag();
+        }
+        else {
+            this.offset += len;
+            this.getNextTag();
+        }
+    }
+    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.implicit) {
+            return Tag_1.default.getTagVRFromDictionary(groupInt, elementInt) || "AA";
+        }
+        const vr = Value_1.default.getString(new Uint8Array(this.arrayBuffer, this.offset, 2));
+        this.offset += 2;
+        return vr;
+    }
+}
+exports.default = Parser;

package/README.md

@@ -0,0 +1,68 @@
+# @abasb75/dicom-parser
+
+```sh
+npm i @abasb75/dicom-parser --save
+```
+
+
+#Usage
+
+1. For Download dicom and parse from url:
+
+```javascript
+import { loadAndParseFromUrl } from "@abasb75/dicom-parser";
+
+...
+const url = "....dcm";
+loadAndParseFromUrl(url)
+.then(dataset=>{
+  console.log(dataset);
+})
+.catch(err=>{
+  console.log(error);
+})
+
+```
+
+
+2. For parse dataset from local files:
+
+```javascript
+import { loadAndParseFromFiles } from "@abasb75/dicom-parser";
+
+...
+
+loadAndParseFromFiles(file)
+.then(dataset=>{
+  console.log(dataset);
+})
+.catch(err=>{
+  console.log(error);
+});
+
+```
+
+3. For parsing arrayBuffer:
+
+```javascript
+import { parse } from "@abasb75/dicom-parser";
+
+...
+
+const dataset = parse(arrayBuffer);
+
+```
+
+
+4. Getting value for dicom tag
+
+```javascript
+
+...
+
+const transferSyntaxUID = dataset.get(0x0002,0x0010);
+const transferSyntaxUID = dataset.string(0x0002,0x0010);
+
+...
+
+```

package/Tag.d.ts

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const TagsDictionary_1 = require("./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 = TagsDictionary_1.default[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 = TagsDictionary_1.default[_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() {
+    }
+}
+exports.default = Tag;

package/Value.d.ts

@@ -0,0 +1,5 @@
+declare class Value {
+    static byVr(arrayBuffer: ArrayBuffer, vr: string): string;
+    static getString(bytes: Uint8Array | Int8Array | ArrayBuffer): string;
+}
+export default Value;

package/Value.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Value {
+    static byVr(arrayBuffer, vr) {
+        switch (vr) {
+            case "UL":
+            default:
+                return Value.getString(arrayBuffer);
+        }
+    }
+    static getString(bytes) {
+        const decoder = new TextDecoder();
+        return decoder.decode(bytes);
+    }
+}
+exports.default = Value;

package/dic.d.ts

@@ -0,0 +1,8 @@
+export declare const dict: {
+    "6": string;
+    Tag: string;
+    Name: string;
+    Keyword: string;
+    VR: string;
+    VM: string;
+}[];