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

package/esm2022/lib/plot-mode/plot-type-menu.mjs

@@ -0,0 +1,85 @@
+import { ViewerFeature } from '../contracts/capabilities.contract';
+import { PlotType, getPlotTypeDescriptor } from '../contracts/plot-type';
+import { contributedPlotTypeOption, } from '../contracts/plot-type-contribution.contract';
+/**
+ * Plot types offered in the selector for the current image:
+ *  - Outside **test mode**, only the curated default set (descriptors with a
+ *    `productionLabel`) is offered, shown under suffix-free names — Image,
+ *    Heatmap, Contour and the napari Surface / Volume / Isosurface. Test mode
+ *    exposes every backend's type under its full (backend-suffixed) label.
+ *  - 3D types hidden when the backend can't render a 3D scene.
+ *  - stack-only types (volume, isosurface) hidden unless the file is a stack —
+ *    a volume needs multiple z-slices.
+ *  - scalar-intensity types (contour, surface, isosurface) hidden for RGB
+ *    images — they map a single intensity per pixel. Image and Heatmap render
+ *    any image. A multichannel image's bands are each scalar, so it passes.
+ *  - spatial-omics types hidden until a `SpatialDataset` is published on
+ *    `SPATIAL_DATA_PORT` — the mode has nothing to draw without observations,
+ *    exactly as a volume has nothing to draw without a stack.
+ *  - image-sourced types hidden while a dataset that brings no pixels is up.
+ *
+ * Contributed modes come after every built-in one, under the same label rule and
+ * their own stack/grayscale/spatial gates; a mode also needs whatever its base view
+ * needs, so the base type's gates apply too.
+ */
+export function computePlotTypeMenu(input) {
+    const { caps, imageInfo, spatial, testMode } = input;
+    const isStack = !!imageInfo?.isStack;
+    const isGrayscale = !!imageInfo?.isGrayscale;
+    const m0 = imageInfo?.imageMeta?.[0];
+    const isMultichannel = (m0?.channelCount ?? 1) > 1 && (m0?.rgbChannels ?? 1) < 3;
+    const dataGates = (d) => {
+        // Volume and Isosurface raymarch the IMAGE STACK, and nothing else: a 3D omics
+        // dataset reaches them because its registered volume is published AS a grayscale
+        // z-stack image (`buildVolumeStackImage`), not through a second voxel source.
+        if (d.requiresStack && !isStack)
+            return false;
+        if (d.requiresGrayscale && !isGrayscale && !isMultichannel)
+            return false;
+        if (d.requiresSpatialData && !spatial.hasDataset)
+            return false;
+        if (d.requiresSpatial3d && !spatial.has3d)
+            return false;
+        return true;
+    };
+    const passesGates = (d) => {
+        if (d.dimensions === '3d' && !caps.has(ViewerFeature.Surface3D))
+            return false;
+        if (!dataGates(d))
+            return false;
+        // An image-sourced mode reads PIXELS. A spatial dataset that brings no tissue image
+        // (seqFISH records unitless coordinates, not a section) leaves nothing for one to
+        // draw. Narrowed to "a dataset is up AND there is no image": with no dataset at
+        // all, Image stays on offer as the host's default.
+        return !(d.source === 'image' && spatial.hasDataset && !spatial.hasPixels);
+    };
+    const curated = (d) => testMode || !!d.productionLabel;
+    const builtIn = input.descriptors.filter((d) => curated(d) && passesGates(d));
+    const contributed = [];
+    for (const d of input.contributions) {
+        if (!curated(d) || !dataGates(d))
+            continue;
+        const base = getPlotTypeDescriptor(d.baseType);
+        if (base && passesGates(base))
+            contributed.push(contributedPlotTypeOption(d, base));
+    }
+    // Default selector shows the suffix-free productionLabel; test mode keeps the full
+    // backend-suffixed label so same-named modes stay distinguishable.
+    const labelled = (d) => testMode ? d : { ...d, label: d.productionLabel };
+    const shown = builtIn.map(labelled);
+    return { builtIn: shown, menu: [...shown, ...contributed.map(labelled)] };
+}
+/**
+ * The type to fall back to when `selected` is no longer offered — Image when it is
+ * on offer, else the first type still offered — or null when `selected` is still
+ * offered (or nothing is). With no image loaded the pixel modes are gone, and falling
+ * back to Image would select a mode the selector does not list and nothing can draw.
+ */
+export function reconcilePlotType(menu, selected) {
+    if (menu.some((d) => d.type === selected))
+        return null;
+    if (menu.some((d) => d.type === PlotType.IMAGE))
+        return PlotType.IMAGE;
+    return menu[0]?.type ?? null;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plot-type-menu.js","sourceRoot":"","sources":["../../../../src/lib/plot-mode/plot-type-menu.ts"],"names":[],"mappings":"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","sourcesContent":["import { ViewerCapabilities, ViewerFeature } from '../contracts/capabilities.contract';\nimport { IImageInfo } from '../contracts/image.contract';\nimport { PlotType, PlotTypeDescriptor, PlotTypeId, getPlotTypeDescriptor } from '../contracts/plot-type';\nimport {\n  ContributedPlotTypeDescriptor,\n  PlotTypeOption,\n  contributedPlotTypeOption,\n} from '../contracts/plot-type-contribution.contract';\n\n/** What a spatial-omics dataset on offer contributes to the plot-type gates. */\nexport interface SpatialGates {\n  /** A dataset is published on `SPATIAL_DATA_PORT`. */\n  hasDataset: boolean;\n  /** Its observations carry a z, so it can be drawn as a 3D cloud. */\n  has3d: boolean;\n  /** It brings pixels of its own: a tissue image it registers onto, or a volume\n   *  published as a z-stack image. */\n  hasPixels: boolean;\n}\n\ntype DataRequirements = Pick<\n  PlotTypeDescriptor,\n  'requiresStack' | 'requiresGrayscale' | 'requiresSpatialData' | 'requiresSpatial3d'\n>;\n\n/** Everything {@link computePlotTypeMenu} gates on. */\nexport interface PlotTypeMenuInput {\n  /** The built-in types the backend advertises. */\n  descriptors: PlotTypeDescriptor[];\n  /** Contributed plot modes (`PLOT_TYPE_CONTRIBUTIONS`). */\n  contributions: ContributedPlotTypeDescriptor[];\n  caps: ViewerCapabilities;\n  imageInfo: IImageInfo | undefined;\n  spatial: SpatialGates;\n  /** Offer every backend's type under its full label, not just the curated set. */\n  testMode: boolean;\n}\n\n/** The selector's entries: {@link builtIn} then the contributed modes. */\nexport interface PlotTypeMenu {\n  builtIn: PlotTypeDescriptor[];\n  menu: PlotTypeOption[];\n}\n\n/**\n * Plot types offered in the selector for the current image:\n *  - Outside **test mode**, only the curated default set (descriptors with a\n *    `productionLabel`) is offered, shown under suffix-free names — Image,\n *    Heatmap, Contour and the napari Surface / Volume / Isosurface. Test mode\n *    exposes every backend's type under its full (backend-suffixed) label.\n *  - 3D types hidden when the backend can't render a 3D scene.\n *  - stack-only types (volume, isosurface) hidden unless the file is a stack —\n *    a volume needs multiple z-slices.\n *  - scalar-intensity types (contour, surface, isosurface) hidden for RGB\n *    images — they map a single intensity per pixel. Image and Heatmap render\n *    any image. A multichannel image's bands are each scalar, so it passes.\n *  - spatial-omics types hidden until a `SpatialDataset` is published on\n *    `SPATIAL_DATA_PORT` — the mode has nothing to draw without observations,\n *    exactly as a volume has nothing to draw without a stack.\n *  - image-sourced types hidden while a dataset that brings no pixels is up.\n *\n * Contributed modes come after every built-in one, under the same label rule and\n * their own stack/grayscale/spatial gates; a mode also needs whatever its base view\n * needs, so the base type's gates apply too.\n */\nexport function computePlotTypeMenu(input: PlotTypeMenuInput): PlotTypeMenu {\n  const { caps, imageInfo, spatial, testMode } = input;\n  const isStack = !!imageInfo?.isStack;\n  const isGrayscale = !!imageInfo?.isGrayscale;\n  const m0 = imageInfo?.imageMeta?.[0];\n  const isMultichannel = (m0?.channelCount ?? 1) > 1 && (m0?.rgbChannels ?? 1) < 3;\n  const dataGates = (d: DataRequirements): boolean => {\n    // Volume and Isosurface raymarch the IMAGE STACK, and nothing else: a 3D omics\n    // dataset reaches them because its registered volume is published AS a grayscale\n    // z-stack image (`buildVolumeStackImage`), not through a second voxel source.\n    if (d.requiresStack && !isStack) return false;\n    if (d.requiresGrayscale && !isGrayscale && !isMultichannel) return false;\n    if (d.requiresSpatialData && !spatial.hasDataset) return false;\n    if (d.requiresSpatial3d && !spatial.has3d) return false;\n    return true;\n  };\n  const passesGates = (d: PlotTypeDescriptor): boolean => {\n    if (d.dimensions === '3d' && !caps.has(ViewerFeature.Surface3D)) return false;\n    if (!dataGates(d)) return false;\n    // An image-sourced mode reads PIXELS. A spatial dataset that brings no tissue image\n    // (seqFISH records unitless coordinates, not a section) leaves nothing for one to\n    // draw. Narrowed to \"a dataset is up AND there is no image\": with no dataset at\n    // all, Image stays on offer as the host's default.\n    return !(d.source === 'image' && spatial.hasDataset && !spatial.hasPixels);\n  };\n  const curated = (d: { productionLabel?: string }): boolean => testMode || !!d.productionLabel;\n  const builtIn = input.descriptors.filter((d) => curated(d) && passesGates(d));\n  const contributed: PlotTypeOption[] = [];\n  for (const d of input.contributions) {\n    if (!curated(d) || !dataGates(d)) continue;\n    const base = getPlotTypeDescriptor(d.baseType);\n    if (base && passesGates(base)) contributed.push(contributedPlotTypeOption(d, base));\n  }\n  // Default selector shows the suffix-free productionLabel; test mode keeps the full\n  // backend-suffixed label so same-named modes stay distinguishable.\n  const labelled = <T extends { label: string; productionLabel?: string }>(d: T): T =>\n    testMode ? d : { ...d, label: d.productionLabel! };\n  const shown = builtIn.map(labelled);\n  return { builtIn: shown, menu: [...shown, ...contributed.map(labelled)] };\n}\n\n/**\n * The type to fall back to when `selected` is no longer offered — Image when it is\n * on offer, else the first type still offered — or null when `selected` is still\n * offered (or nothing is). With no image loaded the pixel modes are gone, and falling\n * back to Image would select a mode the selector does not list and nothing can draw.\n */\nexport function reconcilePlotType(menu: PlotTypeOption[], selected: PlotTypeId): PlotTypeId | null {\n  if (menu.some((d) => d.type === selected)) return null;\n  if (menu.some((d) => d.type === PlotType.IMAGE)) return PlotType.IMAGE;\n  return menu[0]?.type ?? null;\n}\n"]}

package/esm2022/lib/plot-mode/tool-params-model.mjs

@@ -0,0 +1,87 @@
+/**
+ * Checkpoint choice and parameter values of the contributed no-prompt tools
+ * (`TOOLBAR_TOOLS`), and the generic parameter dialog over them.
+ *
+ * Values are seeded from the tool's defaults with the active checkpoint's own
+ * `ToolModelOption.defaults` on top — they encode the scale and crowding the
+ * checkpoint was trained for — lazily, on first use, and re-seeded when the
+ * checkpoint changes or the user resets.
+ */
+export class ToolParamsModel {
+    constructor(tools) {
+        this.tools = tools;
+        /** Active checkpoint per tool; replaced (not mutated) so the toolbar sees a new reference. */
+        this.toolModelIds = {};
+        /** Parameter values per tool. */
+        this.toolParams = {};
+        /** The open dialog, built once on open so change detection only reads properties. Null while closed. */
+        this.openParams = null;
+    }
+    /** A tool's current values, seeded on first use. */
+    paramsFor(toolId) {
+        const tool = this.find(toolId);
+        if (!tool)
+            return {};
+        // Through `seed`, never `defaultParams` directly: the first run must already
+        // carry the checkpoint's overrides, not only after a checkpoint switch.
+        this.toolParams[toolId] ??= this.seed(tool, this.modelIdFor(tool));
+        return this.toolParams[toolId];
+    }
+    /** Active checkpoint for a tool, falling back to the tool's own default. */
+    modelIdFor(tool) {
+        return this.toolModelIds[tool.id] ?? tool.defaultModelId();
+    }
+    /** Switching checkpoint re-seeds the parameters: the defaults belong to the model. */
+    setModel(toolId, modelId) {
+        const tool = this.find(toolId);
+        if (!tool)
+            return;
+        this.toolModelIds = { ...this.toolModelIds, [toolId]: modelId };
+        tool.onModelChange?.(modelId);
+        this.toolParams[toolId] = this.seed(tool, modelId);
+        this.rebind(toolId);
+    }
+    reset(toolId) {
+        const tool = this.find(toolId);
+        if (!tool)
+            return;
+        this.toolParams[toolId] = this.seed(tool, this.modelIdFor(tool));
+        this.rebind(toolId);
+    }
+    open(toolId) {
+        const tool = this.find(toolId);
+        if (!tool)
+            return;
+        this.openParams = {
+            tool,
+            values: this.paramsFor(toolId),
+            fields: tool.params.map((spec) => ({
+                spec,
+                number: spec.type === 'number' ? spec : null,
+                select: spec.type === 'select' ? spec : null,
+            })),
+        };
+    }
+    close() {
+        this.openParams = null;
+    }
+    /** The values to run a tool with: its parameters plus the active checkpoint. */
+    runParams(tool) {
+        return { ...this.paramsFor(tool.id), modelId: this.modelIdFor(tool) };
+    }
+    find(toolId) {
+        return this.tools.find((t) => t.id === toolId);
+    }
+    /** A tool's defaults for a checkpoint, with that checkpoint's own overrides on top. */
+    seed(tool, modelId) {
+        const model = tool.models().find((m) => m.id === modelId);
+        return { ...tool.defaultParams(modelId), ...(model?.defaults ?? {}) };
+    }
+    /** A tool's values object was replaced: point an open dialog for it at the new one. */
+    rebind(toolId) {
+        if (this.openParams?.tool.id === toolId) {
+            this.openParams = { ...this.openParams, values: this.paramsFor(toolId) };
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tool-params-model.js","sourceRoot":"","sources":["../../../../src/lib/plot-mode/tool-params-model.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  NumberParamSpec,\n  SelectParamSpec,\n  ToolParamSpec,\n  ToolbarToolContribution,\n} from '../contracts/toolbar-tool.contract';\n\n/** The open parameter dialog, as its template binds it. */\nexport interface OpenToolParams {\n  tool: ToolbarToolContribution;\n  /** The tool's live values; the dialog edits them in place. */\n  values: Record<string, unknown>;\n  /** Each field's spec, already narrowed for the template (an `*ngSwitchCase` does not\n   *  narrow a union in the template type checker). */\n  fields: { spec: ToolParamSpec; number: NumberParamSpec | null; select: SelectParamSpec | null }[];\n}\n\n/**\n * Checkpoint choice and parameter values of the contributed no-prompt tools\n * (`TOOLBAR_TOOLS`), and the generic parameter dialog over them.\n *\n * Values are seeded from the tool's defaults with the active checkpoint's own\n * `ToolModelOption.defaults` on top — they encode the scale and crowding the\n * checkpoint was trained for — lazily, on first use, and re-seeded when the\n * checkpoint changes or the user resets.\n */\nexport class ToolParamsModel {\n  /** Active checkpoint per tool; replaced (not mutated) so the toolbar sees a new reference. */\n  toolModelIds: Record<string, string> = {};\n  /** Parameter values per tool. */\n  toolParams: Record<string, Record<string, unknown>> = {};\n  /** The open dialog, built once on open so change detection only reads properties. Null while closed. */\n  openParams: OpenToolParams | null = null;\n\n  constructor(readonly tools: ToolbarToolContribution[]) {}\n\n  /** A tool's current values, seeded on first use. */\n  paramsFor(toolId: string): Record<string, unknown> {\n    const tool = this.find(toolId);\n    if (!tool) return {};\n    // Through `seed`, never `defaultParams` directly: the first run must already\n    // carry the checkpoint's overrides, not only after a checkpoint switch.\n    this.toolParams[toolId] ??= this.seed(tool, this.modelIdFor(tool));\n    return this.toolParams[toolId]!;\n  }\n\n  /** Active checkpoint for a tool, falling back to the tool's own default. */\n  modelIdFor(tool: ToolbarToolContribution): string {\n    return this.toolModelIds[tool.id] ?? tool.defaultModelId();\n  }\n\n  /** Switching checkpoint re-seeds the parameters: the defaults belong to the model. */\n  setModel(toolId: string, modelId: string): void {\n    const tool = this.find(toolId);\n    if (!tool) return;\n    this.toolModelIds = { ...this.toolModelIds, [toolId]: modelId };\n    tool.onModelChange?.(modelId);\n    this.toolParams[toolId] = this.seed(tool, modelId);\n    this.rebind(toolId);\n  }\n\n  reset(toolId: string): void {\n    const tool = this.find(toolId);\n    if (!tool) return;\n    this.toolParams[toolId] = this.seed(tool, this.modelIdFor(tool));\n    this.rebind(toolId);\n  }\n\n  open(toolId: string): void {\n    const tool = this.find(toolId);\n    if (!tool) return;\n    this.openParams = {\n      tool,\n      values: this.paramsFor(toolId),\n      fields: tool.params.map((spec) => ({\n        spec,\n        number: spec.type === 'number' ? spec : null,\n        select: spec.type === 'select' ? spec : null,\n      })),\n    };\n  }\n\n  close(): void {\n    this.openParams = null;\n  }\n\n  /** The values to run a tool with: its parameters plus the active checkpoint. */\n  runParams(tool: ToolbarToolContribution): Record<string, unknown> {\n    return { ...this.paramsFor(tool.id), modelId: this.modelIdFor(tool) };\n  }\n\n  find(toolId: string): ToolbarToolContribution | undefined {\n    return this.tools.find((t) => t.id === toolId);\n  }\n\n  /** A tool's defaults for a checkpoint, with that checkpoint's own overrides on top. */\n  private seed(tool: ToolbarToolContribution, modelId: string): Record<string, unknown> {\n    const model = tool.models().find((m) => m.id === modelId);\n    return { ...tool.defaultParams(modelId), ...(model?.defaults ?? {}) };\n  }\n\n  /** A tool's values object was replaced: point an open dialog for it at the new one. */\n  private rebind(toolId: string): void {\n    if (this.openParams?.tool.id === toolId) {\n      this.openParams = { ...this.openParams, values: this.paramsFor(toolId) };\n    }\n  }\n}\n"]}