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

package/esm2022/lib/store/region-source-scope.mjs

@@ -0,0 +1,171 @@
+/** Sources held open, past which the least recently used one is closed (never the one shown). */
+export const OPEN_REGION_SOURCES = 6;
+const NONE = new Set();
+/**
+ * The region sources of every image the store has seen, per slice, and per slice the ids of
+ * the source features taken out of the source (into the working set, or deleted) — those the
+ * source no longer draws and an export leaves out.
+ *
+ * Sources open lazily, the first time their slice is shown or read, and at most
+ * {@link OPEN_REGION_SOURCES} stay open: the least recently used are closed and re-opened from
+ * their opener when used again (a source's ids are stable, so what was taken stays taken). The
+ * source of the slice on screen ({@link show}) is never closed for another: a read across every
+ * slice must not close the source the viewer draws and takes from.
+ */
+export class RegionSourceScope {
+    constructor() {
+        this.images = new Map();
+        /** Open entries, least recently used first. */
+        this.openOrder = [];
+        /** The entry of the slice on screen: kept open. */
+        this.shown = null;
+    }
+    /** Attach `open` to `image` for `slices`, replacing (and closing) what was there. */
+    attach(image, open, slices) {
+        const sources = this.imageSources(image);
+        const entry = { open, source: null, ready: null };
+        if (slices === 'planes') {
+            if (sources.planes)
+                this.close(sources.planes);
+            sources.planes = entry;
+            sources.perSlice.forEach((e) => this.close(e));
+            sources.perSlice.clear();
+            sources.taken.clear();
+        }
+        else {
+            const old = sources.perSlice.get(slices.slice);
+            if (old)
+                this.close(old);
+            entry.plane = slices.plane ?? 0;
+            sources.perSlice.set(slices.slice, entry);
+            sources.taken.delete(slices.slice);
+        }
+    }
+    /** Drop every source of `image` (closing the open ones) and what was taken from them. */
+    detachImage(image) {
+        const sources = this.images.get(image);
+        if (!sources)
+            return;
+        if (sources.planes)
+            this.close(sources.planes);
+        sources.perSlice.forEach((e) => this.close(e));
+        this.images.delete(image);
+    }
+    /** Drop the source of one slice of `image`. */
+    detachSlice(image, slice) {
+        const sources = this.images.get(image);
+        const entry = sources?.perSlice.get(slice);
+        if (!sources || !entry)
+            return;
+        this.close(entry);
+        sources.perSlice.delete(slice);
+        sources.taken.delete(slice);
+    }
+    /** The slice on screen (null: none): its source stays open while others are read. */
+    show(image, slice) {
+        this.shown = image && slice !== null ? this.entry(image, slice) : null;
+    }
+    /** Whether `image` has a source for `slice`. */
+    has(image, slice) {
+        return !!image && !!this.entry(image, slice);
+    }
+    /** Whether `slice` of `image` has a source of its own (not a `'planes'` source's plane). */
+    hasOwnSource(image, slice) {
+        return !!image && !!this.images.get(image)?.perSlice.has(slice);
+    }
+    /** Every slice of `image` with a source of its own (not counting a `'planes'` source). */
+    slicesWithSource(image) {
+        if (!image)
+            return [];
+        return Array.from(this.images.get(image)?.perSlice.keys() ?? []).sort((a, b) => a - b);
+    }
+    /** Whether `image` has one source over all its slices. */
+    hasPlanesSource(image) {
+        return !!image && !!this.images.get(image)?.planes;
+    }
+    /**
+     * The source behind `slice` of `image`, opening it if needed. Resolves null when there is
+     * none, and rejects when it cannot be opened.
+     */
+    async binding(image, slice) {
+        const entry = image ? this.entry(image, slice) : null;
+        if (!entry)
+            return null;
+        const source = await this.openEntry(entry);
+        return { source, plane: entry.plane ?? slice };
+    }
+    /** The ids taken from `slice`'s source. */
+    taken(image, slice) {
+        return (image && this.images.get(image)?.taken.get(slice)) || NONE;
+    }
+    /** Every id taken from any slice of `image` (a `'planes'` source's ids are unique across them). */
+    allTaken(image) {
+        const taken = image ? this.images.get(image)?.taken : undefined;
+        return taken ? Array.from(taken.values()).flatMap((ids) => Array.from(ids)) : [];
+    }
+    /** The slices of `image` with anything taken from their source. */
+    slicesWithTaken(image) {
+        const taken = image ? this.images.get(image)?.taken : undefined;
+        return taken ? Array.from(taken.keys()) : [];
+    }
+    /** Replace the ids taken from `slice`'s source (copy-on-write: `ids` is kept as given). */
+    setTaken(image, slice, ids) {
+        if (!image)
+            return;
+        const sources = this.images.get(image);
+        if (!sources)
+            return;
+        if (ids.size)
+            sources.taken.set(slice, ids);
+        else
+            sources.taken.delete(slice);
+    }
+    entry(image, slice) {
+        const sources = this.images.get(image);
+        return sources?.perSlice.get(slice) ?? sources?.planes ?? null;
+    }
+    imageSources(image) {
+        let sources = this.images.get(image);
+        if (!sources) {
+            sources = { planes: null, perSlice: new Map(), taken: new Map() };
+            this.images.set(image, sources);
+        }
+        return sources;
+    }
+    openEntry(entry) {
+        const at = this.openOrder.indexOf(entry);
+        if (at >= 0)
+            this.openOrder.splice(at, 1);
+        this.openOrder.push(entry);
+        if (!entry.source) {
+            const opening = entry.open();
+            entry.source = opening;
+            opening.then((source) => {
+                if (entry.source === opening)
+                    entry.ready = source;
+                else
+                    source.dispose(); // closed while it opened
+            }, () => {
+                if (entry.source === opening)
+                    entry.source = null; // try again next time
+            });
+        }
+        while (this.openOrder.length > OPEN_REGION_SOURCES) {
+            const [oldest] = this.openOrder.splice(this.openOrder.findIndex((e) => e !== this.shown), 1);
+            this.closeSource(oldest);
+        }
+        return entry.source;
+    }
+    close(entry) {
+        const at = this.openOrder.indexOf(entry);
+        if (at >= 0)
+            this.openOrder.splice(at, 1);
+        this.closeSource(entry);
+    }
+    closeSource(entry) {
+        entry.ready?.dispose();
+        entry.ready = null;
+        entry.source = null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"region-source-scope.js","sourceRoot":"","sources":["../../../../src/lib/store/region-source-scope.ts"],"names":[],"mappings":"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","sourcesContent":["import type { RegionSource } from '../region-source/region-source';\n\n/** Opens a region source on demand (and again after it was closed to save memory). */\nexport type RegionSourceOpener = () => Promise<RegionSource>;\n\n/** Which slices a source serves: one slice (plane `plane` of the source), or every slice z\n *  from the source's plane z (a z-indexed GeoJSON over a whole stack). */\nexport type RegionSourceSlices = { slice: number; plane?: number } | 'planes';\n\n/** The region source behind one slice: the source and which of its planes the slice shows. */\nexport interface RegionSourceBinding {\n  source: RegionSource;\n  plane: number;\n}\n\n/** Sources held open, past which the least recently used one is closed (never the one shown). */\nexport const OPEN_REGION_SOURCES = 6;\n\ninterface Entry {\n  open: RegionSourceOpener;\n  /** The plane each slice shows; undefined = the slice's own index. */\n  plane?: number;\n  source: Promise<RegionSource> | null;\n  /** The resolved source, once open. */\n  ready: RegionSource | null;\n}\n\ninterface ImageSources {\n  /** The source over every slice (`'planes'`), if any. */\n  planes: Entry | null;\n  perSlice: Map<number, Entry>;\n  /** Source feature ids taken into the working set (or deleted), per slice. */\n  taken: Map<number, ReadonlySet<string>>;\n}\n\nconst NONE: ReadonlySet<string> = new Set<string>();\n\n/**\n * The region sources of every image the store has seen, per slice, and per slice the ids of\n * the source features taken out of the source (into the working set, or deleted) — those the\n * source no longer draws and an export leaves out.\n *\n * Sources open lazily, the first time their slice is shown or read, and at most\n * {@link OPEN_REGION_SOURCES} stay open: the least recently used are closed and re-opened from\n * their opener when used again (a source's ids are stable, so what was taken stays taken). The\n * source of the slice on screen ({@link show}) is never closed for another: a read across every\n * slice must not close the source the viewer draws and takes from.\n */\nexport class RegionSourceScope {\n  private readonly images = new Map<string, ImageSources>();\n  /** Open entries, least recently used first. */\n  private readonly openOrder: Entry[] = [];\n  /** The entry of the slice on screen: kept open. */\n  private shown: Entry | null = null;\n\n  /** Attach `open` to `image` for `slices`, replacing (and closing) what was there. */\n  attach(image: string, open: RegionSourceOpener, slices: RegionSourceSlices): void {\n    const sources = this.imageSources(image);\n    const entry: Entry = { open, source: null, ready: null };\n    if (slices === 'planes') {\n      if (sources.planes) this.close(sources.planes);\n      sources.planes = entry;\n      sources.perSlice.forEach((e) => this.close(e));\n      sources.perSlice.clear();\n      sources.taken.clear();\n    } else {\n      const old = sources.perSlice.get(slices.slice);\n      if (old) this.close(old);\n      entry.plane = slices.plane ?? 0;\n      sources.perSlice.set(slices.slice, entry);\n      sources.taken.delete(slices.slice);\n    }\n  }\n\n  /** Drop every source of `image` (closing the open ones) and what was taken from them. */\n  detachImage(image: string): void {\n    const sources = this.images.get(image);\n    if (!sources) return;\n    if (sources.planes) this.close(sources.planes);\n    sources.perSlice.forEach((e) => this.close(e));\n    this.images.delete(image);\n  }\n\n  /** Drop the source of one slice of `image`. */\n  detachSlice(image: string, slice: number): void {\n    const sources = this.images.get(image);\n    const entry = sources?.perSlice.get(slice);\n    if (!sources || !entry) return;\n    this.close(entry);\n    sources.perSlice.delete(slice);\n    sources.taken.delete(slice);\n  }\n\n  /** The slice on screen (null: none): its source stays open while others are read. */\n  show(image: string | undefined, slice: number | null): void {\n    this.shown = image && slice !== null ? this.entry(image, slice) : null;\n  }\n\n  /** Whether `image` has a source for `slice`. */\n  has(image: string | undefined, slice: number): boolean {\n    return !!image && !!this.entry(image, slice);\n  }\n\n  /** Whether `slice` of `image` has a source of its own (not a `'planes'` source's plane). */\n  hasOwnSource(image: string | undefined, slice: number): boolean {\n    return !!image && !!this.images.get(image)?.perSlice.has(slice);\n  }\n\n  /** Every slice of `image` with a source of its own (not counting a `'planes'` source). */\n  slicesWithSource(image: string | undefined): number[] {\n    if (!image) return [];\n    return Array.from(this.images.get(image)?.perSlice.keys() ?? []).sort((a, b) => a - b);\n  }\n\n  /** Whether `image` has one source over all its slices. */\n  hasPlanesSource(image: string | undefined): boolean {\n    return !!image && !!this.images.get(image)?.planes;\n  }\n\n  /**\n   * The source behind `slice` of `image`, opening it if needed. Resolves null when there is\n   * none, and rejects when it cannot be opened.\n   */\n  async binding(image: string | undefined, slice: number): Promise<RegionSourceBinding | null> {\n    const entry = image ? this.entry(image, slice) : null;\n    if (!entry) return null;\n    const source = await this.openEntry(entry);\n    return { source, plane: entry.plane ?? slice };\n  }\n\n  /** The ids taken from `slice`'s source. */\n  taken(image: string | undefined, slice: number): ReadonlySet<string> {\n    return (image && this.images.get(image)?.taken.get(slice)) || NONE;\n  }\n\n  /** Every id taken from any slice of `image` (a `'planes'` source's ids are unique across them). */\n  allTaken(image: string | undefined): string[] {\n    const taken = image ? this.images.get(image)?.taken : undefined;\n    return taken ? Array.from(taken.values()).flatMap((ids) => Array.from(ids)) : [];\n  }\n\n  /** The slices of `image` with anything taken from their source. */\n  slicesWithTaken(image: string | undefined): number[] {\n    const taken = image ? this.images.get(image)?.taken : undefined;\n    return taken ? Array.from(taken.keys()) : [];\n  }\n\n  /** Replace the ids taken from `slice`'s source (copy-on-write: `ids` is kept as given). */\n  setTaken(image: string | undefined, slice: number, ids: ReadonlySet<string>): void {\n    if (!image) return;\n    const sources = this.images.get(image);\n    if (!sources) return;\n    if (ids.size) sources.taken.set(slice, ids);\n    else sources.taken.delete(slice);\n  }\n\n  private entry(image: string, slice: number): Entry | null {\n    const sources = this.images.get(image);\n    return sources?.perSlice.get(slice) ?? sources?.planes ?? null;\n  }\n\n  private imageSources(image: string): ImageSources {\n    let sources = this.images.get(image);\n    if (!sources) {\n      sources = { planes: null, perSlice: new Map(), taken: new Map() };\n      this.images.set(image, sources);\n    }\n    return sources;\n  }\n\n  private openEntry(entry: Entry): Promise<RegionSource> {\n    const at = this.openOrder.indexOf(entry);\n    if (at >= 0) this.openOrder.splice(at, 1);\n    this.openOrder.push(entry);\n    if (!entry.source) {\n      const opening = entry.open();\n      entry.source = opening;\n      opening.then(\n        (source) => {\n          if (entry.source === opening) entry.ready = source;\n          else source.dispose(); // closed while it opened\n        },\n        () => {\n          if (entry.source === opening) entry.source = null; // try again next time\n        },\n      );\n    }\n    while (this.openOrder.length > OPEN_REGION_SOURCES) {\n      const [oldest] = this.openOrder.splice(\n        this.openOrder.findIndex((e) => e !== this.shown),\n        1,\n      );\n      this.closeSource(oldest);\n    }\n    return entry.source;\n  }\n\n  private close(entry: Entry): void {\n    const at = this.openOrder.indexOf(entry);\n    if (at >= 0) this.openOrder.splice(at, 1);\n    this.closeSource(entry);\n  }\n\n  private closeSource(entry: Entry): void {\n    entry.ready?.dispose();\n    entry.ready = null;\n    entry.source = null;\n  }\n}\n"]}