@jax-data-science/sci-image-visualizer 0.9.0 → 0.11.0

package/esm2022/lib/region-import/label-classes.mjs

@@ -0,0 +1,149 @@
+import { traceContours } from 'napari-js/geometry';
+/** The look the Allen atlas region sets carry (see the brain-atlas example's GeoJSON). */
+export const ATLAS_STYLE = {
+    fillOpacity: 0.6,
+    stroke: '#3c3c3c',
+    strokeWidth: 1,
+    labels: true,
+    highlight: '#a020f0',
+};
+/**
+ * The classes of a label volume from `ontology`, a parsed JSON document:
+ *
+ * - an **Allen structure graph** (`structure_graph_1.json`: `{ msg: [root] }`, or a node or a
+ *   list of nodes with `id`, `acronym`, `name`, `color_hex_triplet`, `graph_order` and
+ *   `children`): label = structure id, class = acronym, its tree the ontology's, drawn as the
+ *   atlas region sets are;
+ * - a **region set description** (a `regionset.json`: `classHierarchy`, optional `style`), whose
+ *   classes name their label as `value` (or `id`), or with a `labels` map of value → class name.
+ *
+ * Without one (or with another document), each label is its own class `label <value>`.
+ */
+export function labelClasses(ontology) {
+    const allen = allenRoots(ontology);
+    if (allen)
+        return allenClasses(allen);
+    if (ontology &&
+        typeof ontology === 'object' &&
+        Array.isArray(ontology.classHierarchy)) {
+        return regionSetClasses(ontology);
+    }
+    return { classOf: unnamed };
+}
+function unnamed(value) {
+    return { name: `label ${value}`, color: paletteColor(value) };
+}
+function allenRoots(doc) {
+    const isNode = (n) => !!n &&
+        typeof n === 'object' &&
+        typeof n.id === 'number' &&
+        typeof n.acronym === 'string';
+    const msg = doc?.msg;
+    const roots = Array.isArray(msg) ? msg : Array.isArray(doc) ? doc : doc ? [doc] : [];
+    return roots.length && roots.every(isNode) ? roots : null;
+}
+function allenClasses(roots) {
+    const byId = new Map();
+    const hierarchy = [];
+    const walk = (n, parent) => {
+        const color = `#${(n.color_hex_triplet || '808080').toUpperCase()}`;
+        byId.set(n.id, { name: n.acronym, color, title: n.name });
+        hierarchy.push({
+            name: n.acronym,
+            ...(n.name ? { title: n.name } : {}),
+            ...(parent ? { parent } : {}),
+            color,
+            ...(n.graph_order != null ? { order: n.graph_order } : {}),
+        });
+        for (const c of n.children ?? [])
+            walk(c, n.acronym);
+    };
+    for (const r of roots)
+        walk(r, null);
+    hierarchy.sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+    return { classOf: (v) => byId.get(v) ?? unnamed(v), hierarchy, style: ATLAS_STYLE };
+}
+function regionSetClasses(doc) {
+    const nodes = new Map(doc.classHierarchy.map((n) => [n.name, n]));
+    const byValue = new Map();
+    for (const n of doc.classHierarchy) {
+        const v = typeof n.value === 'number' ? n.value : typeof n.id === 'number' ? n.id : undefined;
+        if (v != null)
+            byValue.set(v, n.name);
+    }
+    for (const [v, name] of Object.entries(doc.labels ?? {}))
+        byValue.set(Number(v), name);
+    const hierarchy = doc.classHierarchy.map(({ name, title, parent, color, order }) => ({
+        name,
+        ...(title ? { title } : {}),
+        ...(parent ? { parent } : {}),
+        ...(color ? { color } : {}),
+        ...(order != null ? { order } : {}),
+    }));
+    return {
+        classOf: (v) => {
+            const name = byValue.get(v);
+            const node = name ? nodes.get(name) : undefined;
+            return node ? { name: node.name, color: node.color ?? paletteColor(v), title: node.title } : unnamed(v);
+        },
+        hierarchy,
+        ...(doc.style ? { style: doc.style } : {}),
+    };
+}
+/** A colour per label value, spread around the hue circle. */
+function paletteColor(value) {
+    const hue = (value * 137.508) % 360;
+    const [r, g, b] = hsl(hue, 0.65, 0.55);
+    return `#${[r, g, b].map((c) => c.toString(16).padStart(2, '0')).join('')}`.toUpperCase();
+}
+function hsl(h, s, l) {
+    const k = (n) => (n + h / 30) % 12;
+    const a = s * Math.min(l, 1 - l);
+    const f = (n) => l - a * Math.max(-1, Math.min(k(n) - 3, Math.min(9 - k(n), 1)));
+    return [f(0), f(8), f(4)].map((c) => Math.round(c * 255));
+}
+const rgb = (hex) => [1, 3, 5].map((o) => parseInt(hex.slice(o, o + 2), 16));
+/**
+ * Slice `z` of `volume` as a GeoJSON FeatureCollection string: one feature per label on the
+ * slice, its every piece (with holes) traced along pixel edges, in image pixels with y down;
+ * classified by `classes`, which also give the collection its class tree and style.
+ */
+export function labelSliceGeoJson(volume, z, classes) {
+    const labels = volume.sliceLabels(z);
+    const byLabel = new Map();
+    for (const c of traceContours({ data: labels, width: volume.width, height: volume.height })) {
+        const polygons = byLabel.get(c.value) ?? [];
+        polygons.push([ring(c.outer), ...c.holes.map(ring)]);
+        byLabel.set(c.value, polygons);
+    }
+    const features = [...byLabel].map(([value, polygons]) => {
+        const cls = classes.classOf(value);
+        return {
+            type: 'Feature',
+            id: String(value),
+            geometry: { type: 'MultiPolygon', coordinates: polygons },
+            properties: {
+                objectType: 'annotation',
+                name: cls.title ?? cls.name,
+                classification: { name: cls.name, color: rgb(cls.color) },
+                labelValue: value,
+            },
+        };
+    });
+    return JSON.stringify({
+        type: 'FeatureCollection',
+        ...(classes.hierarchy ? { classHierarchy: classes.hierarchy } : {}),
+        ...(classes.style ? { style: classes.style } : {}),
+        features,
+    });
+}
+/** A closed GeoJSON ring from a flat `[x0, y0, …]` one. */
+function ring(flat) {
+    const pts = [];
+    for (let i = 0; i < flat.length; i += 2)
+        pts.push([flat[i], flat[i + 1]]);
+    if (pts.length)
+        pts.push([...pts[0]]);
+    return pts;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"label-classes.js","sourceRoot":"","sources":["../../../../src/lib/region-import/label-classes.ts"],"names":[],"mappings":"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","sourcesContent":["import { traceContours } from 'napari-js/geometry';\n\nimport type { RegionClassNode, RegionSourceStyle } from '../region-source/region-tiles';\nimport type { LabelVolume } from './label-volume';\n\n/**\n * The classes of a label volume's values: their names and colours and, when the volume comes\n * with an ontology, their tree. Pure.\n */\nexport interface LabelClasses {\n  /** The class of label `value` (> 0); one without an ontology entry is `label <value>`. */\n  classOf(value: number): { name: string; color: string; title?: string };\n  /** The class tree, when the ontology has one. */\n  hierarchy?: RegionClassNode[];\n  /** How the set wants to be drawn (an atlas's filled look), when the ontology says. */\n  style?: RegionSourceStyle;\n}\n\n/** The look the Allen atlas region sets carry (see the brain-atlas example's GeoJSON). */\nexport const ATLAS_STYLE: RegionSourceStyle = {\n  fillOpacity: 0.6,\n  stroke: '#3c3c3c',\n  strokeWidth: 1,\n  labels: true,\n  highlight: '#a020f0',\n};\n\ninterface AllenNode {\n  id: number;\n  acronym: string;\n  name?: string;\n  color_hex_triplet?: string;\n  graph_order?: number;\n  children?: AllenNode[];\n}\n\n/**\n * The classes of a label volume from `ontology`, a parsed JSON document:\n *\n * - an **Allen structure graph** (`structure_graph_1.json`: `{ msg: [root] }`, or a node or a\n *   list of nodes with `id`, `acronym`, `name`, `color_hex_triplet`, `graph_order` and\n *   `children`): label = structure id, class = acronym, its tree the ontology's, drawn as the\n *   atlas region sets are;\n * - a **region set description** (a `regionset.json`: `classHierarchy`, optional `style`), whose\n *   classes name their label as `value` (or `id`), or with a `labels` map of value → class name.\n *\n * Without one (or with another document), each label is its own class `label <value>`.\n */\nexport function labelClasses(ontology?: unknown): LabelClasses {\n  const allen = allenRoots(ontology);\n  if (allen) return allenClasses(allen);\n  if (\n    ontology &&\n    typeof ontology === 'object' &&\n    Array.isArray((ontology as { classHierarchy?: unknown }).classHierarchy)\n  ) {\n    return regionSetClasses(ontology as RegionSetDoc);\n  }\n  return { classOf: unnamed };\n}\n\nfunction unnamed(value: number): { name: string; color: string } {\n  return { name: `label ${value}`, color: paletteColor(value) };\n}\n\nfunction allenRoots(doc: unknown): AllenNode[] | null {\n  const isNode = (n: unknown): n is AllenNode =>\n    !!n &&\n    typeof n === 'object' &&\n    typeof (n as AllenNode).id === 'number' &&\n    typeof (n as AllenNode).acronym === 'string';\n  const msg = (doc as { msg?: unknown })?.msg;\n  const roots = Array.isArray(msg) ? msg : Array.isArray(doc) ? doc : doc ? [doc] : [];\n  return roots.length && roots.every(isNode) ? (roots as AllenNode[]) : null;\n}\n\nfunction allenClasses(roots: AllenNode[]): LabelClasses {\n  const byId = new Map<number, { name: string; color: string; title?: string }>();\n  const hierarchy: RegionClassNode[] = [];\n  const walk = (n: AllenNode, parent: string | null) => {\n    const color = `#${(n.color_hex_triplet || '808080').toUpperCase()}`;\n    byId.set(n.id, { name: n.acronym, color, title: n.name });\n    hierarchy.push({\n      name: n.acronym,\n      ...(n.name ? { title: n.name } : {}),\n      ...(parent ? { parent } : {}),\n      color,\n      ...(n.graph_order != null ? { order: n.graph_order } : {}),\n    });\n    for (const c of n.children ?? []) walk(c, n.acronym);\n  };\n  for (const r of roots) walk(r, null);\n  hierarchy.sort((a, b) => (a.order ?? 0) - (b.order ?? 0));\n  return { classOf: (v) => byId.get(v) ?? unnamed(v), hierarchy, style: ATLAS_STYLE };\n}\n\ninterface RegionSetDoc {\n  classHierarchy: Array<RegionClassNode & { value?: number; id?: number }>;\n  style?: RegionSourceStyle;\n  labels?: Record<string, string>;\n}\n\nfunction regionSetClasses(doc: RegionSetDoc): LabelClasses {\n  const nodes = new Map(doc.classHierarchy.map((n) => [n.name, n]));\n  const byValue = new Map<number, string>();\n  for (const n of doc.classHierarchy) {\n    const v = typeof n.value === 'number' ? n.value : typeof n.id === 'number' ? n.id : undefined;\n    if (v != null) byValue.set(v, n.name);\n  }\n  for (const [v, name] of Object.entries(doc.labels ?? {})) byValue.set(Number(v), name);\n  const hierarchy = doc.classHierarchy.map(({ name, title, parent, color, order }) => ({\n    name,\n    ...(title ? { title } : {}),\n    ...(parent ? { parent } : {}),\n    ...(color ? { color } : {}),\n    ...(order != null ? { order } : {}),\n  }));\n  return {\n    classOf: (v) => {\n      const name = byValue.get(v);\n      const node = name ? nodes.get(name) : undefined;\n      return node ? { name: node.name, color: node.color ?? paletteColor(v), title: node.title } : unnamed(v);\n    },\n    hierarchy,\n    ...(doc.style ? { style: doc.style } : {}),\n  };\n}\n\n/** A colour per label value, spread around the hue circle. */\nfunction paletteColor(value: number): string {\n  const hue = (value * 137.508) % 360;\n  const [r, g, b] = hsl(hue, 0.65, 0.55);\n  return `#${[r, g, b].map((c) => c.toString(16).padStart(2, '0')).join('')}`.toUpperCase();\n}\n\nfunction hsl(h: number, s: number, l: number): [number, number, number] {\n  const k = (n: number) => (n + h / 30) % 12;\n  const a = s * Math.min(l, 1 - l);\n  const f = (n: number) => l - a * Math.max(-1, Math.min(k(n) - 3, Math.min(9 - k(n), 1)));\n  return [f(0), f(8), f(4)].map((c) => Math.round(c * 255)) as [number, number, number];\n}\n\nconst rgb = (hex: string): [number, number, number] =>\n  [1, 3, 5].map((o) => parseInt(hex.slice(o, o + 2), 16)) as [number, number, number];\n\n/**\n * Slice `z` of `volume` as a GeoJSON FeatureCollection string: one feature per label on the\n * slice, its every piece (with holes) traced along pixel edges, in image pixels with y down;\n * classified by `classes`, which also give the collection its class tree and style.\n */\nexport function labelSliceGeoJson(volume: LabelVolume, z: number, classes: LabelClasses): string {\n  const labels = volume.sliceLabels(z);\n  const byLabel = new Map<number, number[][][][]>();\n  for (const c of traceContours({ data: labels, width: volume.width, height: volume.height })) {\n    const polygons = byLabel.get(c.value) ?? [];\n    polygons.push([ring(c.outer), ...c.holes.map(ring)]);\n    byLabel.set(c.value, polygons);\n  }\n  const features = [...byLabel].map(([value, polygons]) => {\n    const cls = classes.classOf(value);\n    return {\n      type: 'Feature',\n      id: String(value),\n      geometry: { type: 'MultiPolygon', coordinates: polygons },\n      properties: {\n        objectType: 'annotation',\n        name: cls.title ?? cls.name,\n        classification: { name: cls.name, color: rgb(cls.color) },\n        labelValue: value,\n      },\n    };\n  });\n  return JSON.stringify({\n    type: 'FeatureCollection',\n    ...(classes.hierarchy ? { classHierarchy: classes.hierarchy } : {}),\n    ...(classes.style ? { style: classes.style } : {}),\n    features,\n  });\n}\n\n/** A closed GeoJSON ring from a flat `[x0, y0, …]` one. */\nfunction ring(flat: number[]): number[][] {\n  const pts: number[][] = [];\n  for (let i = 0; i < flat.length; i += 2) pts.push([flat[i], flat[i + 1]]);\n  if (pts.length) pts.push([...pts[0]]);\n  return pts;\n}\n"]}

package/esm2022/lib/region-import/label-volume.mjs

@@ -0,0 +1,194 @@
+/**
+ * A label volume (a NIfTI-1 `.nii` / `.nii.gz` or a NRRD `.nrrd` of integer structure ids, an
+ * atlas annotation say) read in the browser, sliced as the server opens the matching image:
+ *
+ * - **NRRD**: a 3D volume is cut along its FIRST axis, each section its third axis wide and its
+ *   second axis high, as jit-service opens a NRRD volume (`AtlasNrrdReader`: the Allen CCF's 528
+ *   coronal sections of 456 × 320, anterior first). A 2D NRRD is one slice.
+ * - **NIfTI**: along its third axis, each slice its first axis wide and its second axis high, as
+ *   Bio-Formats reads one (no row flip).
+ *
+ * Only what label volumes use: a single file (NRRD with attached data, NIfTI-1 `n+1`), integer
+ * or integer-valued float samples, either byte order, raw or gzip. Anything else throws rather
+ * than be read approximately. Pure: usable from workers.
+ */
+/** Whether a file name is a label volume this reads. */
+export function isLabelVolumeName(name) {
+    return /\.(nrrd|nii|nii\.gz)$/i.test(name);
+}
+/** Read the label volume in `bytes`, named `name` (`.nrrd`, `.nii`, `.nii.gz`). */
+export async function readLabelVolume(name, bytes, gunzip = platformGunzip) {
+    if (/\.nrrd$/i.test(name))
+        return readNrrd(bytes, gunzip);
+    if (/\.nii(\.gz)?$/i.test(name))
+        return readNifti(isGzip(bytes) ? await gunzip(bytes) : bytes);
+    throw new Error(`${name}: not a NIfTI (.nii, .nii.gz) or NRRD (.nrrd) label volume`);
+}
+const SAMPLES = {
+    u8: { bytes: 1, read: (v, at) => v.getUint8(at) },
+    i8: { bytes: 1, read: (v, at) => v.getInt8(at) },
+    u16: { bytes: 2, read: (v, at, le) => v.getUint16(at, le) },
+    i16: { bytes: 2, read: (v, at, le) => v.getInt16(at, le) },
+    u32: { bytes: 4, read: (v, at, le) => v.getUint32(at, le) },
+    i32: { bytes: 4, read: (v, at, le) => v.getInt32(at, le) },
+    f32: { bytes: 4, read: (v, at, le) => Math.round(v.getFloat32(at, le)) },
+    f64: { bytes: 8, read: (v, at, le) => Math.round(v.getFloat64(at, le)) },
+};
+/** NRRD type names (every spelling the format allows) → sample type. */
+const NRRD_TYPES = {
+    'signed char': 'i8',
+    int8: 'i8',
+    int8_t: 'i8',
+    uchar: 'u8',
+    'unsigned char': 'u8',
+    uint8: 'u8',
+    uint8_t: 'u8',
+    short: 'i16',
+    'short int': 'i16',
+    'signed short': 'i16',
+    'signed short int': 'i16',
+    int16: 'i16',
+    int16_t: 'i16',
+    ushort: 'u16',
+    'unsigned short': 'u16',
+    'unsigned short int': 'u16',
+    uint16: 'u16',
+    uint16_t: 'u16',
+    int: 'i32',
+    'signed int': 'i32',
+    int32: 'i32',
+    int32_t: 'i32',
+    uint: 'u32',
+    'unsigned int': 'u32',
+    uint32: 'u32',
+    uint32_t: 'u32',
+    float: 'f32',
+    double: 'f64',
+};
+/** NIfTI datatype codes → sample type. */
+const NIFTI_TYPES = {
+    2: 'u8',
+    4: 'i16',
+    8: 'i32',
+    16: 'f32',
+    64: 'f64',
+    256: 'i8',
+    512: 'u16',
+    768: 'u32',
+};
+async function readNrrd(bytes, gunzip) {
+    const end = headerEnd(bytes);
+    if (end < 0)
+        throw new Error('NRRD: no blank line ends the header');
+    const lines = new TextDecoder('latin1').decode(bytes.subarray(0, end)).split(/\r?\n/);
+    if (!/^NRRD\d{4}/.test(lines[0] ?? ''))
+        throw new Error('NRRD: not a NRRD file');
+    const field = {};
+    for (const line of lines.slice(1)) {
+        if (line.startsWith('#'))
+            continue;
+        const at = line.indexOf(': ');
+        if (at > 0)
+            field[line.slice(0, at).trim().toLowerCase()] = line.slice(at + 2).trim();
+    }
+    if (field['data file'] || field['datafile'])
+        throw new Error('NRRD: detached data (a .nhdr) is not supported');
+    const type = NRRD_TYPES[(field['type'] ?? '').toLowerCase()];
+    if (!type)
+        throw new Error(`NRRD: unsupported type "${field['type']}"`);
+    const sizes = (field['sizes'] ?? '').split(/\s+/).filter(Boolean).map(Number);
+    if (sizes.length !== 2 && sizes.length !== 3)
+        throw new Error(`NRRD: need 2 or 3 dimensions, got ${sizes.length}`);
+    const encoding = (field['encoding'] ?? 'raw').toLowerCase();
+    let data = bytes.subarray(end);
+    if (encoding === 'gzip' || encoding === 'gz')
+        data = await gunzip(data);
+    else if (encoding !== 'raw')
+        throw new Error(`NRRD: unsupported encoding "${encoding}"`);
+    const little = (field['endian'] ?? 'little').toLowerCase() !== 'big';
+    // A 3D volume: sections along axis 0, each axis 2 wide and axis 1 high (jit-service's cut).
+    const [n0, n1, n2] = sizes.length === 3 ? sizes : [sizes[0], sizes[1], 1];
+    const axes = sizes.length === 3 ? { z: 0, x: 2, y: 1 } : { z: 2, x: 0, y: 1 };
+    return volume('nrrd', [n0, n1, n2], axes, data, SAMPLES[type], little);
+}
+function readNifti(bytes) {
+    if (bytes.length < 352)
+        throw new Error('NIfTI: shorter than a header');
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    let little = true;
+    if (view.getInt32(0, true) !== 348) {
+        if (view.getInt32(0, false) !== 348)
+            throw new Error('NIfTI: not a NIfTI-1 file');
+        little = false;
+    }
+    const magic = new TextDecoder('latin1').decode(bytes.subarray(344, 347));
+    if (magic !== 'n+1')
+        throw new Error('NIfTI: a separate .hdr/.img pair is not supported');
+    const ndim = view.getInt16(40, little);
+    const dims = [1, 2, 3, 4].map((i) => view.getInt16(40 + 2 * i, little));
+    if (ndim < 2)
+        throw new Error(`NIfTI: need at least 2 dimensions, got ${ndim}`);
+    if (ndim >= 4 && dims[3] > 1)
+        throw new Error('NIfTI: a 4D file is not a label volume');
+    const type = NIFTI_TYPES[view.getInt16(70, little)];
+    if (!type)
+        throw new Error(`NIfTI: unsupported datatype ${view.getInt16(70, little)}`);
+    const offset = Math.max(352, Math.round(view.getFloat32(108, little)));
+    const [n0, n1, n2] = [dims[0], dims[1], ndim >= 3 ? dims[2] : 1];
+    // Slices along axis 2, each axis 0 wide and axis 1 high (Bio-Formats' planes).
+    return volume('nifti', [n0, n1, n2], { z: 2, x: 0, y: 1 }, bytes.subarray(offset), SAMPLES[type], little);
+}
+function volume(format, n, axes, data, sample, little) {
+    const count = n[0] * n[1] * n[2];
+    if (!(count > 0))
+        throw new Error(`${format}: empty volume`);
+    if (data.length < count * sample.bytes) {
+        throw new Error(`${format}: ${data.length} bytes of data, ${count * sample.bytes} needed`);
+    }
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    const stride = [1, n[0], n[0] * n[1]];
+    const width = n[axes.x];
+    const height = n[axes.y];
+    return {
+        format,
+        width,
+        height,
+        slices: n[axes.z],
+        sliceLabels(z) {
+            const out = new Uint32Array(width * height);
+            const base = z * stride[axes.z];
+            const sx = stride[axes.x];
+            const sy = stride[axes.y];
+            for (let y = 0; y < height; y++) {
+                for (let x = 0; x < width; x++) {
+                    const v = sample.read(view, (base + x * sx + y * sy) * sample.bytes, little);
+                    out[y * width + x] = v > 0 ? v : 0;
+                }
+            }
+            return out;
+        },
+    };
+}
+/** The offset just past the header's blank line (`\n\n` or `\r\n\r\n`); -1 without one. */
+function headerEnd(bytes) {
+    const limit = Math.min(bytes.length - 1, 1 << 20);
+    for (let i = 0; i < limit; i++) {
+        if (bytes[i] !== 10)
+            continue;
+        if (bytes[i + 1] === 10)
+            return i + 2;
+        if (bytes[i + 1] === 13 && bytes[i + 2] === 10)
+            return i + 3;
+    }
+    return -1;
+}
+function isGzip(bytes) {
+    return bytes.length > 2 && bytes[0] === 0x1f && bytes[1] === 0x8b;
+}
+async function platformGunzip(bytes) {
+    if (typeof DecompressionStream === 'undefined')
+        throw new Error('gzip data needs DecompressionStream');
+    const stream = new Blob([bytes]).stream().pipeThrough(new DecompressionStream('gzip'));
+    return new Uint8Array(await new Response(stream).arrayBuffer());
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"label-volume.js","sourceRoot":"","sources":["../../../../src/lib/region-import/label-volume.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * A label volume (a NIfTI-1 `.nii` / `.nii.gz` or a NRRD `.nrrd` of integer structure ids, an\n * atlas annotation say) read in the browser, sliced as the server opens the matching image:\n *\n * - **NRRD**: a 3D volume is cut along its FIRST axis, each section its third axis wide and its\n *   second axis high, as jit-service opens a NRRD volume (`AtlasNrrdReader`: the Allen CCF's 528\n *   coronal sections of 456 × 320, anterior first). A 2D NRRD is one slice.\n * - **NIfTI**: along its third axis, each slice its first axis wide and its second axis high, as\n *   Bio-Formats reads one (no row flip).\n *\n * Only what label volumes use: a single file (NRRD with attached data, NIfTI-1 `n+1`), integer\n * or integer-valued float samples, either byte order, raw or gzip. Anything else throws rather\n * than be read approximately. Pure: usable from workers.\n */\n\n/** A label volume, sliced (see the module comment). Label 0 is background. */\nexport interface LabelVolume {\n  format: 'nrrd' | 'nifti';\n  /** A slice's width and height, in voxels (the image's pixels). */\n  width: number;\n  height: number;\n  /** Number of slices. */\n  slices: number;\n  /** Slice `z`'s labels, row-major (`height` rows of `width`). */\n  sliceLabels(z: number): Uint32Array;\n}\n\n/** Decompress gzip bytes (default: the platform's `DecompressionStream`). */\nexport type Gunzip = (bytes: Uint8Array) => Promise<Uint8Array>;\n\n/** Whether a file name is a label volume this reads. */\nexport function isLabelVolumeName(name: string): boolean {\n  return /\\.(nrrd|nii|nii\\.gz)$/i.test(name);\n}\n\n/** Read the label volume in `bytes`, named `name` (`.nrrd`, `.nii`, `.nii.gz`). */\nexport async function readLabelVolume(\n  name: string,\n  bytes: Uint8Array,\n  gunzip: Gunzip = platformGunzip,\n): Promise<LabelVolume> {\n  if (/\\.nrrd$/i.test(name)) return readNrrd(bytes, gunzip);\n  if (/\\.nii(\\.gz)?$/i.test(name)) return readNifti(isGzip(bytes) ? await gunzip(bytes) : bytes);\n  throw new Error(`${name}: not a NIfTI (.nii, .nii.gz) or NRRD (.nrrd) label volume`);\n}\n\n/** Sample types: their byte size and how one is read. */\ntype Sample = { bytes: number; read: (v: DataView, at: number, little: boolean) => number };\nconst SAMPLES: Record<string, Sample> = {\n  u8: { bytes: 1, read: (v, at) => v.getUint8(at) },\n  i8: { bytes: 1, read: (v, at) => v.getInt8(at) },\n  u16: { bytes: 2, read: (v, at, le) => v.getUint16(at, le) },\n  i16: { bytes: 2, read: (v, at, le) => v.getInt16(at, le) },\n  u32: { bytes: 4, read: (v, at, le) => v.getUint32(at, le) },\n  i32: { bytes: 4, read: (v, at, le) => v.getInt32(at, le) },\n  f32: { bytes: 4, read: (v, at, le) => Math.round(v.getFloat32(at, le)) },\n  f64: { bytes: 8, read: (v, at, le) => Math.round(v.getFloat64(at, le)) },\n};\n\n/** NRRD type names (every spelling the format allows) → sample type. */\nconst NRRD_TYPES: Record<string, string> = {\n  'signed char': 'i8',\n  int8: 'i8',\n  int8_t: 'i8',\n  uchar: 'u8',\n  'unsigned char': 'u8',\n  uint8: 'u8',\n  uint8_t: 'u8',\n  short: 'i16',\n  'short int': 'i16',\n  'signed short': 'i16',\n  'signed short int': 'i16',\n  int16: 'i16',\n  int16_t: 'i16',\n  ushort: 'u16',\n  'unsigned short': 'u16',\n  'unsigned short int': 'u16',\n  uint16: 'u16',\n  uint16_t: 'u16',\n  int: 'i32',\n  'signed int': 'i32',\n  int32: 'i32',\n  int32_t: 'i32',\n  uint: 'u32',\n  'unsigned int': 'u32',\n  uint32: 'u32',\n  uint32_t: 'u32',\n  float: 'f32',\n  double: 'f64',\n};\n\n/** NIfTI datatype codes → sample type. */\nconst NIFTI_TYPES: Record<number, string> = {\n  2: 'u8',\n  4: 'i16',\n  8: 'i32',\n  16: 'f32',\n  64: 'f64',\n  256: 'i8',\n  512: 'u16',\n  768: 'u32',\n};\n\nasync function readNrrd(bytes: Uint8Array, gunzip: Gunzip): Promise<LabelVolume> {\n  const end = headerEnd(bytes);\n  if (end < 0) throw new Error('NRRD: no blank line ends the header');\n  const lines = new TextDecoder('latin1').decode(bytes.subarray(0, end)).split(/\\r?\\n/);\n  if (!/^NRRD\\d{4}/.test(lines[0] ?? '')) throw new Error('NRRD: not a NRRD file');\n  const field: Record<string, string> = {};\n  for (const line of lines.slice(1)) {\n    if (line.startsWith('#')) continue;\n    const at = line.indexOf(': ');\n    if (at > 0) field[line.slice(0, at).trim().toLowerCase()] = line.slice(at + 2).trim();\n  }\n  if (field['data file'] || field['datafile']) throw new Error('NRRD: detached data (a .nhdr) is not supported');\n  const type = NRRD_TYPES[(field['type'] ?? '').toLowerCase()];\n  if (!type) throw new Error(`NRRD: unsupported type \"${field['type']}\"`);\n  const sizes = (field['sizes'] ?? '').split(/\\s+/).filter(Boolean).map(Number);\n  if (sizes.length !== 2 && sizes.length !== 3)\n    throw new Error(`NRRD: need 2 or 3 dimensions, got ${sizes.length}`);\n  const encoding = (field['encoding'] ?? 'raw').toLowerCase();\n  let data = bytes.subarray(end);\n  if (encoding === 'gzip' || encoding === 'gz') data = await gunzip(data);\n  else if (encoding !== 'raw') throw new Error(`NRRD: unsupported encoding \"${encoding}\"`);\n  const little = (field['endian'] ?? 'little').toLowerCase() !== 'big';\n  // A 3D volume: sections along axis 0, each axis 2 wide and axis 1 high (jit-service's cut).\n  const [n0, n1, n2] = sizes.length === 3 ? sizes : [sizes[0], sizes[1], 1];\n  const axes = sizes.length === 3 ? { z: 0, x: 2, y: 1 } : { z: 2, x: 0, y: 1 };\n  return volume('nrrd', [n0, n1, n2], axes, data, SAMPLES[type], little);\n}\n\nfunction readNifti(bytes: Uint8Array): LabelVolume {\n  if (bytes.length < 352) throw new Error('NIfTI: shorter than a header');\n  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n  let little = true;\n  if (view.getInt32(0, true) !== 348) {\n    if (view.getInt32(0, false) !== 348) throw new Error('NIfTI: not a NIfTI-1 file');\n    little = false;\n  }\n  const magic = new TextDecoder('latin1').decode(bytes.subarray(344, 347));\n  if (magic !== 'n+1') throw new Error('NIfTI: a separate .hdr/.img pair is not supported');\n  const ndim = view.getInt16(40, little);\n  const dims = [1, 2, 3, 4].map((i) => view.getInt16(40 + 2 * i, little));\n  if (ndim < 2) throw new Error(`NIfTI: need at least 2 dimensions, got ${ndim}`);\n  if (ndim >= 4 && dims[3] > 1) throw new Error('NIfTI: a 4D file is not a label volume');\n  const type = NIFTI_TYPES[view.getInt16(70, little)];\n  if (!type) throw new Error(`NIfTI: unsupported datatype ${view.getInt16(70, little)}`);\n  const offset = Math.max(352, Math.round(view.getFloat32(108, little)));\n  const [n0, n1, n2] = [dims[0], dims[1], ndim >= 3 ? dims[2] : 1];\n  // Slices along axis 2, each axis 0 wide and axis 1 high (Bio-Formats' planes).\n  return volume('nifti', [n0, n1, n2], { z: 2, x: 0, y: 1 }, bytes.subarray(offset), SAMPLES[type], little);\n}\n\nfunction volume(\n  format: LabelVolume['format'],\n  n: [number, number, number],\n  axes: { z: number; x: number; y: number },\n  data: Uint8Array,\n  sample: Sample,\n  little: boolean,\n): LabelVolume {\n  const count = n[0] * n[1] * n[2];\n  if (!(count > 0)) throw new Error(`${format}: empty volume`);\n  if (data.length < count * sample.bytes) {\n    throw new Error(`${format}: ${data.length} bytes of data, ${count * sample.bytes} needed`);\n  }\n  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);\n  const stride = [1, n[0], n[0] * n[1]];\n  const width = n[axes.x];\n  const height = n[axes.y];\n  return {\n    format,\n    width,\n    height,\n    slices: n[axes.z],\n    sliceLabels(z: number): Uint32Array {\n      const out = new Uint32Array(width * height);\n      const base = z * stride[axes.z];\n      const sx = stride[axes.x];\n      const sy = stride[axes.y];\n      for (let y = 0; y < height; y++) {\n        for (let x = 0; x < width; x++) {\n          const v = sample.read(view, (base + x * sx + y * sy) * sample.bytes, little);\n          out[y * width + x] = v > 0 ? v : 0;\n        }\n      }\n      return out;\n    },\n  };\n}\n\n/** The offset just past the header's blank line (`\\n\\n` or `\\r\\n\\r\\n`); -1 without one. */\nfunction headerEnd(bytes: Uint8Array): number {\n  const limit = Math.min(bytes.length - 1, 1 << 20);\n  for (let i = 0; i < limit; i++) {\n    if (bytes[i] !== 10) continue;\n    if (bytes[i + 1] === 10) return i + 2;\n    if (bytes[i + 1] === 13 && bytes[i + 2] === 10) return i + 3;\n  }\n  return -1;\n}\n\nfunction isGzip(bytes: Uint8Array): boolean {\n  return bytes.length > 2 && bytes[0] === 0x1f && bytes[1] === 0x8b;\n}\n\nasync function platformGunzip(bytes: Uint8Array): Promise<Uint8Array> {\n  if (typeof DecompressionStream === 'undefined') throw new Error('gzip data needs DecompressionStream');\n  const stream = new Blob([bytes as BlobPart]).stream().pipeThrough(new DecompressionStream('gzip'));\n  return new Uint8Array(await new Response(stream).arrayBuffer());\n}\n"]}

package/esm2022/lib/region-import/region-import.mjs

@@ -0,0 +1,71 @@
+import { isLabelVolumeName } from './label-volume';
+/** `data`, named `name`, as an import file. A `File`'s own name is used when `name` is omitted. */
+export function importFile(data, name = data.name ?? '') {
+    const encoder = new TextEncoder();
+    return {
+        name,
+        text: async () => typeof data === 'string'
+            ? data
+            : data instanceof Blob
+                ? data.text()
+                : new TextDecoder().decode(data instanceof Uint8Array ? data : new Uint8Array(data)),
+        bytes: async () => typeof data === 'string'
+            ? encoder.encode(data)
+            : data instanceof Blob
+                ? new Uint8Array(await data.arrayBuffer())
+                : data instanceof Uint8Array
+                    ? data
+                    : new Uint8Array(data),
+    };
+}
+const leaf = (name) => name.split(/[\\/]/).pop() ?? name;
+const isRegionSet = (f) => leaf(f.name).toLowerCase() === 'regionset.json';
+const isGeoJson = (f) => /\.geojson$/i.test(f.name);
+const isJson = (f) => /\.json$/i.test(f.name);
+/**
+ * What `files` import as: a label volume (`.nii`, `.nii.gz`, `.nrrd`) with the ontology JSON chosen
+ * with it (a `regionset.json`, else an Allen `structure_graph*.json`, else any `.json`); several
+ * region files (a folder of per-slice `.geojson`, in natural name order, its `regionset.json`
+ * apart); or one region file (`.geojson` or `.json`). Null when none of them is one.
+ */
+export function planRegionImport(files) {
+    const volume = files.find((f) => isLabelVolumeName(f.name));
+    if (volume) {
+        const jsons = files.filter((f) => f !== volume && isJson(f));
+        const ontology = jsons.find(isRegionSet) ??
+            jsons.find((f) => /structure_graph.*\.json$/i.test(leaf(f.name))) ??
+            jsons[0] ??
+            null;
+        return { kind: 'volume', volume, ontology };
+    }
+    const regionSet = files.find(isRegionSet) ?? null;
+    const geojsons = files.filter((f) => isGeoJson(f));
+    const regionFiles = geojsons.length ? geojsons : files.filter((f) => isJson(f) && !isRegionSet(f));
+    if (regionFiles.length > 1 || (regionFiles.length === 1 && regionSet)) {
+        const slices = [...regionFiles].sort((a, b) => naturalCompare(leaf(a.name), leaf(b.name)));
+        return { kind: 'folder', slices, regionSet };
+    }
+    return regionFiles.length === 1 ? { kind: 'single', file: regionFiles[0] } : null;
+}
+/** "slice_2" before "slice_10": runs of digits compared as numbers. */
+export function naturalCompare(a, b) {
+    return a.localeCompare(b, undefined, { numeric: true, sensitivity: 'base' });
+}
+/**
+ * A folder slice's GeoJSON with the set's class tree and style (its `regionset.json`) as the
+ * collection's own members, unless the file has its own: what a served folder's slice carries.
+ */
+export async function folderSliceGeoJson(file, regionSet) {
+    const text = await file.text();
+    if (!regionSet || (!regionSet.classHierarchy && !regionSet.style))
+        return text;
+    const doc = JSON.parse(text);
+    if (doc['type'] !== 'FeatureCollection')
+        return text;
+    if (regionSet.classHierarchy && !doc['classHierarchy'])
+        doc['classHierarchy'] = regionSet.classHierarchy;
+    if (regionSet.style && !doc['style'])
+        doc['style'] = regionSet.style;
+    return JSON.stringify(doc);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"region-import.js","sourceRoot":"","sources":["../../../../src/lib/region-import/region-import.ts"],"names":[],"mappings":"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","sourcesContent":["import { isLabelVolumeName } from './label-volume';\n\n/** A file to import regions from: one the user chose, or one the host's server sent. */\nexport interface RegionImportFile {\n  name: string;\n  text(): Promise<string>;\n  bytes(): Promise<Uint8Array>;\n}\n\n/** A file's contents as the host may hand them over (see `ServerRegionPick`). */\nexport type RegionImportData = Blob | ArrayBuffer | Uint8Array | string;\n\n/** `data`, named `name`, as an import file. A `File`'s own name is used when `name` is omitted. */\nexport function importFile(data: RegionImportData, name = (data as File).name ?? ''): RegionImportFile {\n  const encoder = new TextEncoder();\n  return {\n    name,\n    text: async () =>\n      typeof data === 'string'\n        ? data\n        : data instanceof Blob\n          ? data.text()\n          : new TextDecoder().decode(data instanceof Uint8Array ? data : new Uint8Array(data)),\n    bytes: async () =>\n      typeof data === 'string'\n        ? encoder.encode(data)\n        : data instanceof Blob\n          ? new Uint8Array(await data.arrayBuffer())\n          : data instanceof Uint8Array\n            ? data\n            : new Uint8Array(data),\n  };\n}\n\n/** What a set of chosen files imports as. */\nexport type RegionImportPlan =\n  /** A label volume, its classes named by an ontology (or a region set description) beside it. */\n  | { kind: 'volume'; volume: RegionImportFile; ontology: RegionImportFile | null }\n  /** A folder of per-slice region files, in slice order, with the set's `regionset.json`. */\n  | { kind: 'folder'; slices: RegionImportFile[]; regionSet: RegionImportFile | null }\n  /** One region file. */\n  | { kind: 'single'; file: RegionImportFile };\n\nconst leaf = (name: string) => name.split(/[\\\\/]/).pop() ?? name;\nconst isRegionSet = (f: RegionImportFile) => leaf(f.name).toLowerCase() === 'regionset.json';\nconst isGeoJson = (f: RegionImportFile) => /\\.geojson$/i.test(f.name);\nconst isJson = (f: RegionImportFile) => /\\.json$/i.test(f.name);\n\n/**\n * What `files` import as: a label volume (`.nii`, `.nii.gz`, `.nrrd`) with the ontology JSON chosen\n * with it (a `regionset.json`, else an Allen `structure_graph*.json`, else any `.json`); several\n * region files (a folder of per-slice `.geojson`, in natural name order, its `regionset.json`\n * apart); or one region file (`.geojson` or `.json`). Null when none of them is one.\n */\nexport function planRegionImport(files: readonly RegionImportFile[]): RegionImportPlan | null {\n  const volume = files.find((f) => isLabelVolumeName(f.name));\n  if (volume) {\n    const jsons = files.filter((f) => f !== volume && isJson(f));\n    const ontology =\n      jsons.find(isRegionSet) ??\n      jsons.find((f) => /structure_graph.*\\.json$/i.test(leaf(f.name))) ??\n      jsons[0] ??\n      null;\n    return { kind: 'volume', volume, ontology };\n  }\n  const regionSet = files.find(isRegionSet) ?? null;\n  const geojsons = files.filter((f) => isGeoJson(f));\n  const regionFiles = geojsons.length ? geojsons : files.filter((f) => isJson(f) && !isRegionSet(f));\n  if (regionFiles.length > 1 || (regionFiles.length === 1 && regionSet)) {\n    const slices = [...regionFiles].sort((a, b) => naturalCompare(leaf(a.name), leaf(b.name)));\n    return { kind: 'folder', slices, regionSet };\n  }\n  return regionFiles.length === 1 ? { kind: 'single', file: regionFiles[0] } : null;\n}\n\n/** \"slice_2\" before \"slice_10\": runs of digits compared as numbers. */\nexport function naturalCompare(a: string, b: string): number {\n  return a.localeCompare(b, undefined, { numeric: true, sensitivity: 'base' });\n}\n\n/**\n * A folder slice's GeoJSON with the set's class tree and style (its `regionset.json`) as the\n * collection's own members, unless the file has its own: what a served folder's slice carries.\n */\nexport async function folderSliceGeoJson(\n  file: RegionImportFile,\n  regionSet: { classHierarchy?: unknown; style?: unknown } | null,\n): Promise<string> {\n  const text = await file.text();\n  if (!regionSet || (!regionSet.classHierarchy && !regionSet.style)) return text;\n  const doc = JSON.parse(text) as Record<string, unknown>;\n  if (doc['type'] !== 'FeatureCollection') return text;\n  if (regionSet.classHierarchy && !doc['classHierarchy']) doc['classHierarchy'] = regionSet.classHierarchy;\n  if (regionSet.style && !doc['style']) doc['style'] = regionSet.style;\n  return JSON.stringify(doc);\n}\n"]}