@jax-data-science/sci-image-visualizer 0.8.3 → 0.10.0

package/esm2022/lib/models/region-geojson.mjs

@@ -0,0 +1,411 @@
+/**
+ * GeoJSON I/O for the region model (review CORE-25, OSD-PLOTLY-35).
+ *
+ * Pure functions between {@link Region}s and a QuPath-compatible GeoJSON
+ * FeatureCollection string, plus {@link downloadGeoJson} (the one DOM-touching
+ * helper, a file download). `RegionStore` calls these directly; the
+ * `PlotUtilities` methods of the same purpose delegate here for compatibility.
+ *
+ * Mapping:
+ *  - `Rectangle` ⇄ a five-point Polygon ring (a single axis-aligned ring with
+ *    no holes reads back as a Rectangle);
+ *  - closed `Polygon` ⇄ `Polygon` (extra rings are holes);
+ *  - open `Polygon` ⇄ `LineString`;
+ *  - `MultiPolygon` ⇄ `MultiPolygon`;
+ *  - a bézier region's geometry is its flattened curve, with the editable
+ *    anchors, handles and hole handles in `properties`;
+ *  - a non-default slice travels as `geometry.plane.z` (QuPath's schema);
+ *  - intensity-profile lines are never exported.
+ */
+import { saveAs } from 'file-saver';
+import { MultiPolygon, Polygon, Rectangle, Region } from './region';
+import { bezierCurveFromHandles, resolveHandles } from './bezier';
+import { hexToRgb, rgbToHex } from '../contracts/color';
+import { featureIdOf } from '../region-source/region-tiles';
+/**
+ * Parse a GeoJSON FeatureCollection string (QuPath-compatible) into regions.
+ * Throws on invalid JSON, a missing `features` key, or a feature without
+ * coordinates.
+ */
+export function regionsFromGeoJson(geoJsonStr) {
+    const regions = [];
+    let geoJson;
+    try {
+        geoJson = JSON.parse(geoJsonStr);
+    }
+    catch (error) {
+        throw new Error('Error parsing json string: ' + error);
+    }
+    if (!geoJson.features) {
+        throw new Error("Invalid GeoJson file: must contain the 'features' key.");
+    }
+    let idx = 0;
+    for (const feature of geoJson.features) {
+        regions.push(regionFromGeoJsonFeature(feature, idx));
+        idx++;
+    }
+    return regions;
+}
+/** Properties SIV reads into the region itself; the rest travel in {@link Region.properties}. */
+const OWN_PROPERTIES = new Set([
+    'classification',
+    'id',
+    'isBezier',
+    'bezierAnchors',
+    'bezierHandlesIn',
+    'bezierHandlesOut',
+    'holes',
+    'holeHandlesIn',
+    'holeHandlesOut',
+]);
+/**
+ * One GeoJSON feature as the region `shape<idx>`. Throws on a feature without coordinates.
+ * The feature's id becomes {@link Region.sourceId} (or `sourceId`, when given: a region source's
+ * id for the feature) and its other properties {@link Region.properties}.
+ */
+export function regionFromGeoJsonFeature(feature, idx, sourceId) {
+    const region = new Region();
+    region.name = `shape${idx}`;
+    const id = sourceId ?? featureIdOf(feature);
+    if (id !== undefined)
+        region.sourceId = id;
+    const extra = Object.entries(feature.properties ?? {}).filter(([key]) => !OWN_PROPERTIES.has(key));
+    if (extra.length)
+        region.properties = Object.fromEntries(extra);
+    // QuPath stores the image plane INSIDE the geometry (a sibling of
+    // type/coordinates), not in properties: `geometry.plane = {c,z,t}`, all
+    // zero-based, and the key is omitted for the default plane (z=0,t=0). A
+    // missing plane therefore reads back as z=0 (jit-ui#93).
+    region.z = feature.geometry?.plane?.z ?? 0;
+    readClassification(region, feature.properties?.classification);
+    region.bounds = boundsFromFeature(feature);
+    return region;
+}
+/** The region's label (and colour) from a feature's `classification`. */
+function readClassification(region, classification) {
+    if (!classification) {
+        // No classification metadata — use a default label and color.
+        region.label = 'Cell';
+    }
+    else if (typeof classification === 'string' || !classification.name) {
+        // assume classification is a string
+        region.label = classification;
+    }
+    else {
+        // if classification is an object with a name / check color as well
+        region.label = classification.name;
+        if (classification.color) {
+            const [r, g, b] = classification.color;
+            region.color = rgbToHex([r, g, b]);
+        }
+    }
+}
+/** A feature's geometry as region bounds. */
+function boundsFromFeature(feature) {
+    // JIT bezier region: the editable anchors + flag travel in properties
+    // (the geometry holds the flattened curve for viewers without bezier
+    // support). Reconstruct the editable bezier from the anchors.
+    if (feature.properties && feature.properties.isBezier && feature.properties.bezierAnchors) {
+        return bezierFromProperties(feature.properties.bezierAnchors, feature.properties, feature.geometry?.type !== 'LineString');
+    }
+    const coordinates = feature.geometry.coordinates;
+    if (!coordinates) {
+        throw new Error("Invalid GeoJson file: must contain the 'coordinates' key.");
+    }
+    // Multi-part region: GeoJSON MultiPolygon → one Polygon per part, each
+    // with its own holes (jit-ui#85).
+    if (feature.geometry.type === 'MultiPolygon') {
+        const mp = new MultiPolygon();
+        mp.polygons = coordinates
+            .map((rings) => polygonFromRings(rings))
+            .filter((p) => p.xpoints.length >= 3);
+        return mp;
+    }
+    // Open polyline: LineString geometry
+    if (feature.geometry.type === 'LineString')
+        return polylineFromLineString(coordinates);
+    // Polygon: check if it encodes a rectangle (single ring only — a polygon
+    // with holes must never be collapsed to a rectangle).
+    const rings = coordinates;
+    if (isRectangleRing(rings)) {
+        const rectangle = new Rectangle();
+        rectangle.x = rings[0][0][0];
+        rectangle.y = rings[0][0][1];
+        rectangle.width = rings[0][2][0] - rings[0][0][0];
+        rectangle.height = rings[0][2][1] - rings[0][0][1];
+        return rectangle;
+    }
+    return polygonFromPolygonRings(rings);
+}
+/** The editable bezier region on `anchors`, its handles and holes from `properties`. */
+function bezierFromProperties(anchors, properties, closed) {
+    const polygon = new Polygon();
+    polygon.bezier = true;
+    polygon.closed = closed;
+    polygon.npoints = anchors.length;
+    polygon.xpoints = anchors.map((a) => a[0]);
+    polygon.ypoints = anchors.map((a) => a[1]);
+    polygon.coordinates = anchors.map((a) => [a[0], a[1]]);
+    // Restore the edited control handles when present (else they'll fall back
+    // to the smooth Catmull-Rom default at render time).
+    if (properties.bezierHandlesIn)
+        polygon.handlesIn = properties.bezierHandlesIn;
+    if (properties.bezierHandlesOut)
+        polygon.handlesOut = properties.bezierHandlesOut;
+    // Restore donut holes + their editable bezier handles (jit-ui#102).
+    if (properties.holes)
+        polygon.holes = properties.holes;
+    if (properties.holeHandlesIn)
+        polygon.holeHandlesIn = properties.holeHandlesIn;
+    if (properties.holeHandlesOut)
+        polygon.holeHandlesOut = properties.holeHandlesOut;
+    return polygon;
+}
+/** An open polyline from a LineString's points. */
+function polylineFromLineString(coordinates) {
+    const polygon = new Polygon();
+    polygon.closed = false;
+    polygon.npoints = coordinates.length;
+    polygon.xpoints = [];
+    polygon.ypoints = [];
+    polygon.coordinates = [];
+    for (let i = 0; i < coordinates.length; i++) {
+        polygon.xpoints.push(coordinates[i][0]);
+        polygon.ypoints.push(coordinates[i][1]);
+        polygon.coordinates.push([coordinates[i][0], coordinates[i][1]]);
+    }
+    return polygon;
+}
+/** Whether Polygon `coordinates` are one closed, axis-aligned four-corner ring. */
+function isRectangleRing(coordinates) {
+    return (coordinates.length === 1 &&
+        coordinates[0].length === 5 &&
+        JSON.stringify(coordinates[0][0]) === JSON.stringify(coordinates[0][4]) &&
+        coordinates[0][0][0] === coordinates[0][3][0] &&
+        coordinates[0][0][1] === coordinates[0][1][1] &&
+        coordinates[0][1][0] === coordinates[0][2][0] &&
+        coordinates[0][2][1] === coordinates[0][3][1]);
+}
+/** A freeform closed polygon from Polygon `coordinates` (the exterior's
+ *  closing point dropped; extra rings are holes). */
+function polygonFromPolygonRings(coordinates) {
+    const polygon = new Polygon();
+    polygon.npoints = coordinates[0].length - 1;
+    polygon.xpoints = [];
+    polygon.ypoints = [];
+    polygon.coordinates = [];
+    for (let i = 0; i < coordinates[0].length - 1; i++) {
+        polygon.xpoints.push(coordinates[0][i][0]);
+        polygon.ypoints.push(coordinates[0][i][1]);
+        polygon.coordinates.push([coordinates[0][i][0], coordinates[0][i][1]]);
+    }
+    // Extra rings are interior holes (GeoJSON Polygon convention) — jit-ui#85.
+    const holes = ringsToHoles(coordinates.slice(1));
+    if (holes.length)
+        polygon.holes = holes;
+    return polygon;
+}
+/**
+ * Serialise regions as a GeoJSON FeatureCollection string (QuPath-compatible),
+ * leaving out intensity-profile lines.
+ */
+export function regionsToGeoJson(rois) {
+    const features = [];
+    for (const roi of rois.filter((r) => r.kind !== 'profile')) {
+        const feature = featureFromRegion(roi);
+        if (feature)
+            features.push(feature);
+    }
+    const geoJsonData = {
+        features: features,
+        type: 'FeatureCollection',
+    };
+    return JSON.stringify(geoJsonData);
+}
+/**
+ * A region as a GeoJSON feature; null for a region without bounds. Its {@link Region.sourceId}
+ * is the feature's `id` and its {@link Region.properties} come along beside the classification.
+ */
+export function featureFromRegion(roi) {
+    const classification = {
+        name: roi.label ? roi.label : roi.name,
+        color: hexToRgb(roi?.color) ?? [0, 0, 0],
+    };
+    // QuPath places the image plane inside the geometry (sibling of
+    // type/coordinates), zero-based, and omits it for the default plane
+    // (z=0,t=0). Emit `plane: {c,z,t}` only for a non-default slice so a
+    // single-plane image round-trips byte-identically to QuPath (jit-ui#93).
+    const planeProp = (roi.z ?? 0) !== 0 ? { plane: { c: -1, z: roi.z, t: 0 } } : {};
+    const feature = geometryFeature(roi, classification, planeProp);
+    if (!feature)
+        return null;
+    if (roi.properties)
+        feature.properties = { ...roi.properties, ...feature.properties };
+    if (roi.sourceId === undefined)
+        return feature;
+    const { type, ...rest } = feature;
+    return { type, id: roi.sourceId, ...rest };
+}
+/** The region's geometry as a feature with its classification (and bézier extras). */
+function geometryFeature(roi, classification, planeProp) {
+    if (roi.bounds instanceof Rectangle) {
+        const { x, y, width, height } = roi.bounds;
+        const ring = [
+            [x, y],
+            [x + width, y],
+            [x + width, y + height],
+            [x, y + height],
+            [x, y],
+        ];
+        return {
+            type: 'Feature',
+            properties: { classification },
+            geometry: { type: 'Polygon', coordinates: [ring], ...planeProp },
+        };
+    }
+    if (roi.bounds instanceof Polygon)
+        return polygonFeature(roi.bounds, classification, planeProp);
+    if (roi.bounds instanceof MultiPolygon) {
+        // Multi-part region → GeoJSON MultiPolygon: one ring-set per part
+        // (exterior + holes), each ring closed (jit-ui#85).
+        const coordinates = roi.bounds.polygons
+            .filter((part) => part.xpoints.length >= 3)
+            .map((part) => {
+            const ext = part.xpoints.map((x, i) => [x, part.ypoints[i]]);
+            const rings = [[...ext, ext[0]]];
+            if (part.holes) {
+                for (const hole of part.holes) {
+                    if (hole.length >= 3)
+                        rings.push([...hole, hole[0]]);
+                }
+            }
+            return rings;
+        });
+        return {
+            type: 'Feature',
+            properties: { classification },
+            geometry: { type: 'MultiPolygon', coordinates, ...planeProp },
+        };
+    }
+    return null;
+}
+/** A closed polygon (with its holes) as a Polygon feature, an open one as a LineString. */
+function polygonFeature(polygon, classification, planeProp) {
+    const closed = polygon.closed !== false;
+    const isBezier = polygon.bezier === true;
+    // For a bezier region the geometry is the flattened smooth curve,
+    // so a viewer without bezier support (QuPath) still renders the curve;
+    // the editable anchors + flag ride along in properties for JIT.
+    const geomCoords = isBezier
+        ? flattenBezier(polygon.xpoints, polygon.ypoints, closed, polygon.handlesIn, polygon.handlesOut)
+        : polygon.coordinates;
+    const properties = { classification };
+    if (isBezier) {
+        properties.isBezier = true;
+        properties.bezierAnchors = polygon.coordinates;
+        // The editable control handles (relative offsets) travel along so JIT
+        // round-trips a hand-edited curve, not just the smooth default.
+        if (polygon.handlesIn)
+            properties.bezierHandlesIn = polygon.handlesIn;
+        if (polygon.handlesOut)
+            properties.bezierHandlesOut = polygon.handlesOut;
+        // Donut bezier: the hole anchors + their editable handles round-trip too (jit-ui#102).
+        if (polygon.holes)
+            properties.holes = polygon.holes;
+        if (polygon.holeHandlesIn)
+            properties.holeHandlesIn = polygon.holeHandlesIn;
+        if (polygon.holeHandlesOut)
+            properties.holeHandlesOut = polygon.holeHandlesOut;
+    }
+    if (!closed) {
+        return {
+            type: 'Feature',
+            properties,
+            geometry: { type: 'LineString', coordinates: geomCoords, ...planeProp },
+        };
+    }
+    // Close the ring. The flattened bezier curve already returns to its
+    // start, so only the straight-polygon path needs the first point
+    // repeated.
+    const ring = isBezier ? geomCoords : [...geomCoords, geomCoords[0]];
+    // Interior rings (holes) follow the exterior as extra GeoJSON rings —
+    // standard Polygon-with-holes, which QuPath round-trips (jit-ui#85). For a bezier donut,
+    // the hole geometry is the flattened smooth curve too (jit-ui#102).
+    const rings = [ring];
+    if (polygon.holes) {
+        polygon.holes.forEach((hole, hi) => {
+            if (hole.length < 3)
+                return;
+            if (isBezier) {
+                const hxs = hole.map((p) => p[0]);
+                const hys = hole.map((p) => p[1]);
+                rings.push(flattenBezier(hxs, hys, true, polygon.holeHandlesIn?.[hi], polygon.holeHandlesOut?.[hi]));
+            }
+            else {
+                rings.push([...hole, hole[0]]);
+            }
+        });
+    }
+    return { type: 'Feature', properties, geometry: { type: 'Polygon', coordinates: rings, ...planeProp } };
+}
+/** The flattened bezier curve through anchors `xs`/`ys` with the given handle offsets, as points. */
+function flattenBezier(xs, ys, closed, handlesIn, handlesOut) {
+    const c = bezierCurveFromHandles(xs, ys, resolveHandles(xs, ys, closed, handlesIn, handlesOut), closed);
+    return c.xs.map((x, i) => [x, c.ys[i]]);
+}
+/**
+ * Build a closed {@link Polygon} from a GeoJSON ring set: `rings[0]` is the
+ * exterior (closing point dropped), `rings[1..]` are interior holes. jit-ui#85.
+ */
+function polygonFromRings(rings) {
+    const poly = new Polygon();
+    const ext = rings?.[0] ?? [];
+    const last = ext.length - 1;
+    const closed = ext.length > 1 && ext[0][0] === ext[last][0] && ext[0][1] === ext[last][1];
+    const n = closed ? last : ext.length;
+    poly.xpoints = [];
+    poly.ypoints = [];
+    poly.coordinates = [];
+    for (let i = 0; i < n; i++) {
+        poly.xpoints.push(ext[i][0]);
+        poly.ypoints.push(ext[i][1]);
+        poly.coordinates.push([ext[i][0], ext[i][1]]);
+    }
+    poly.npoints = poly.xpoints.length;
+    poly.closed = true;
+    const holes = ringsToHoles(rings.slice(1));
+    if (holes.length)
+        poly.holes = holes;
+    return poly;
+}
+/**
+ * Convert GeoJSON interior rings into the neutral hole representation
+ * (`number[][]` per ring, no repeated closing point). Degenerate rings (< 3
+ * distinct points) are dropped. jit-ui#85.
+ */
+function ringsToHoles(rings) {
+    const holes = [];
+    for (const ringIn of rings || []) {
+        if (!ringIn || ringIn.length < 3)
+            continue;
+        const last = ringIn.length - 1;
+        const closed = ringIn[0][0] === ringIn[last][0] && ringIn[0][1] === ringIn[last][1];
+        const n = closed ? last : ringIn.length;
+        const ring = [];
+        for (let i = 0; i < n; i++)
+            ring.push([ringIn[i][0], ringIn[i][1]]);
+        if (ring.length >= 3)
+            holes.push(ring);
+    }
+    return holes;
+}
+/**
+ * Download a GeoJSON string as `<baseName without extension>.geojson`
+ * (`rois.geojson` without a base name).
+ */
+export function downloadGeoJson(jsonString, baseName) {
+    const blob = new Blob([jsonString], { type: 'application/json' });
+    const stem = (baseName ?? '').replace(/\.[^/.]+$/, '').trim() || 'rois';
+    saveAs(blob, `${stem}.geojson`);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"region-geojson.js","sourceRoot":"","sources":["../../../../src/lib/models/region-geojson.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * GeoJSON I/O for the region model (review CORE-25, OSD-PLOTLY-35).\n *\n * Pure functions between {@link Region}s and a QuPath-compatible GeoJSON\n * FeatureCollection string, plus {@link downloadGeoJson} (the one DOM-touching\n * helper, a file download). `RegionStore` calls these directly; the\n * `PlotUtilities` methods of the same purpose delegate here for compatibility.\n *\n * Mapping:\n *  - `Rectangle` ⇄ a five-point Polygon ring (a single axis-aligned ring with\n *    no holes reads back as a Rectangle);\n *  - closed `Polygon` ⇄ `Polygon` (extra rings are holes);\n *  - open `Polygon` ⇄ `LineString`;\n *  - `MultiPolygon` ⇄ `MultiPolygon`;\n *  - a bézier region's geometry is its flattened curve, with the editable\n *    anchors, handles and hole handles in `properties`;\n *  - a non-default slice travels as `geometry.plane.z` (QuPath's schema);\n *  - intensity-profile lines are never exported.\n */\nimport { saveAs } from 'file-saver';\n\nimport { MultiPolygon, Polygon, Rectangle, Region } from './region';\nimport { bezierCurveFromHandles, resolveHandles } from './bezier';\nimport { hexToRgb, rgbToHex } from '../contracts/color';\nimport { featureIdOf } from '../region-source/region-tiles';\n\n/**\n * Parse a GeoJSON FeatureCollection string (QuPath-compatible) into regions.\n * Throws on invalid JSON, a missing `features` key, or a feature without\n * coordinates.\n */\nexport function regionsFromGeoJson(geoJsonStr: string): Region[] {\n  const regions: Region[] = [];\n  let geoJson: any;\n  try {\n    geoJson = JSON.parse(geoJsonStr);\n  } catch (error) {\n    throw new Error('Error parsing json string: ' + error);\n  }\n  if (!geoJson.features) {\n    throw new Error(\"Invalid GeoJson file: must contain the 'features' key.\");\n  }\n  let idx = 0;\n  for (const feature of geoJson.features) {\n    regions.push(regionFromGeoJsonFeature(feature, idx));\n    idx++;\n  }\n  return regions;\n}\n\n/** Properties SIV reads into the region itself; the rest travel in {@link Region.properties}. */\nconst OWN_PROPERTIES = new Set([\n  'classification',\n  'id',\n  'isBezier',\n  'bezierAnchors',\n  'bezierHandlesIn',\n  'bezierHandlesOut',\n  'holes',\n  'holeHandlesIn',\n  'holeHandlesOut',\n]);\n\n/** A feature's `classification`: QuPath's `{name, color}`, or a bare name. */\ntype Classification = string | { name?: string; color?: number[] };\n\n/** The parts of a GeoJSON feature the reader looks at, JIT's bezier extras\n *  included. Parsed from a file, so nothing here is guaranteed. */\nexport interface GeoJsonFeature {\n  id?: string | number;\n  geometry: { type?: string; coordinates?: unknown; plane?: { z?: number } };\n  properties?: {\n    id?: string | number;\n    classification?: Classification;\n    isBezier?: boolean;\n    bezierAnchors?: number[][];\n    bezierHandlesIn?: number[][];\n    bezierHandlesOut?: number[][];\n    holes?: number[][][];\n    holeHandlesIn?: number[][][];\n    holeHandlesOut?: number[][][];\n  };\n}\n\n/**\n * One GeoJSON feature as the region `shape<idx>`. Throws on a feature without coordinates.\n * The feature's id becomes {@link Region.sourceId} (or `sourceId`, when given: a region source's\n * id for the feature) and its other properties {@link Region.properties}.\n */\nexport function regionFromGeoJsonFeature(feature: GeoJsonFeature, idx: number, sourceId?: string): Region {\n  const region = new Region();\n  region.name = `shape${idx}`;\n  const id = sourceId ?? featureIdOf(feature);\n  if (id !== undefined) region.sourceId = id;\n  const extra = Object.entries(feature.properties ?? {}).filter(([key]) => !OWN_PROPERTIES.has(key));\n  if (extra.length) region.properties = Object.fromEntries(extra);\n  // QuPath stores the image plane INSIDE the geometry (a sibling of\n  // type/coordinates), not in properties: `geometry.plane = {c,z,t}`, all\n  // zero-based, and the key is omitted for the default plane (z=0,t=0). A\n  // missing plane therefore reads back as z=0 (jit-ui#93).\n  region.z = feature.geometry?.plane?.z ?? 0;\n  readClassification(region, feature.properties?.classification);\n  region.bounds = boundsFromFeature(feature);\n  return region;\n}\n\n/** The region's label (and colour) from a feature's `classification`. */\nfunction readClassification(region: Region, classification: Classification | undefined): void {\n  if (!classification) {\n    // No classification metadata — use a default label and color.\n    region.label = 'Cell';\n  } else if (typeof classification === 'string' || !classification.name) {\n    // assume classification is a string\n    region.label = classification as string;\n  } else {\n    // if classification is an object with a name / check color as well\n    region.label = classification.name;\n    if (classification.color) {\n      const [r, g, b] = classification.color;\n      region.color = rgbToHex([r, g, b]);\n    }\n  }\n}\n\n/** A feature's geometry as region bounds. */\nfunction boundsFromFeature(feature: GeoJsonFeature): Rectangle | Polygon | MultiPolygon {\n  // JIT bezier region: the editable anchors + flag travel in properties\n  // (the geometry holds the flattened curve for viewers without bezier\n  // support). Reconstruct the editable bezier from the anchors.\n  if (feature.properties && feature.properties.isBezier && feature.properties.bezierAnchors) {\n    return bezierFromProperties(\n      feature.properties.bezierAnchors,\n      feature.properties,\n      feature.geometry?.type !== 'LineString',\n    );\n  }\n  const coordinates = feature.geometry.coordinates;\n  if (!coordinates) {\n    throw new Error(\"Invalid GeoJson file: must contain the 'coordinates' key.\");\n  }\n  // Multi-part region: GeoJSON MultiPolygon → one Polygon per part, each\n  // with its own holes (jit-ui#85).\n  if (feature.geometry.type === 'MultiPolygon') {\n    const mp = new MultiPolygon();\n    mp.polygons = (coordinates as number[][][][])\n      .map((rings) => polygonFromRings(rings))\n      .filter((p) => p.xpoints.length >= 3);\n    return mp;\n  }\n  // Open polyline: LineString geometry\n  if (feature.geometry.type === 'LineString') return polylineFromLineString(coordinates as number[][]);\n  // Polygon: check if it encodes a rectangle (single ring only — a polygon\n  // with holes must never be collapsed to a rectangle).\n  const rings = coordinates as number[][][];\n  if (isRectangleRing(rings)) {\n    const rectangle = new Rectangle();\n    rectangle.x = rings[0][0][0];\n    rectangle.y = rings[0][0][1];\n    rectangle.width = rings[0][2][0] - rings[0][0][0];\n    rectangle.height = rings[0][2][1] - rings[0][0][1];\n    return rectangle;\n  }\n  return polygonFromPolygonRings(rings);\n}\n\n/** The editable bezier region on `anchors`, its handles and holes from `properties`. */\nfunction bezierFromProperties(\n  anchors: number[][],\n  properties: NonNullable<GeoJsonFeature['properties']>,\n  closed: boolean,\n): Polygon {\n  const polygon = new Polygon();\n  polygon.bezier = true;\n  polygon.closed = closed;\n  polygon.npoints = anchors.length;\n  polygon.xpoints = anchors.map((a) => a[0]);\n  polygon.ypoints = anchors.map((a) => a[1]);\n  polygon.coordinates = anchors.map((a) => [a[0], a[1]]);\n  // Restore the edited control handles when present (else they'll fall back\n  // to the smooth Catmull-Rom default at render time).\n  if (properties.bezierHandlesIn) polygon.handlesIn = properties.bezierHandlesIn;\n  if (properties.bezierHandlesOut) polygon.handlesOut = properties.bezierHandlesOut;\n  // Restore donut holes + their editable bezier handles (jit-ui#102).\n  if (properties.holes) polygon.holes = properties.holes;\n  if (properties.holeHandlesIn) polygon.holeHandlesIn = properties.holeHandlesIn;\n  if (properties.holeHandlesOut) polygon.holeHandlesOut = properties.holeHandlesOut;\n  return polygon;\n}\n\n/** An open polyline from a LineString's points. */\nfunction polylineFromLineString(coordinates: number[][]): Polygon {\n  const polygon = new Polygon();\n  polygon.closed = false;\n  polygon.npoints = coordinates.length;\n  polygon.xpoints = [];\n  polygon.ypoints = [];\n  polygon.coordinates = [];\n  for (let i = 0; i < coordinates.length; i++) {\n    polygon.xpoints.push(coordinates[i][0]);\n    polygon.ypoints.push(coordinates[i][1]);\n    polygon.coordinates.push([coordinates[i][0], coordinates[i][1]]);\n  }\n  return polygon;\n}\n\n/** Whether Polygon `coordinates` are one closed, axis-aligned four-corner ring. */\nfunction isRectangleRing(coordinates: number[][][]): boolean {\n  return (\n    coordinates.length === 1 &&\n    coordinates[0].length === 5 &&\n    JSON.stringify(coordinates[0][0]) === JSON.stringify(coordinates[0][4]) &&\n    coordinates[0][0][0] === coordinates[0][3][0] &&\n    coordinates[0][0][1] === coordinates[0][1][1] &&\n    coordinates[0][1][0] === coordinates[0][2][0] &&\n    coordinates[0][2][1] === coordinates[0][3][1]\n  );\n}\n\n/** A freeform closed polygon from Polygon `coordinates` (the exterior's\n *  closing point dropped; extra rings are holes). */\nfunction polygonFromPolygonRings(coordinates: number[][][]): Polygon {\n  const polygon = new Polygon();\n  polygon.npoints = coordinates[0].length - 1;\n  polygon.xpoints = [];\n  polygon.ypoints = [];\n  polygon.coordinates = [];\n  for (let i = 0; i < coordinates[0].length - 1; i++) {\n    polygon.xpoints.push(coordinates[0][i][0]);\n    polygon.ypoints.push(coordinates[0][i][1]);\n    polygon.coordinates.push([coordinates[0][i][0], coordinates[0][i][1]]);\n  }\n  // Extra rings are interior holes (GeoJSON Polygon convention) — jit-ui#85.\n  const holes = ringsToHoles(coordinates.slice(1));\n  if (holes.length) polygon.holes = holes;\n  return polygon;\n}\n\n/**\n * Serialise regions as a GeoJSON FeatureCollection string (QuPath-compatible),\n * leaving out intensity-profile lines.\n */\nexport function regionsToGeoJson(rois: readonly Region[]): string {\n  const features: object[] = [];\n  for (const roi of rois.filter((r) => r.kind !== 'profile')) {\n    const feature = featureFromRegion(roi);\n    if (feature) features.push(feature);\n  }\n  const geoJsonData = {\n    features: features,\n    type: 'FeatureCollection',\n  };\n\n  return JSON.stringify(geoJsonData);\n}\n\n/**\n * A region as a GeoJSON feature; null for a region without bounds. Its {@link Region.sourceId}\n * is the feature's `id` and its {@link Region.properties} come along beside the classification.\n */\nexport function featureFromRegion(roi: Region): object | null {\n  const classification = {\n    name: roi.label ? roi.label : roi.name,\n    color: hexToRgb(roi?.color) ?? [0, 0, 0],\n  };\n  // QuPath places the image plane inside the geometry (sibling of\n  // type/coordinates), zero-based, and omits it for the default plane\n  // (z=0,t=0). Emit `plane: {c,z,t}` only for a non-default slice so a\n  // single-plane image round-trips byte-identically to QuPath (jit-ui#93).\n  const planeProp = (roi.z ?? 0) !== 0 ? { plane: { c: -1, z: roi.z, t: 0 } } : {};\n  const feature = geometryFeature(roi, classification, planeProp);\n  if (!feature) return null;\n  if (roi.properties) feature.properties = { ...roi.properties, ...feature.properties };\n  if (roi.sourceId === undefined) return feature;\n  const { type, ...rest } = feature;\n  return { type, id: roi.sourceId, ...rest };\n}\n\n/** A GeoJSON feature as {@link featureFromRegion} builds it. */\ninterface ExportedFeature {\n  type: 'Feature';\n  id?: string;\n  properties: Record<string, unknown>;\n  geometry: object;\n}\n\n/** The region's geometry as a feature with its classification (and bézier extras). */\nfunction geometryFeature(roi: Region, classification: object, planeProp: object): ExportedFeature | null {\n  if (roi.bounds instanceof Rectangle) {\n    const { x, y, width, height } = roi.bounds;\n    const ring = [\n      [x, y],\n      [x + width, y],\n      [x + width, y + height],\n      [x, y + height],\n      [x, y],\n    ];\n    return {\n      type: 'Feature',\n      properties: { classification },\n      geometry: { type: 'Polygon', coordinates: [ring], ...planeProp },\n    };\n  }\n  if (roi.bounds instanceof Polygon) return polygonFeature(roi.bounds, classification, planeProp);\n  if (roi.bounds instanceof MultiPolygon) {\n    // Multi-part region → GeoJSON MultiPolygon: one ring-set per part\n    // (exterior + holes), each ring closed (jit-ui#85).\n    const coordinates = roi.bounds.polygons\n      .filter((part) => part.xpoints.length >= 3)\n      .map((part) => {\n        const ext = part.xpoints.map((x, i) => [x, part.ypoints[i]]);\n        const rings: number[][][] = [[...ext, ext[0]]];\n        if (part.holes) {\n          for (const hole of part.holes) {\n            if (hole.length >= 3) rings.push([...hole, hole[0]]);\n          }\n        }\n        return rings;\n      });\n    return {\n      type: 'Feature',\n      properties: { classification },\n      geometry: { type: 'MultiPolygon', coordinates, ...planeProp },\n    };\n  }\n  return null;\n}\n\n/** A closed polygon (with its holes) as a Polygon feature, an open one as a LineString. */\nfunction polygonFeature(polygon: Polygon, classification: object, planeProp: object): ExportedFeature {\n  const closed = polygon.closed !== false;\n  const isBezier = polygon.bezier === true;\n  // For a bezier region the geometry is the flattened smooth curve,\n  // so a viewer without bezier support (QuPath) still renders the curve;\n  // the editable anchors + flag ride along in properties for JIT.\n  const geomCoords = isBezier\n    ? flattenBezier(polygon.xpoints, polygon.ypoints, closed, polygon.handlesIn, polygon.handlesOut)\n    : polygon.coordinates;\n  const properties: Record<string, unknown> = { classification };\n  if (isBezier) {\n    properties.isBezier = true;\n    properties.bezierAnchors = polygon.coordinates;\n    // The editable control handles (relative offsets) travel along so JIT\n    // round-trips a hand-edited curve, not just the smooth default.\n    if (polygon.handlesIn) properties.bezierHandlesIn = polygon.handlesIn;\n    if (polygon.handlesOut) properties.bezierHandlesOut = polygon.handlesOut;\n    // Donut bezier: the hole anchors + their editable handles round-trip too (jit-ui#102).\n    if (polygon.holes) properties.holes = polygon.holes;\n    if (polygon.holeHandlesIn) properties.holeHandlesIn = polygon.holeHandlesIn;\n    if (polygon.holeHandlesOut) properties.holeHandlesOut = polygon.holeHandlesOut;\n  }\n  if (!closed) {\n    return {\n      type: 'Feature',\n      properties,\n      geometry: { type: 'LineString', coordinates: geomCoords, ...planeProp },\n    };\n  }\n  // Close the ring. The flattened bezier curve already returns to its\n  // start, so only the straight-polygon path needs the first point\n  // repeated.\n  const ring = isBezier ? geomCoords : [...geomCoords, geomCoords[0]];\n  // Interior rings (holes) follow the exterior as extra GeoJSON rings —\n  // standard Polygon-with-holes, which QuPath round-trips (jit-ui#85). For a bezier donut,\n  // the hole geometry is the flattened smooth curve too (jit-ui#102).\n  const rings: number[][][] = [ring];\n  if (polygon.holes) {\n    polygon.holes.forEach((hole, hi) => {\n      if (hole.length < 3) return;\n      if (isBezier) {\n        const hxs = hole.map((p) => p[0]);\n        const hys = hole.map((p) => p[1]);\n        rings.push(flattenBezier(hxs, hys, true, polygon.holeHandlesIn?.[hi], polygon.holeHandlesOut?.[hi]));\n      } else {\n        rings.push([...hole, hole[0]]);\n      }\n    });\n  }\n  return { type: 'Feature', properties, geometry: { type: 'Polygon', coordinates: rings, ...planeProp } };\n}\n\n/** The flattened bezier curve through anchors `xs`/`ys` with the given handle offsets, as points. */\nfunction flattenBezier(\n  xs: number[],\n  ys: number[],\n  closed: boolean,\n  handlesIn?: number[][],\n  handlesOut?: number[][],\n): number[][] {\n  const c = bezierCurveFromHandles(xs, ys, resolveHandles(xs, ys, closed, handlesIn, handlesOut), closed);\n  return c.xs.map((x, i) => [x, c.ys[i]]);\n}\n\n/**\n * Build a closed {@link Polygon} from a GeoJSON ring set: `rings[0]` is the\n * exterior (closing point dropped), `rings[1..]` are interior holes. jit-ui#85.\n */\nfunction polygonFromRings(rings: number[][][]): Polygon {\n  const poly = new Polygon();\n  const ext = rings?.[0] ?? [];\n  const last = ext.length - 1;\n  const closed = ext.length > 1 && ext[0][0] === ext[last][0] && ext[0][1] === ext[last][1];\n  const n = closed ? last : ext.length;\n  poly.xpoints = [];\n  poly.ypoints = [];\n  poly.coordinates = [];\n  for (let i = 0; i < n; i++) {\n    poly.xpoints.push(ext[i][0]);\n    poly.ypoints.push(ext[i][1]);\n    poly.coordinates.push([ext[i][0], ext[i][1]]);\n  }\n  poly.npoints = poly.xpoints.length;\n  poly.closed = true;\n  const holes = ringsToHoles(rings.slice(1));\n  if (holes.length) poly.holes = holes;\n  return poly;\n}\n\n/**\n * Convert GeoJSON interior rings into the neutral hole representation\n * (`number[][]` per ring, no repeated closing point). Degenerate rings (< 3\n * distinct points) are dropped. jit-ui#85.\n */\nfunction ringsToHoles(rings: number[][][]): number[][][] {\n  const holes: number[][][] = [];\n  for (const ringIn of rings || []) {\n    if (!ringIn || ringIn.length < 3) continue;\n    const last = ringIn.length - 1;\n    const closed = ringIn[0][0] === ringIn[last][0] && ringIn[0][1] === ringIn[last][1];\n    const n = closed ? last : ringIn.length;\n    const ring: number[][] = [];\n    for (let i = 0; i < n; i++) ring.push([ringIn[i][0], ringIn[i][1]]);\n    if (ring.length >= 3) holes.push(ring);\n  }\n  return holes;\n}\n\n/**\n * Download a GeoJSON string as `<baseName without extension>.geojson`\n * (`rois.geojson` without a base name).\n */\nexport function downloadGeoJson(jsonString: string, baseName?: string): void {\n  const blob = new Blob([jsonString], { type: 'application/json' });\n  const stem = (baseName ?? '').replace(/\\.[^/.]+$/, '').trim() || 'rois';\n  saveAs(blob, `${stem}.geojson`);\n}\n"]}