@jax-data-science/sci-image-visualizer 0.1.0

package/esm2022/lib/models/region.mjs

@@ -0,0 +1,166 @@
+import { ShapeSelection } from './shape';
+export class Region {
+    constructor() {
+        this.bounds = null;
+        /** Zero-based z-slice this region belongs to within a stack — mirrors
+         *  QuPath's `geometry.plane.z` (a missing plane / default plane reads back as
+         *  0). Used to place/filter ROIs per slice; 0 for a plain single-plane image
+         *  or a region drawn without a slice context (jit-ui#93). */
+        this.z = 0;
+        this.shapeColor = '#00FFFF';
+        this.bytesPerPixel = 8;
+        /**
+         * resolution is the resolution at which the region
+         * was found. In order to get it in the full image
+         * coordinates it will normally be 0. However if
+         * there is a mistake with the resolution it may not
+         * be. We return the resolution here in order to be
+         * sure what it is. The server may need to be changed
+         * to ensure that results regions are always returned
+         * at resolution = 0
+         */
+        this.resolution = 0;
+        this.cropped = false;
+        this.tileNumber = 0;
+        this.tileCoordinates = null;
+    }
+    /** True for intensity-profile line ROIs (the intensity tool's lines). These are
+     *  NOT annotation regions: they never appear in the Region Editor and editor
+     *  operations (select/save/delete) must never touch them. */
+    isProfile() {
+        return this.kind === 'profile';
+    }
+    toString() {
+        // if shape is rectangle
+        if (this.bounds instanceof Rectangle) {
+            return `x: ${this.bounds.x}, y: ${this.bounds.y},
+              width: ${this.bounds.width}, height: ${this.bounds.height}`;
+        }
+        else if (this.bounds instanceof Polygon) {
+            let path = 'M';
+            // display as path
+            for (let i = 0; i < this.bounds.npoints; i++) {
+                if (i < this.bounds.npoints - 1) {
+                    path = `${path}${this.bounds.xpoints[i]},${this.bounds.ypoints[i]}L`;
+                }
+                else {
+                    path = `${path}${this.bounds.xpoints[i]},${this.bounds.ypoints[i]}`;
+                }
+            }
+            if (this.bounds.closed !== false) {
+                path += 'Z';
+            }
+            return path;
+        }
+        return '';
+    }
+    /**
+     * Returns a ShapeSelection object that can be used to
+     * create a shape in Plotly.
+     * @param showRegionLabel
+     * @return ShapeSelection
+     */
+    getShape(showRegionLabel = true) {
+        const shape = new ShapeSelection();
+        shape.id = this.id;
+        shape.name = this.name;
+        shape.editable = true;
+        shape.line = {
+            color: this.color ? this.color : this.shapeColor,
+            width: 3
+        };
+        shape.fileName = this.filename;
+        if (this.kind === 'profile')
+            shape.kind = 'profile';
+        if (showRegionLabel) {
+            shape.label = {
+                text: `${this.label}`,
+                texttemplate: `${this.label}`,
+                font: { color: this.color ? this.color : this.shapeColor },
+                textposition: 'top left'
+            };
+        }
+        else {
+            shape.label = {};
+        }
+        shape.legend = this.label;
+        const bnds = this.bounds;
+        if (bnds != undefined) {
+            if (this.isRectangle(bnds)) {
+                shape.type = 'rect';
+                shape.x0 = bnds.x;
+                shape.y0 = bnds.y;
+                shape.x1 = bnds.x + bnds.width;
+                shape.y1 = bnds.y + bnds.height;
+            }
+            if (this.isPolygon(bnds)) {
+                shape.type = 'path';
+                let path = 'M';
+                for (let i = 0; i < bnds.npoints; i++) {
+                    if (i < bnds.npoints - 1) {
+                        path = `${path}${bnds.xpoints[i]},${bnds.ypoints[i]}L`;
+                    }
+                    else {
+                        path = `${path}${bnds.xpoints[i]},${bnds.ypoints[i]}`;
+                    }
+                }
+                if (bnds.closed !== false) {
+                    path += 'Z';
+                }
+                shape.path = path;
+            }
+        }
+        return shape;
+    }
+    isRectangle(bnds) {
+        return 'x' in bnds && 'y' in bnds && 'width' in bnds && 'height' in bnds;
+    }
+    isPolygon(bnds) {
+        return 'npoints' in bnds && 'xpoints' in bnds && 'ypoints' in bnds;
+    }
+}
+export class Rectangle {
+    constructor() {
+        this.x = 0;
+        this.y = 0;
+        this.width = 0;
+        this.height = 0;
+    }
+}
+export class Polygon {
+    constructor() {
+        this.npoints = 0;
+        this.xpoints = [];
+        this.ypoints = [];
+        this.coordinates = [];
+        /** false for open polylines; true (default) for closed polygons */
+        this.closed = true;
+        /**
+         * When true the vertices are treated as bezier-spline **anchors** and the
+         * region is rendered/exported as a smooth curve through them. The vertices
+         * stay the editable anchors — toggling this flag is the toBezier
+         * (`true`) / toPolygon (`false`), which only add/remove the curve, never move
+         * the anchors. GeoJSON keeps the flattened curve as the geometry (so QuPath
+         * renders it) plus the anchors + handles + flag in properties (so JIT
+         * round-trips the editable bezier).
+         */
+        this.bezier = false;
+    }
+}
+/**
+ * A region whose geometry is several disjoint parts — e.g. the result of merging
+ * two non-touching regions, or the inverse of a blob (jit-ui#85). Each part is a
+ * closed {@link Polygon} that may carry its own holes, so a MultiPolygon
+ * represents "sparse bits, some with donut holes" as a single region. Maps 1:1
+ * onto a GeoJSON `MultiPolygon` (and QuPath's geometry).
+ *
+ * A single-part MultiPolygon is equivalent to that Polygon; callers should
+ * prefer a plain {@link Polygon} for one connected part.
+ */
+export class MultiPolygon {
+    constructor() {
+        /** One or more disjoint closed polygons (each may have holes). */
+        this.polygons = [];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"region.js","sourceRoot":"","sources":["../../../../src/lib/models/region.ts"],"names":[],"mappings":"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","sourcesContent":["import { ShapeSelection } from './shape';\n\nexport class Region {\n\n  /** Stable, unique identity for selection and equality. Minted by\n   *  PlotlyService when a region first enters the system. Never derived\n   *  from array index — name collisions across delete/add cycles must\n   *  not break PrimeNG row selection. */\n  id!: number;\n  name!: string;\n  bounds?: Rectangle | Polygon | MultiPolygon | null = null;\n  /** profile = an intensity-profile line ROI; rendered/dragged like a region but\n   *  excluded from the Regions tab and exports. Use `isProfile()` to test it —\n   *  it's the canonical marker that separates intensity lines (owned by the\n   *  intensity tool, sampled into the inset) from annotation regions (owned by\n   *  the Region Editor). Both backends (Plotly, OSD) honour it. */\n  kind?: 'profile';\n  color?: string; // hex string, e.g. '#RRGGBB' (the historical \"[r, g, b]\" note is stale)\n  // class label\n  label?: string;\n  /** True when the user set this region's colour explicitly (Region Editor Color\n   *  column). Preset colour resolution (jit-ui#70) skips overridden regions so a\n   *  manual colour is not clobbered when presets are (re)applied on load/import. */\n  colorOverridden?: boolean;\n  filename?: string;\n  /** Zero-based z-slice this region belongs to within a stack — mirrors\n   *  QuPath's `geometry.plane.z` (a missing plane / default plane reads back as\n   *  0). Used to place/filter ROIs per slice; 0 for a plain single-plane image\n   *  or a region drawn without a slice context (jit-ui#93). */\n  z = 0;\n  shapeColor? = '#00FFFF';\n  bytesPerPixel = 8;\n  /**\n   * resolution is the resolution at which the region\n   * was found. In order to get it in the full image\n   * coordinates it will normally be 0. However if\n   * there is a mistake with the resolution it may not\n   * be. We return the resolution here in order to be\n   * sure what it is. The server may need to be changed\n   * to ensure that results regions are always returned\n   * at resolution = 0\n   */\n  resolution = 0;\n  cropped = false;\n  tileNumber = 0;\n  tileCoordinates: number[] | null = null;\n\n  /** True for intensity-profile line ROIs (the intensity tool's lines). These are\n   *  NOT annotation regions: they never appear in the Region Editor and editor\n   *  operations (select/save/delete) must never touch them. */\n  isProfile(): boolean {\n    return this.kind === 'profile';\n  }\n\n  toString() {\n    // if shape is rectangle\n    if (this.bounds instanceof Rectangle) {\n      return `x: ${this.bounds.x}, y: ${this.bounds.y},\n              width: ${this.bounds.width}, height: ${this.bounds.height}`;\n    } else if (this.bounds instanceof Polygon){\n      let path = 'M';\n      // display as path\n      for (let i = 0; i < this.bounds.npoints; i++) {\n        if (i < this.bounds.npoints - 1) {\n          path = `${path}${this.bounds.xpoints[i]},${this.bounds.ypoints[i]}L`;\n        } else {\n          path = `${path}${this.bounds.xpoints[i]},${this.bounds.ypoints[i]}`;\n        }\n      }\n      if (this.bounds.closed !== false) {\n        path += 'Z';\n      }\n      return path;\n    }\n    return '';\n  }\n\n  /**\n   * Returns a ShapeSelection object that can be used to\n   * create a shape in Plotly.\n   * @param showRegionLabel\n   * @return ShapeSelection\n   */\n   getShape(showRegionLabel: boolean = true): ShapeSelection {\n    const shape = new ShapeSelection();\n    shape.id = this.id;\n    shape.name = this.name;\n    shape.editable = true;\n    shape.line = {\n      color: this.color ? this.color : this.shapeColor,\n      width: 3\n    };\n    shape.fileName = this.filename;\n    if (this.kind === 'profile') shape.kind = 'profile';\n    if (showRegionLabel) {\n      shape.label = {\n        text: `${this.label}`,\n        texttemplate: `${this.label}`,\n        font: { color: this.color ? this.color : this.shapeColor },\n        textposition: 'top left'\n      };\n    } else {\n      shape.label = {};\n    }\n    shape.legend = this.label;\n\n    const bnds = this.bounds;\n    if (bnds != undefined) {\n      if (this.isRectangle(bnds)) {\n        shape.type = 'rect';\n        shape.x0 = bnds.x;\n        shape.y0 = bnds.y;\n        shape.x1 = bnds.x + bnds.width;\n        shape.y1 = bnds.y + bnds.height;\n      }\n      if (this.isPolygon(bnds)) {\n        shape.type = 'path';\n        let path = 'M';\n        for (let i = 0; i < bnds.npoints; i++) {\n          if (i < bnds.npoints - 1) {\n            path = `${path}${bnds.xpoints[i]},${bnds.ypoints[i]}L`;\n          } else {\n            path = `${path}${bnds.xpoints[i]},${bnds.ypoints[i]}`;\n          }\n        }\n        if (bnds.closed !== false) {\n          path += 'Z';\n        }\n        shape.path = path;\n      }\n    }\n    return shape;\n  }\n\n  isRectangle(bnds: any): bnds is Rectangle {\n    return 'x' in bnds && 'y' in bnds && 'width' in bnds && 'height' in bnds;\n  }\n\n  isPolygon(bnds: any): bnds is Polygon {\n    return 'npoints' in bnds && 'xpoints' in bnds && 'ypoints' in bnds;\n  }\n}\n\nexport class Rectangle {\n  x = 0;\n  y = 0;\n  width = 0;\n  height = 0;\n}\n\nexport class Polygon {\n  npoints = 0;\n  xpoints: number[] = [];\n  ypoints: number[] = [];\n  coordinates: number[][] = [];\n  /** false for open polylines; true (default) for closed polygons */\n  closed = true;\n  /**\n   * When true the vertices are treated as bezier-spline **anchors** and the\n   * region is rendered/exported as a smooth curve through them. The vertices\n   * stay the editable anchors — toggling this flag is the toBezier\n   * (`true`) / toPolygon (`false`), which only add/remove the curve, never move\n   * the anchors. GeoJSON keeps the flattened curve as the geometry (so QuPath\n   * renders it) plus the anchors + handles + flag in properties (so JIT\n   * round-trips the editable bezier).\n   */\n  bezier = false;\n  /**\n   * Per-anchor cubic-bezier control-point offsets, **relative** to their anchor\n   * (so they translate with it). Present only for bezier regions; initialised\n   * from the Catmull-Rom construction (a smooth curve) when bezier is turned on,\n   * then individually editable by dragging the handles. `handlesIn[i]` /\n   * `handlesOut[i]` are `[dx, dy]` for vertex `i`.\n   */\n  handlesIn?: number[][];\n  handlesOut?: number[][];\n\n  /**\n   * Interior rings (holes) — jit-ui#85. Each ring is a list of `[x, y]`\n   * image-pixel pairs in the SAME closed-polygon convention as the exterior\n   * (`coordinates`): no repeated closing point. Present only on closed polygons.\n   * A point inside the exterior **and** inside any hole is OUTSIDE the region\n   * (even-odd rule). Absent/empty == a solid polygon (the prior behaviour), so\n   * every existing region is unaffected.\n   */\n  holes?: number[][][];\n\n  /**\n   * Per-hole bézier control-point offsets, parallel to {@link holes} (one entry per ring, each a\n   * list of `[dx, dy]` per ring vertex, **relative** to the vertex). Present only when `bezier` is\n   * on for a donut — seeded from the Catmull-Rom default and individually editable, exactly like\n   * the exterior {@link handlesIn}/{@link handlesOut}. So a donut smoothed to a bézier curves its\n   * holes too (jit-ui#102).\n   */\n  holeHandlesIn?: number[][][];\n  holeHandlesOut?: number[][][];\n}\n\n/**\n * A region whose geometry is several disjoint parts — e.g. the result of merging\n * two non-touching regions, or the inverse of a blob (jit-ui#85). Each part is a\n * closed {@link Polygon} that may carry its own holes, so a MultiPolygon\n * represents \"sparse bits, some with donut holes\" as a single region. Maps 1:1\n * onto a GeoJSON `MultiPolygon` (and QuPath's geometry).\n *\n * A single-part MultiPolygon is equivalent to that Polygon; callers should\n * prefer a plain {@link Polygon} for one connected part.\n */\nexport class MultiPolygon {\n  /** One or more disjoint closed polygons (each may have holes). */\n  polygons: Polygon[] = [];\n}\n\nexport type Bounds = Rectangle | Polygon | {\n  x?: number;\n  y?: number;\n  width?: number;\n  height?: number;\n  npoints?: number;\n  xpoints?: number[];\n  ypoints?: number[];\n};\n"]}

package/esm2022/lib/models/shape.mjs

@@ -0,0 +1,53 @@
+import { Region, Polygon, Rectangle } from './region';
+export class ShapeSelection {
+    constructor() {
+        this.editable = true;
+    }
+    /**
+     * Returns a Region object based on the shape type.
+     */
+    getRegion() {
+        const region = new Region();
+        region.id = this.id;
+        region.name = this.name;
+        // The region's colour lives on line.color (see Region.getShape); fillcolor
+        // is only set for the active-shape highlight. Restore the class label from
+        // legend too. Without these, getRegions() — which the OSD region overlay
+        // renders from — returned undefined colour AND label, so OSD drew every
+        // region in the default colour with no label (unlike Plotly, which renders
+        // its shape array directly).
+        region.color = this.line?.color ?? this.fillcolor;
+        region.label = this.legend;
+        if (this.kind === 'profile')
+            region.kind = 'profile';
+        if (this.type === 'rect') {
+            region.bounds = new Rectangle();
+            region.bounds.x = this.x0;
+            region.bounds.y = this.y0;
+            region.bounds.width = this.x1 - this.x0;
+            region.bounds.height = this.y1 - this.y0;
+        }
+        else if (this.type === 'path') {
+            region.bounds = new Polygon();
+            const isClosed = this.path.endsWith('Z');
+            const spath = isClosed ? this.path.slice(1, -1) : this.path.slice(1); // remove M and optionally Z
+            const spoints = spath.split('L');
+            region.bounds.npoints = spoints.length;
+            region.bounds.xpoints = [];
+            region.bounds.ypoints = [];
+            region.bounds.coordinates = [];
+            region.bounds.closed = isClosed;
+            for (const point of spoints) {
+                const coords = point.split(',');
+                region.bounds.xpoints.push(parseFloat(coords[0]));
+                region.bounds.ypoints.push(parseFloat(coords[1]));
+                region.bounds.coordinates.push([parseFloat(coords[0]), parseFloat(coords[1])]);
+            }
+        }
+        else {
+            throw new Error(`Unsupported shape type: ${this.type}`);
+        }
+        return region;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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