@l1yp/file-viewer 0.1.0

package/dist/lib/dicom.js

@@ -0,0 +1,442 @@
+import e from "dicom-parser";
+//#region src/lib/dicom.ts
+var t = {
+	transferSyntax: "x00020010",
+	samplesPerPixel: "x00280002",
+	photometric: "x00280004",
+	planarConfiguration: "x00280006",
+	numberOfFrames: "x00280008",
+	rows: "x00280010",
+	columns: "x00280011",
+	bitsAllocated: "x00280100",
+	bitsStored: "x00280101",
+	highBit: "x00280102",
+	pixelRepresentation: "x00280103",
+	windowCenter: "x00281050",
+	windowWidth: "x00281051",
+	rescaleIntercept: "x00281052",
+	rescaleSlope: "x00281053",
+	redDescriptor: "x00281101",
+	greenDescriptor: "x00281102",
+	blueDescriptor: "x00281103",
+	redData: "x00281201",
+	greenData: "x00281202",
+	blueData: "x00281203",
+	modality: "x00080060",
+	studyDescription: "x00081030",
+	seriesDescription: "x0008103e",
+	bodyPart: "x00180015",
+	pixelData: "x7fe00010"
+}, n = class extends Error {
+	constructor(e) {
+		super(e), this.name = "DicomError";
+	}
+};
+function r(e, t, n) {
+	let r = e.uint16(t);
+	return typeof r == "number" && Number.isFinite(r) ? r : n;
+}
+function i(e, t, n) {
+	let r = e.floatString(t, 0);
+	return typeof r == "number" && Number.isFinite(r) ? r : n;
+}
+function a(e, t) {
+	let n = e.floatString(t, 0);
+	return typeof n == "number" && Number.isFinite(n) ? n : null;
+}
+function o(e, t) {
+	return (e.string(t) ?? "").trim();
+}
+function s(e) {
+	let n = e.elements[t.redData], r = e.elements[t.greenData], i = e.elements[t.blueData], a = e.elements[t.redDescriptor];
+	if (!n || !r || !i || !a) return null;
+	let o = e.uint16(t.redDescriptor, 0) ?? 0;
+	o === 0 && (o = 65536);
+	let s = e.uint16(t.redDescriptor, 2) ?? 8, c = (t) => {
+		let n = new Uint8ClampedArray(o), r = e.byteArray;
+		if (s === 16) for (let e = 0; e < o; e++) {
+			let i = t.dataOffset + e * 2;
+			n[e] = i + 1 < r.length ? r[i + 1] : 0;
+		}
+		else for (let e = 0; e < o; e++) {
+			let i = t.dataOffset + e;
+			n[e] = i < r.length ? r[i] : 0;
+		}
+		return n;
+	};
+	return {
+		r: c(n),
+		g: c(r),
+		b: c(i)
+	};
+}
+var c = new Set([
+	"1.2.840.10008.1.2",
+	"1.2.840.10008.1.2.1",
+	"1.2.840.10008.1.2.2"
+]), l = [
+	{
+		title: "患者",
+		specs: [
+			{
+				tag: "x00100010",
+				label: "姓名",
+				kind: "name"
+			},
+			{
+				tag: "x00100020",
+				label: "ID"
+			},
+			{
+				tag: "x00100030",
+				label: "出生日期",
+				kind: "date"
+			},
+			{
+				tag: "x00100040",
+				label: "性别"
+			},
+			{
+				tag: "x00101010",
+				label: "年龄"
+			},
+			{
+				tag: "x00101030",
+				label: "体重 (kg)"
+			},
+			{
+				tag: "x00101020",
+				label: "身高 (m)"
+			}
+		]
+	},
+	{
+		title: "检查 (Study)",
+		specs: [
+			{
+				tag: "x00080020",
+				label: "检查日期",
+				kind: "date"
+			},
+			{
+				tag: "x00080030",
+				label: "检查时间",
+				kind: "time"
+			},
+			{
+				tag: "x00081030",
+				label: "检查描述"
+			},
+			{
+				tag: "x00080050",
+				label: "登记号"
+			},
+			{
+				tag: "x00200010",
+				label: "Study ID"
+			},
+			{
+				tag: "x00080090",
+				label: "申请医师",
+				kind: "name"
+			},
+			{
+				tag: "x0020000d",
+				label: "Study UID"
+			}
+		]
+	},
+	{
+		title: "序列 (Series)",
+		specs: [
+			{
+				tag: "x00080060",
+				label: "设备类型"
+			},
+			{
+				tag: "x0008103e",
+				label: "序列描述"
+			},
+			{
+				tag: "x00200011",
+				label: "序列号"
+			},
+			{
+				tag: "x00180015",
+				label: "检查部位"
+			},
+			{
+				tag: "x00185100",
+				label: "患者体位"
+			},
+			{
+				tag: "x00080021",
+				label: "序列日期",
+				kind: "date"
+			},
+			{
+				tag: "x00080031",
+				label: "序列时间",
+				kind: "time"
+			},
+			{
+				tag: "x0020000e",
+				label: "Series UID"
+			}
+		]
+	},
+	{
+		title: "设备",
+		specs: [
+			{
+				tag: "x00080070",
+				label: "厂商"
+			},
+			{
+				tag: "x00081090",
+				label: "型号"
+			},
+			{
+				tag: "x00080080",
+				label: "机构"
+			},
+			{
+				tag: "x00081010",
+				label: "工作站"
+			},
+			{
+				tag: "x00181020",
+				label: "软件版本"
+			},
+			{
+				tag: "x00080008",
+				label: "图像类型"
+			}
+		]
+	},
+	{
+		title: "采集参数",
+		specs: [
+			{
+				tag: "x00181030",
+				label: "协议名"
+			},
+			{
+				tag: "x00180050",
+				label: "层厚 (mm)"
+			},
+			{
+				tag: "x00180088",
+				label: "层间距 (mm)"
+			},
+			{
+				tag: "x00201041",
+				label: "层位置"
+			},
+			{
+				tag: "x00180060",
+				label: "KVP"
+			},
+			{
+				tag: "x00181151",
+				label: "管电流 (mA)"
+			},
+			{
+				tag: "x00181150",
+				label: "曝光时间 (ms)"
+			},
+			{
+				tag: "x00181152",
+				label: "曝光量 (mAs)"
+			},
+			{
+				tag: "x00181210",
+				label: "卷积核"
+			},
+			{
+				tag: "x00180080",
+				label: "重复时间 TR (ms)"
+			},
+			{
+				tag: "x00180081",
+				label: "回波时间 TE (ms)"
+			},
+			{
+				tag: "x00180087",
+				label: "磁场强度 (T)"
+			},
+			{
+				tag: "x00181314",
+				label: "翻转角 (°)"
+			}
+		]
+	},
+	{
+		title: "图像",
+		specs: [
+			{
+				tag: "x00200013",
+				label: "实例号"
+			},
+			{
+				tag: "x00280008",
+				label: "帧数"
+			},
+			{
+				tag: "x00280010",
+				label: "行 (Rows)",
+				kind: "us"
+			},
+			{
+				tag: "x00280011",
+				label: "列 (Columns)",
+				kind: "us"
+			},
+			{
+				tag: "x00280100",
+				label: "Bits Allocated",
+				kind: "us"
+			},
+			{
+				tag: "x00280101",
+				label: "Bits Stored",
+				kind: "us"
+			},
+			{
+				tag: "x00280002",
+				label: "Samples/Pixel",
+				kind: "us"
+			},
+			{
+				tag: "x00280004",
+				label: "光度"
+			},
+			{
+				tag: "x00280030",
+				label: "像素间距"
+			},
+			{
+				tag: "x00281050",
+				label: "窗位"
+			},
+			{
+				tag: "x00281051",
+				label: "窗宽"
+			},
+			{
+				tag: "x00281052",
+				label: "截距"
+			},
+			{
+				tag: "x00281053",
+				label: "斜率"
+			}
+		]
+	}
+];
+function u(e) {
+	let t = /^(\d{4})(\d{2})(\d{2})/.exec(e);
+	return t ? `${t[1]}-${t[2]}-${t[3]}` : e;
+}
+function d(e) {
+	let t = /^(\d{2})(\d{2})(\d{2})/.exec(e);
+	return t ? `${t[1]}:${t[2]}:${t[3]}` : e;
+}
+function f(e) {
+	return e.replace(/\^+/g, " ").replace(/\s+/g, " ").trim();
+}
+function p(e, t) {
+	if (t.kind === "us") {
+		let n = e.uint16(t.tag);
+		return typeof n == "number" && Number.isFinite(n) ? String(n) : "";
+	}
+	let n = (e.string(t.tag) ?? "").trim();
+	return n ? t.kind === "date" ? u(n) : t.kind === "time" ? d(n) : t.kind === "name" ? f(n) : n.replace(/\\/g, " / ") : "";
+}
+function m(e) {
+	let t = [];
+	for (let n of l) {
+		let r = [];
+		for (let t of n.specs) {
+			let n = p(e, t);
+			n && r.push({
+				label: t.label,
+				value: n
+			});
+		}
+		r.length > 0 && t.push({
+			title: n.title,
+			rows: r
+		});
+	}
+	return t;
+}
+function h(l) {
+	let u = new Uint8Array(l);
+	if (u.length < 132 || u[128] !== 68 || u[129] !== 73 || u[130] !== 67 || u[131] !== 77) throw new n("不是有效的 DICOM 文件（缺少 DICM 标识）");
+	let d;
+	try {
+		d = e.parseDicom(u);
+	} catch (e) {
+		throw new n(`DICOM 解析失败：${e instanceof Error ? e.message : String(e)}`);
+	}
+	let f = d.elements[t.pixelData];
+	if (!f) throw new n("该 DICOM 不含像素数据（可能仅为结构化报告/元数据）");
+	let p = r(d, t.rows, 0), h = r(d, t.columns, 0);
+	if (p < 1 || h < 1) throw new n("像素尺寸无效");
+	let g = r(d, t.bitsAllocated, 8);
+	if (g !== 8 && g !== 16) throw new n(`暂不支持 ${g}-bit 像素（仅支持 8/16-bit）`);
+	let _ = {
+		transferSyntaxUid: o(d, t.transferSyntax) || "1.2.840.10008.1.2",
+		rows: p,
+		columns: h,
+		samplesPerPixel: r(d, t.samplesPerPixel, 1),
+		photometric: o(d, t.photometric) || "MONOCHROME2",
+		bitsAllocated: g,
+		bitsStored: r(d, t.bitsStored, g),
+		highBit: r(d, t.highBit, g - 1),
+		pixelRepresentation: r(d, t.pixelRepresentation, 0),
+		planarConfiguration: r(d, t.planarConfiguration, 0),
+		numberOfFrames: Math.max(1, d.intString(t.numberOfFrames) ?? 1),
+		windowCenter: a(d, t.windowCenter),
+		windowWidth: a(d, t.windowWidth),
+		rescaleSlope: i(d, t.rescaleSlope, 1),
+		rescaleIntercept: i(d, t.rescaleIntercept, 0),
+		palette: null,
+		modality: o(d, t.modality),
+		studyDescription: o(d, t.studyDescription),
+		seriesDescription: o(d, t.seriesDescription),
+		bodyPart: o(d, t.bodyPart)
+	};
+	_.photometric === "PALETTE COLOR" && (_.palette = s(d));
+	let v = m(d), y = !c.has(_.transferSyntaxUid), b = _.transferSyntaxUid === "1.2.840.10008.1.2.5", x = p * h * _.samplesPerPixel * (g / 8), S = _.numberOfFrames;
+	function C(t) {
+		let r = Math.min(Math.max(t, 0), S - 1);
+		if (!y) {
+			let e = f.dataOffset + r * x;
+			return u.subarray(e, e + x);
+		}
+		try {
+			if (b) return e.readEncapsulatedPixelDataFromFragments(d, f, r);
+			let t = f.basicOffsetTable;
+			if (!t || t.length === 0) try {
+				t = e.createJPEGBasicOffsetTable(d, f);
+			} catch {
+				t = [];
+			}
+			if (t && t.length > 0) return e.readEncapsulatedImageFrame(d, f, r, t);
+			let n = f.fragments?.length ?? 1;
+			return S <= 1 ? e.readEncapsulatedPixelDataFromFragments(d, f, 0, n) : e.readEncapsulatedPixelDataFromFragments(d, f, r);
+		} catch (e) {
+			throw new n(`读取第 ${r + 1} 帧像素失败：${e instanceof Error ? e.message : String(e)}`);
+		}
+	}
+	return {
+		meta: _,
+		encapsulated: y,
+		tags: v,
+		frameBytes: C
+	};
+}
+//#endregion
+export { n as DicomError, h as readDicom };

package/dist/lib/dicomCodecs.d.ts

@@ -0,0 +1,28 @@
+/**
+ * DICOM pixel-data decoding: turn one frame's transfer-syntax-encoded bytes into raw pixel samples.
+ *
+ * Browsers have no native DICOM/JPEG2000/JPEG-LS decoder, so compressed transfer syntaxes are decoded by the
+ * cornerstone WASM codecs (openjpeg / charls / libjpeg-turbo), lazily `import()`-ed only when a compressed
+ * frame is actually opened — so the main bundle and non-DICOM users pay nothing. Uncompressed and RLE are
+ * handled here directly (RLE is a hand-rolled PackBits unpack — no dependency needed). The *predictive
+ * lossless* JPEGs (Process 14 / SV1) are a different beast — libjpeg-turbo is DCT-only and cannot decode
+ * them — so they go through `jpeg-lossless-decoder-js` (pure JS), also lazily imported.
+ *
+ * Output contract: {@link decodeDicomFrame} returns interleaved pixel-sample BYTES laid out exactly like an
+ * uncompressed frame would be (little-endian for 16-bit), so the render layer (lib/dicomRender.ts) has a
+ * single code path regardless of how the pixels were stored.
+ */
+import type { DicomMeta } from './dicom';
+export declare function transferSyntaxName(uid: string): string;
+export declare class UnsupportedTransferSyntaxError extends Error {
+    constructor(uid: string);
+}
+export interface DecodedFrame {
+    /** Interleaved pixel-sample bytes (little-endian for 16-bit), laid out like an uncompressed frame. */
+    bytes: Uint8Array;
+    littleEndian: boolean;
+    bitsPerSample: number;
+    componentCount: number;
+}
+/** Decode one frame. Async because compressed transfer syntaxes lazy-load a WASM codec. */
+export declare function decodeDicomFrame(meta: DicomMeta, encoded: Uint8Array): Promise<DecodedFrame>;

package/dist/lib/dicomCodecs.js

@@ -0,0 +1,156 @@
+//#region src/lib/dicomCodecs.ts
+var e = {
+	IMPLICIT_LE: "1.2.840.10008.1.2",
+	EXPLICIT_LE: "1.2.840.10008.1.2.1",
+	EXPLICIT_BE: "1.2.840.10008.1.2.2",
+	DEFLATED: "1.2.840.10008.1.2.1.99",
+	RLE: "1.2.840.10008.1.2.5",
+	JPEG_BASELINE: "1.2.840.10008.1.2.4.50",
+	JPEG_EXTENDED: "1.2.840.10008.1.2.4.51",
+	JPEG_LOSSLESS_57: "1.2.840.10008.1.2.4.57",
+	JPEG_LOSSLESS_70: "1.2.840.10008.1.2.4.70",
+	JPEGLS_LOSSLESS: "1.2.840.10008.1.2.4.80",
+	JPEGLS_NEAR: "1.2.840.10008.1.2.4.81",
+	J2K_LOSSLESS: "1.2.840.10008.1.2.4.90",
+	J2K: "1.2.840.10008.1.2.4.91"
+}, t = new Set([
+	e.IMPLICIT_LE,
+	e.EXPLICIT_LE,
+	e.EXPLICIT_BE
+]), n = {
+	[e.IMPLICIT_LE]: "隐式 VR 小端（未压缩）",
+	[e.EXPLICIT_LE]: "显式 VR 小端（未压缩）",
+	[e.EXPLICIT_BE]: "显式 VR 大端（未压缩）",
+	[e.DEFLATED]: "Deflated 显式 VR",
+	[e.RLE]: "RLE 无损",
+	[e.JPEG_BASELINE]: "JPEG Baseline",
+	[e.JPEG_EXTENDED]: "JPEG Extended (12-bit)",
+	[e.JPEG_LOSSLESS_57]: "JPEG Lossless (P14)",
+	[e.JPEG_LOSSLESS_70]: "JPEG Lossless (P14 SV1)",
+	[e.JPEGLS_LOSSLESS]: "JPEG-LS 无损",
+	[e.JPEGLS_NEAR]: "JPEG-LS 近无损",
+	[e.J2K_LOSSLESS]: "JPEG 2000 无损",
+	[e.J2K]: "JPEG 2000"
+};
+function r(e) {
+	return n[e] ?? e;
+}
+var i = class extends Error {
+	constructor(e) {
+		super(`暂不支持的传输语法：${r(e)}（${e}）`), this.name = "UnsupportedTransferSyntaxError";
+	}
+}, a = null, o = null, s = null;
+function c() {
+	return a ??= import("@cornerstonejs/codec-openjpeg/decode").then((e) => e.default()), a;
+}
+function l() {
+	return o ??= import("@cornerstonejs/codec-charls/decode").then((e) => e.default()), o;
+}
+function u() {
+	return s ??= import("@cornerstonejs/codec-libjpeg-turbo-8bit/decode").then((e) => e.default()), s;
+}
+var d = null;
+function f() {
+	return d ??= import("jpeg-lossless-decoder-js"), d;
+}
+function p(e, t, n) {
+	if (!t) throw Error("codec 模块缺少解码器");
+	let r = new t();
+	try {
+		r.getEncodedBuffer(n.length).set(n), r.decode();
+		let e = r.getFrameInfo();
+		return {
+			bytes: r.getDecodedBuffer().slice(),
+			info: e
+		};
+	} finally {
+		r.delete();
+	}
+}
+async function m(n, a) {
+	let o = n.transferSyntaxUid;
+	if (t.has(o)) return {
+		bytes: a,
+		littleEndian: o !== e.EXPLICIT_BE,
+		bitsPerSample: n.bitsAllocated,
+		componentCount: n.samplesPerPixel
+	};
+	if (o === e.RLE) return {
+		bytes: g(a, n),
+		littleEndian: !0,
+		bitsPerSample: n.bitsAllocated,
+		componentCount: n.samplesPerPixel
+	};
+	if (o === e.JPEG_LOSSLESS_57 || o === e.JPEG_LOSSLESS_70) try {
+		let { Decoder: e } = await f(), t = new e(), r = t.decode(a.buffer, a.byteOffset, a.byteLength);
+		return {
+			bytes: new Uint8Array(r.buffer, r.byteOffset, r.byteLength),
+			littleEndian: !0,
+			bitsPerSample: (t.numBytes || n.bitsAllocated / 8) * 8,
+			componentCount: t.numComp || n.samplesPerPixel
+		};
+	} catch (e) {
+		throw Error(`${r(o)} 解码失败：${e instanceof Error ? e.message : String(e)}`);
+	}
+	let s, d;
+	switch (o) {
+		case e.JPEG_BASELINE:
+		case e.JPEG_EXTENDED:
+			s = await u(), d = s.JPEGDecoder;
+			break;
+		case e.JPEGLS_LOSSLESS:
+		case e.JPEGLS_NEAR:
+			s = await l(), d = s.JpegLSDecoder;
+			break;
+		case e.J2K_LOSSLESS:
+		case e.J2K:
+			s = await c(), d = s.J2KDecoder;
+			break;
+		default: throw new i(o);
+	}
+	let m, h;
+	try {
+		({bytes: h, info: m} = p(s, d, a));
+	} catch (e) {
+		throw Error(`${r(o)} 解码失败：${e instanceof Error ? e.message : String(e)}`);
+	}
+	return {
+		bytes: h,
+		littleEndian: !0,
+		bitsPerSample: m.bitsPerSample || n.bitsAllocated,
+		componentCount: m.componentCount || n.samplesPerPixel
+	};
+}
+function h(e, t) {
+	let n = new Uint8Array(t), r = 0, i = 0;
+	for (; i < e.length && r < t;) {
+		let a = e[i++] << 24 >> 24;
+		if (a >= 0) {
+			let o = a + 1;
+			for (let a = 0; a < o && i < e.length && r < t; a++) n[r++] = e[i++];
+		} else if (a !== -128) {
+			let o = 1 - a, s = i < e.length ? e[i++] : 0;
+			for (let e = 0; e < o && r < t; e++) n[r++] = s;
+		}
+	}
+	return n;
+}
+function g(e, t) {
+	let { rows: n, columns: r, samplesPerPixel: i, bitsAllocated: a } = t, o = n * r, s = a / 8, c = new DataView(e.buffer, e.byteOffset, e.byteLength), l = c.getUint32(0, !0), u = [];
+	for (let e = 0; e < l; e++) u.push(c.getUint32(4 + e * 4, !0));
+	let d = [];
+	for (let t = 0; t < l; t++) {
+		let n = u[t], r = t + 1 < l ? u[t + 1] : e.length;
+		d.push(h(e.subarray(n, r), o));
+	}
+	let f = new Uint8Array(o * i * s);
+	for (let e = 0; e < i; e++) for (let t = 0; t < s; t++) {
+		let n = d[e * s + t];
+		if (!n) continue;
+		let r = s - 1 - t;
+		for (let t = 0; t < o; t++) f[(t * i + e) * s + r] = n[t];
+	}
+	return f;
+}
+//#endregion
+export { i as UnsupportedTransferSyntaxError, m as decodeDicomFrame, r as transferSyntaxName };

package/dist/lib/dicomRender.d.ts

@@ -0,0 +1,46 @@
+/**
+ * DICOM pixel → screen rendering: stored samples to displayable RGBA.
+ *
+ * Splits into two steps so the interactive window/level (brightness/contrast) drag stays cheap:
+ *   1. {@link buildFramePixels} — decode the raw bytes into per-pixel values ONCE per frame (apply the
+ *      modality rescale LUT, honour bit depth / signedness / endianness, separate grayscale vs RGB vs
+ *      palette). The expensive parse happens here.
+ *   2. {@link renderToImageData} — apply the VOI window + invert and write RGBA. Cheap enough to re-run on
+ *      every drag frame, since it only maps already-decoded values.
+ *
+ * The VOI window mapping follows the DICOM PS3.3 C.11.2.1.2 LINEAR formula. MONOCHROME1 (0 = white) is
+ * handled by inverting the grayscale ramp.
+ */
+import type { DecodedFrame } from './dicomCodecs';
+import type { DicomMeta, DicomPalette } from './dicom';
+export interface FramePixels {
+    width: number;
+    height: number;
+    mode: 'gray' | 'rgb' | 'palette';
+    /** Grayscale: per-pixel modality value (rescale slope/intercept already applied). */
+    gray?: Float32Array;
+    /** Palette: per-pixel LUT index. */
+    indices?: Int32Array;
+    palette?: DicomPalette;
+    /** RGB: interleaved R,G,B bytes (3 per pixel). */
+    rgb?: Uint8Array;
+    /** Grayscale modality-value range, for auto-windowing. */
+    minValue: number;
+    maxValue: number;
+    /** MONOCHROME1: low values display bright — the grayscale ramp is inverted. */
+    monochrome1: boolean;
+}
+export interface WindowParams {
+    windowCenter: number;
+    windowWidth: number;
+    invert: boolean;
+}
+/** Decode one frame's bytes into per-pixel values (the expensive step; do this once per frame). */
+export declare function buildFramePixels(decoded: DecodedFrame, meta: DicomMeta): FramePixels;
+/** A sensible default window: the file's own VOI when present, else the full modality-value range. */
+export declare function autoWindow(fp: FramePixels): {
+    center: number;
+    width: number;
+};
+/** Apply the VOI window + invert and produce RGBA pixels for the canvas. Cheap — safe to call on each drag. */
+export declare function renderToImageData(fp: FramePixels, params: WindowParams): ImageData;