plexora 0.0.1__py3-none-any.whl

plexora/client/src/js/services/dataLayer.js

@@ -0,0 +1,400 @@
+//todo add crossfilter stuff here... build some lensingFilters and sorters for individual and combined dimensions
+
+class DataLayer {
+
+    constructor(config, imageChannels) {
+        var that = this;
+        //vars and consts
+        this.config = config;
+        //all image channels
+        this.imageChannels = imageChannels;
+
+        this.imageBitRange = [0, 65536];
+        //selections
+        this.currentSelection = new Map();
+        // Roles, not literal column names -- see services/datasetContext.js.
+        // Null for an image-only project, and also for one whose coordinate
+        // columns nobody has identified yet; nothing needing real coordinates
+        // should be reachable in either case (callers check `schema` first).
+        this.schema = PlexoraDataset.resolveSchema(this.config);
+        this.x = this.schema?.x;
+        this.y = this.schema?.y;
+        this.phenotypes = [];
+    }
+
+    async init() {
+        try {
+            await fetch(plexoraUrl('init_database') + '?' + new URLSearchParams({
+                datasource: datasource
+            }))
+
+        } catch (e) {
+            console.log("Error Initializing Dataset", e);
+        }
+    }
+
+    async getRow(row) {
+        try {
+            let response = await fetch(plexoraUrl('get_database_row') + '?' + new URLSearchParams({
+                row: row,
+                datasource: datasource
+            }))
+            let response_data = await response.json();
+            return response_data;
+        } catch (e) {
+            console.log("Error Getting Row", e);
+        }
+    }
+
+    async getSavedChannelList() {
+        try {
+            let response = await fetch(plexoraUrl('get_saved_channel_list') + '?' + new URLSearchParams({
+                datasource: datasource
+            }))
+            let response_data = await response.json();
+            return response_data;
+        } catch (e) {
+            console.log("Error Getting Saved Channel List", e);
+        }
+    }
+
+    async saveChannelList(map_channels, active_channels, list_colors, list_ranges, list_channels) {
+        const self = this;
+        try {
+            let response = await fetch(plexoraUrl('save_channel_list'), {
+                method: 'POST',
+                headers: {
+                    'Accept': 'application/json',
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify(
+                    {
+                        datasource: datasource,
+                        map_channels: map_channels,
+                        active_channels: active_channels,
+                        list_colors: list_colors,
+                        list_ranges: list_ranges,
+                        list_channels: list_channels
+                    }
+                )
+            });
+            let response_data = await response.json();
+            return response_data;
+        } catch (e) {
+            console.log("Error Saving Channel List", e);
+        }
+    }
+
+    async getColumnDistributions(columns) {
+        try {
+            let response = await fetch(plexoraUrl('get_column_distributions') + '?' + new URLSearchParams({
+                columns: columns,
+                datasource: datasource
+            }))
+            let distributions = await response.json();
+            return distributions;
+        } catch (e) {
+            console.log("Error Getting Nearest Cell", e);
+        }
+    }
+
+    async submitChannelUpload(formData) {
+        try {
+            formData.append('datasource', datasource);
+            let response = await fetch(plexoraUrl('upload_channels'), {
+                method: "POST",
+                body: formData
+            })
+            let cell = await response.json();
+            return cell;
+        } catch (e) {
+            console.log("Error Getting Submitting Form Upload", e);
+        }
+    }
+
+    async getAllCells(start_keys, use_integer) {
+        const dtype = use_integer ? 'integer' : 'float'
+        const base_url = plexoraUrl(`get_all_cells/${dtype}/`) + '?'
+        try {
+            const headers = new Headers();
+            headers.append("Content-Type","application/octet-stream");
+            headers.append("Content-Encoding","gzip");
+            const response = await fetch(base_url + new URLSearchParams({
+                start_keys: start_keys,
+                datasource: datasource
+            }), {
+                headers: headers
+            })
+            return response.arrayBuffer();
+        } catch (e) {
+            console.log("Error Getting Gated Cell Ids", e);
+        }
+    }
+
+    async getCentroidManifest() {
+        try {
+            let response = await fetch(plexoraUrl('get_centroid_manifest') + '?' + new URLSearchParams({
+                datasource: datasource
+            }))
+            if (!response.ok) {
+                throw new Error(`Centroid manifest request failed: ${response.status}`);
+            }
+            const text = await response.text();
+            if (!text.trim().startsWith("{")) {
+                throw new Error("Centroid manifest response was not JSON");
+            }
+            return JSON.parse(text);
+        } catch (e) {
+            console.log("Error Getting Centroid Manifest", e);
+            return null;
+        }
+    }
+
+    async getCentroidTiles(level, tiles, filter = {}, maxPoints = 50000) {
+        try {
+            let response = await fetch(plexoraUrl('get_centroid_tiles'), {
+                method: 'POST',
+                headers: {
+                    'Accept': 'application/octet-stream',
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify(
+                    {
+                        datasource: datasource,
+                        level: level,
+                        tiles: tiles,
+                        filter: filter || {},
+                        max_points: maxPoints
+                    }
+                )
+            });
+            if (!response.ok) {
+                throw new Error(`Centroid tile request failed: ${response.status}`);
+            }
+            const contentType = response.headers.get("Content-Type") || "";
+            if (!contentType.includes("application/octet-stream")) {
+                throw new Error("Centroid tile response was not binary");
+            }
+            return response.arrayBuffer();
+        } catch (e) {
+            console.log("Error Getting Centroid Tiles", e);
+            return null;
+        }
+    }
+
+    async getDatabaseDescription() {
+        try {
+            let response = await fetch(plexoraUrl('get_database_description') + '?' + new URLSearchParams({
+                datasource: datasource
+            }))
+            let description = await response.json();
+            return description;
+        } catch (e) {
+            console.log("Error Getting DB Description", e);
+        }
+    }
+
+    async getSegmentationStatus() {
+        try {
+            let response = await fetch(plexoraUrl('get_segmentation_status') + '?' + new URLSearchParams({
+                datasource: datasource
+            }))
+            return await response.json();
+        } catch (e) {
+            console.log("Error Getting Segmentation Status", e);
+        }
+    }
+
+    async getChannelGMM(channel) {
+        try {
+            let response = await fetch(plexoraUrl('get_channel_gmm') + '?' + new URLSearchParams({
+                channel: channel,
+                datasource: datasource
+            }))
+            let packet_gmm = await response.json();
+            return packet_gmm;
+        } catch (e) {
+            console.log("Error Getting Channel GMM", e);
+        }
+    }
+
+    async getImageChannelStats(channel) {
+        try {
+            let response = await fetch(plexoraUrl('get_image_channel_stats') + '?' + new URLSearchParams({
+                channel: channel,
+                datasource: datasource
+            }))
+            return await response.json();
+        } catch (e) {
+            console.log("Error Getting Image Channel Stats", e);
+        }
+    }
+
+    async getChannelCellIds(sels) {
+        try {
+            let response = await fetch(plexoraUrl('get_channel_cell_ids') + '?' + new URLSearchParams({
+                filter: JSON.stringify(sels),
+                datasource: datasource
+            }))
+            let cellIds = await response.json();
+            return cellIds;
+        } catch (e) {
+            console.log("Error Getting Channel Cell Ids", e);
+        }
+    }
+
+    async getChannelNames(shortNames = true) {
+        try {
+            let response = await fetch(plexoraUrl('get_channel_names') + '?' + new URLSearchParams({
+                datasource: datasource,
+                shortNames: shortNames
+            }))
+            let response_data = await response.json();
+            return response_data;
+        } catch (e) {
+            console.log("Error Getting Sample Row", e);
+        }
+    }
+
+    async getNearestCell(point_x, point_y) {
+        try {
+            let response = await fetch(plexoraUrl('get_nearest_cell') + '?' + new URLSearchParams({
+                point_x: point_x,
+                point_y: point_y,
+                datasource: datasource
+            }))
+            let cell = await response.json();
+            return cell;
+        } catch (e) {
+            console.log("Error Getting Nearest Cell", e);
+        }
+    }
+
+
+    getCurrentSelection() {
+        return this.currentSelection;
+    }
+
+    clearCurrentSelection() {
+        this.currentSelection.clear();
+    }
+
+    getImageBitRange(float = false) {
+        const self = this;
+        if (!float) {
+            return self.imageBitRange;
+        } else {
+            return [0.0, 1.0];
+        }
+    }
+
+    addToCurrentSelection(item, allowDelete, clearPriors) {
+        // No real per-cell id field for a quick-view (no feature data)
+        // datasource -- nothing to key a selection by.
+        if (!this.schema) return;
+
+        // delete item on second click
+        if (allowDelete && this.currentSelection.has(item)) {
+            this.currentSelection.delete(item);
+            if (clearPriors) {
+                this.currentSelection.clear();
+            }
+
+            // console.log('current selection size:', this.currentSelection.size);
+            if (this.currentSelection.size > 0) {
+                // console.log('id: ', this.currentSelection.values().next().value.id);
+            }
+            return;
+        }
+
+        // clear previous items
+        if (clearPriors) {
+            this.currentSelection.clear();
+        }
+
+        // add new item
+        this.currentSelection.set(item[this.schema.cellId], item);
+
+        // console.log('current selection size:', this.currentSelection.size);
+        if (this.currentSelection.size > 0) {
+            // console.log('id: ', this.currentSelection.values().next().value.id);
+        }
+    }
+
+
+    addAllToCurrentSelection(items, allowDelete, clearPriors) {
+        // console.log("update current selection")
+        // No real per-cell id field for a quick-view (no feature data)
+        // datasource -- nothing to key a selection by.
+        if (!this.schema) return;
+        var that = this;
+        let idField = this.schema.cellId
+        that.currentSelection = new Map(items.map(i => [(i[idField]), i]));
+        // console.log("update current selection done")
+    }
+
+    isImageFeature(key) {
+        if (this.imageChannels.hasOwnProperty(key)
+            && key != 'CellId' && key != 'id' && key != 'CellID' && key != 'ID' && key != 'Area') {
+            return true;
+        }
+        return false;
+    }
+
+    getShortChannelName(fullname) {
+        var shortname = fullname;
+        this.config["imageData"].forEach(function (channel) {
+            if (channel.fullname == fullname) {
+                shortname = channel.name;
+            }
+        });
+        return shortname;
+    }
+
+    getFullChannelName(shortname) {
+        var fullname = shortname;
+        this.config["imageData"].forEach(function (channel) {
+            if (channel.name == shortname) {
+                fullname = channel.fullname;
+            }
+        });
+        return fullname;
+    }
+
+    async getMetadata() {
+        try {
+            let response = await fetch(plexoraUrl('get_ome_metadata') + '?' + new URLSearchParams({
+                datasource: datasource
+            }))
+            let response_data = await response.json();
+            return response_data;
+        } catch (e) {
+            console.log("Error Getting Metadata", e);
+        }
+    }
+
+    /**
+     * Decimal-place precision for gate slider rounding, derived from the
+     * channel's own observed [min, max] span rather than a stored config
+     * flag -- aims for ~200 distinguishable steps across the range. Wide
+     * integer-scale channels (e.g. raw 0-65535 pixel intensities) land on 0
+     * decimals (whole-number gates); narrow float-scale channels (e.g.
+     * already log/arcsinh-transformed markers spanning ~1.7-2.2) get enough
+     * decimal places to stay meaningful. Replaces the old
+     * dataset.isTransformed flag, which had to be set correctly
+     * (and consistently across datasources built from the same source data)
+     * at import time and silently broke gating whenever it didn't match the
+     * data's actual scale -- this is instead computed fresh from the same
+     * min/max every request already returns, so it can't drift out of sync.
+     * @param {number[]} range - [min, max] of the channel being gated
+     * @returns {number}
+     */
+    gateDecimals(range) {
+        const span = Math.abs(((range && range[1]) || 0) - ((range && range[0]) || 0));
+        if (!Number.isFinite(span) || span <= 0) return 0;
+        const decimals = Math.ceil(Math.log10(200 / span));
+        return Math.max(0, Math.min(6, decimals));
+    }
+
+
+}

plexora/client/src/js/services/datasetContext.js

@@ -0,0 +1,143 @@
+/**
+ * datasetContext.js - the dataset a plugin is handed, client-side.
+ *
+ * Mirrors plexora/api/dataset.py so a plugin sees the same shape on both
+ * sides: image data always, segmentation and a feature table when the project
+ * has them, and a role->column map read from the project record.
+ *
+ * The point is that plugins read ROLES, not column names. `schema.x` resolves
+ * to whatever the project recorded for the x role; a plugin that hardcodes
+ * "X_centroid" breaks on the next dataset. Roles this version has no field for
+ * survive in `extra`, so adding one later needs no plugin change.
+ *
+ * It also replaces the bare globals plugins used to reach for. csvGatingList
+ * read `imageChannels`, `datasource` and `__plexora` straight off window,
+ * which meant core could not rename or scope any of them, and a plugin loaded
+ * out of order got undefined rather than an error.
+ */
+window.PlexoraDataset = (function () {
+    // Role name on the wire -> the camelCase name plugins read. The record
+    // stores roles under one explicit key (server/models/project.py's
+    // ROLE_NAMES), so unlike the old shape there is no alias list and no
+    // denylist -- a role can no longer be confused with a file path or a
+    // processing flag, because they are not in the same dict any more.
+    const ROLE_KEYS = {
+        cell_id: "cellId",
+        x: "x",
+        y: "y",
+        celltype: "celltype",
+        image_id: "imageId",
+    };
+
+    function resolveSchema(config) {
+        const spec = config.dataset;
+        if (!spec) return null;
+        const roles = spec.roles || {};
+        const schema = { extra: {} };
+        for (const [wire, name] of Object.entries(ROLE_KEYS)) {
+            schema[name] = roles[wire] || null;
+        }
+        // A role the record has learned but this version has no field for
+        // still reaches plugins, so adding one needs no client change.
+        for (const [wire, value] of Object.entries(roles)) {
+            if (!ROLE_KEYS[wire] && typeof value === "string") schema.extra[wire] = value;
+        }
+        return schema;
+    }
+
+    /**
+     * @param config - this datasource's /config entry
+     * @param imageChannels - fullname -> index lookup built by main.js
+     * @param databaseDescription - per-column stats, or {} before it arrives
+     */
+    function build(config, imageChannels, databaseDescription = {}) {
+        const schema = resolveSchema(config);
+
+        // Reserved columns are numeric but are not markers. Kept in step with
+        // the server's TableHandle.markers, which likewise reports only
+        // columns a histogram could be built for.
+        const reserved = new Set(["id"]);
+        [schema?.cellId, schema?.x, schema?.y].forEach((c) => c && reserved.add(c));
+
+        return {
+            name: config.name || window.datasource,
+            image: {
+                channels: (config.imageData || []).filter((c) => c.fullname !== "Area"),
+                get channelNames() {
+                    return this.channels.map((c) => c.fullname);
+                },
+                kind: config.image_kind || null,
+                index: imageChannels || {},
+                /** Whether a marker name is also a real image channel. */
+                has(fullName) {
+                    return (imageChannels || {})[fullName] !== undefined;
+                },
+            },
+            // Getters, not values: a mask whose pyramid was still building when
+            // the page opened is adopted in place when the job lands (main.js's
+            // adoptSegmentation), and a plugin holding this object from before
+            // that would otherwise go on being told there is no mask.
+            segmentation: {
+                get available() {
+                    return Boolean(config.segmentation);
+                },
+                get pending() {
+                    return config.segmentation_status === "pending";
+                },
+            },
+            table: {
+                // No dataset block IS the image-only state; there is no
+                // separate flag that could disagree with it.
+                available: Boolean(config.dataset),
+                sourceKind: config.dataset?.type || "csv",
+                describe: databaseDescription,
+                /**
+                 * Columns a plugin can threshold or plot -- the classification
+                 * the project recorded at import, so every plugin sees the same
+                 * answer. Deliberately not image.channelNames: a structural
+                 * channel like DNA is a real image channel with no feature
+                 * column, and conflating the two has caused bugs here.
+                 *
+                 * Narrowed to columns the server could describe, because that
+                 * is what "can be thresholded" actually means: a gate needs a
+                 * range and a histogram to draw, and a recorded marker the
+                 * loaded table no longer holds has neither.
+                 *
+                 * The derivation is the fallback, not the answer. It cannot
+                 * tell a stain from a measurement -- Area and Eccentricity are
+                 * as numeric as CD3 is, and in a CSV they sit in the same
+                 * header, which is the entire reason the import step asks. It
+                 * covers a project whose columns were never classified; better
+                 * a usable guess than an empty panel.
+                 */
+                get markers() {
+                    const describable = (column) => Boolean(databaseDescription[column]?.histogram);
+                    const recorded = (config.dataset?.columns?.markers || []).filter(describable);
+                    if (recorded.length) return recorded;
+                    return Object.keys(databaseDescription).filter(
+                        (column) => !reserved.has(column) && describable(column)
+                    );
+                },
+                get metadataColumns() {
+                    return [...(config.dataset?.columns?.metadata || [])];
+                },
+            },
+            schema,
+        };
+    }
+
+    /**
+     * Whether this project has per-cell positions to draw.
+     *
+     * Not the same question as "has a feature table": a table whose coordinate
+     * columns nobody has identified yet has no positions either, and the
+     * server's centroid manifest reports `missing` for both cases. Callers use
+     * it to skip a centroid round trip that was never going to return points.
+     */
+    function hasCentroids(config) {
+        const roles = config?.dataset?.roles;
+        return Boolean(roles && roles.x && roles.y);
+    }
+
+    return { build, resolveSchema, hasCentroids };
+})();

plexora/client/src/js/services/glRenderer.js

@@ -0,0 +1,143 @@
+/**
+ * WebGL2 tile-colorization engine.
+ *
+ * Deliberately OpenSeadragon-independent: this module is only the WebGL
+ * rendering engine, so the app can run against upstream OpenSeadragon rather
+ * than a fork pinned to a patched commit. The OpenSeadragon integration
+ * (tile-loaded/tile-drawing wiring) lives in imageViewer.js rather than a
+ * separate glue class, since imageViewer.js already overrides most of that
+ * layer's behavior.
+ */
+export class GLRenderer {
+    constructor(incoming) {
+        // Custom hook points, callable via `this['gl-drawing']`/`this['gl-loaded']`
+        this['gl-drawing'] = function (e) { return e; };
+        this['gl-loaded'] = function (e) { return e; };
+
+        // Vertex input buffer describing a full-canvas quad
+        this.one_point_size = 2 * Float32Array.BYTES_PER_ELEMENT;
+        this.points_list_size = 4 * this.one_point_size;
+        this.points_buffer = new Float32Array([
+            0, 1, 0, 0, 1, 1, 1, 0,
+        ]);
+
+        // Offscreen WebGL2 context and texture/buffer handles
+        this.gl = document.createElement('canvas').getContext('webgl2');
+        this.texture = this.gl.createTexture();
+        this.buffer = this.gl.createBuffer();
+
+        // Placeholder defaults, overwritten by the caller before init()
+        this.vShader = 'vShader.glsl';
+        this.fShader = 'fShader.glsl';
+        this.height = 0;
+        this.width = 0;
+
+        for (const key in incoming) {
+            this[key] = incoming[key];
+        }
+    }
+
+    init() {
+        const step = [[this.vShader, this.fShader].map(this.getter)];
+        step.push(this.toProgram.bind(this), this.toBuffers.bind(this));
+        return Promise.all(step[0]).then(step[1]).then(step[2]);
+    }
+
+    updateShape(width, height) {
+        this.width = width;
+        this.height = height;
+        this.gl.canvas.width = width;
+        this.gl.canvas.height = height;
+        this.gl.viewport(0, 0, width, height);
+    }
+
+    // Fetch a shader source file (or pass through a non-.glsl value unchanged)
+    getter(where) {
+        return new Promise((done) => {
+            if (where.slice(-4) != 'glsl') {
+                return done(where);
+            }
+            const bid = new XMLHttpRequest();
+            const win = function () {
+                if (bid.status == 200) {
+                    return done(bid.response);
+                }
+                return done(where);
+            };
+            bid.open('GET', where, true);
+            bid.setRequestHeader('Cache-Control', 'no-cache, no-store, max-age=0');
+            bid.onerror = bid.onload = win;
+            bid.send();
+        });
+    }
+
+    // Compile and link the vertex/fragment shader pair
+    toProgram(files) {
+        const gl = this.gl;
+        const program = gl.createProgram();
+        const ok = function (kind, status, value, sh) {
+            if (!gl['get' + kind + 'Parameter'](value, gl[status + '_STATUS'])) {
+                console.log((sh || 'LINK') + ':\n' + gl['get' + kind + 'InfoLog'](value));
+            }
+            return value;
+        };
+        files.map((given, i) => {
+            const sh = ['VERTEX_SHADER', 'FRAGMENT_SHADER'][i];
+            const shader = gl.createShader(gl[sh]);
+            gl.shaderSource(shader, given);
+            gl.compileShader(shader);
+            gl.attachShader(program, shader);
+            ok('Shader', 'COMPILE', shader, sh);
+        });
+        gl.linkProgram(program);
+        return ok('Program', 'LINK', program);
+    }
+
+    // Bind the quad buffer, texture parameters, and uniforms
+    toBuffers(program) {
+        const gl = this.gl;
+        gl.useProgram(program);
+        this['gl-loaded'].call(this, program);
+
+        const u_tile = gl.getUniformLocation(program, 'u_tile');
+        const a_uv = gl.getAttribLocation(program, 'a_uv');
+        const u8 = gl.getUniformLocation(program, 'u8');
+
+        gl.uniform1ui(u8, 255);
+        gl.uniform1i(u_tile, 0);
+
+        gl.bindBuffer(gl.ARRAY_BUFFER, this.buffer);
+        gl.bufferData(gl.ARRAY_BUFFER, this.points_buffer, gl.STATIC_DRAW);
+
+        gl.enableVertexAttribArray(a_uv);
+        gl.vertexAttribPointer(a_uv, 2, gl.FLOAT, 0, this.one_point_size, 0 * this.points_list_size);
+
+        gl.activeTexture(gl.TEXTURE0);
+        gl.bindTexture(gl.TEXTURE_2D, this.texture);
+        gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, 1);
+        gl.pixelStorei(gl.UNPACK_ALIGNMENT, 1);
+
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+    }
+
+    // Default single-texture draw path. imageViewer.js overrides this with
+    // its own multi-texture-cache implementation; kept here for fidelity/reuse.
+    loadArray(width, height, pixels, format = 'u16') {
+        this['gl-drawing'].call(this);
+        const gl = this.gl;
+
+        if (format == 'u16') {
+            gl.texImage2D(gl.TEXTURE_2D, 0, gl.RG8UI, width, height, 0, gl.RG_INTEGER, gl.UNSIGNED_BYTE, pixels);
+        } else if (format == 'u32') {
+            gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA8UI, width, height, 0, gl.RGBA_INTEGER, gl.UNSIGNED_BYTE, pixels);
+        } else if (format == 'u8') {
+            gl.texImage2D(gl.TEXTURE_2D, 0, gl.R8UI, width, height, 0, gl.RED_INTEGER, gl.UNSIGNED_BYTE, pixels);
+        }
+
+        gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+        return this.gl.canvas;
+    }
+}