@sjcrh/proteinpaint-server 2.189.0 → 2.190.1

package/routes/termdb.singleCellPlots.js

@@ -0,0 +1,159 @@
+import { getColors, getCoordinate, calculatePadding, xAxisOffSet, yAxisOffSet } from "#shared";
+import { isSingleCellTerm, SINGLECELL_GENE_EXPRESSION, SINGLECELL_CELLTYPE } from "#shared/terms.js";
+import { createCanvas } from "canvas";
+import { scaleLinear } from "d3-scale";
+import { rgb } from "d3-color";
+import { refColor } from "./termdb.sampleScatter.js";
+function init({ genomes }) {
+  return async function(req, res) {
+    try {
+      const q = req.query;
+      if (!q.genome || !q.dslabel) {
+        throw new Error("Genome and dataset label are required for termdb/singleCellPlots request.");
+      }
+      const g = genomes[q.genome];
+      if (!g) throw new Error("Invalid genome name");
+      const ds = g.datasets[q.dslabel];
+      if (!ds) throw new Error("Invalid dataset label");
+      if (!ds.queries?.singleCell) throw new Error("No single cell data on this dataset");
+      return getSingleCellScatter(req, res, ds);
+    } catch (err) {
+      console.error(err);
+      res.status(500).json({ error: err.message || String(err) });
+    }
+  };
+}
+async function getSingleCellScatter(req, res, ds) {
+  const q = req.query;
+  const { name, sample } = q.singleCellPlot;
+  try {
+    const tw = q.colorTW;
+    if (!tw || !isSingleCellTerm(tw.term))
+      throw new Error("colorTW must be provided and be a single cell term for single cell scatter plot");
+    const arg = { plots: [name], sample };
+    if (tw.term.type == SINGLECELL_GENE_EXPRESSION) arg.gene = tw.term.gene;
+    else if (tw.term.type == SINGLECELL_CELLTYPE) arg.colorBy = tw.term.name;
+    else throw new Error(`unsupported single cell term type: ${tw.term.type}`);
+    const data = await ds.queries.singleCell.data.get(arg);
+    const plot = data.plots[0];
+    const cells = [...plot.expCells, ...plot.noExpCells];
+    const groups = tw.q?.customset?.groups;
+    const cat2GrpName = /* @__PURE__ */ new Map();
+    if (groups) {
+      for (const group of groups) {
+        for (const value of Object.values(group.values)) {
+          cat2GrpName.set(value.key, group.name);
+        }
+      }
+    }
+    const samples = [];
+    const categoryCounts = /* @__PURE__ */ new Map();
+    let xMin = Infinity, xMax = -Infinity, yMin = Infinity, yMax = -Infinity, geMin = Infinity, geMax = -Infinity;
+    let totalCellCount = 0;
+    for (const cell of cells) {
+      let category = cell.category;
+      const groupName = cat2GrpName.get(category);
+      if (groupName !== void 0) category = groupName;
+      const isHidden = tw?.q?.hiddenValues ? category in tw.q.hiddenValues : false;
+      totalCellCount++;
+      categoryCounts.set(category, (categoryCounts.get(category) || 0) + 1);
+      if (cell.x < xMin) xMin = cell.x;
+      if (cell.x > xMax) xMax = cell.x;
+      if (cell.y < yMin) yMin = cell.y;
+      if (cell.y > yMax) yMax = cell.y;
+      if (Number.isFinite(cell.geneExp) && cell.geneExp < geMin) geMin = cell.geneExp;
+      if (Number.isFinite(cell.geneExp) && cell.geneExp > geMax) geMax = cell.geneExp;
+      if (isHidden) continue;
+      samples.push({
+        sampleId: cell.cellId,
+        x: cell.x,
+        y: cell.y,
+        z: 0,
+        category,
+        shape: "Ref",
+        hidden: { category: false },
+        geneExp: cell.geneExp
+      });
+    }
+    const colorMap = {};
+    if (tw.term.type == SINGLECELL_CELLTYPE) {
+      const defaultK2c = getColors(categoryCounts.size);
+      const dsTerm = ds.queries.singleCell?.terms ? ds.queries.singleCell.terms.find((t) => t.name == tw.term.name) : void 0;
+      for (const [category, count] of categoryCounts) {
+        const color = tw.term.values?.[category]?.color || dsTerm?.values?.[category]?.color || defaultK2c(category);
+        colorMap[category] = { sampleCount: count, color, key: category };
+      }
+    }
+    const shapeLegend = [["Ref", { sampleCount: totalCellCount, shape: 0, key: "Ref" }]];
+    const colorLegend = Object.entries(colorMap);
+    const output = {
+      range: { xMin, xMax, yMin, yMax, geMin, geMax },
+      //There should only be one chart
+      result: { Default: { colorLegend, shapeLegend } }
+    };
+    if (totalCellCount >= q.canvasSettings.cutoff) {
+      const { src, canvasWidth, canvasHeight } = await makeCanvas(
+        q,
+        samples,
+        colorMap,
+        { xMin, xMax, yMin, yMax, geMin, geMax },
+        tw.term.type
+      );
+      output.result.Default.src = src;
+      output.result.Default.canvasWidth = canvasWidth;
+      output.result.Default.canvasHeight = canvasHeight;
+      output.result.Default.totalSampleCount = totalCellCount;
+    } else {
+      output.result.Default.samples = samples;
+    }
+    res.send(output);
+  } catch (e) {
+    console.log(e);
+    res.send({ error: e.message || e });
+  }
+}
+async function makeCanvas(q, samples, colorMap, range, termType) {
+  const settings = q.canvasSettings;
+  const dpr = settings.devicePixelRatio || 1;
+  const extraSpaceX = calculatePadding(settings.minXScale, settings.maxXScale, range.xMin, range.xMax);
+  const extraSpaceY = calculatePadding(settings.minYScale, settings.maxYScale, range.yMin, range.yMax);
+  const width = settings.width + xAxisOffSet + extraSpaceX + 20;
+  const height = settings.height + yAxisOffSet + extraSpaceY + 20;
+  const canvas = createCanvas(width * dpr, height * dpr);
+  const ctx = canvas.getContext("2d");
+  if (dpr > 1) ctx.scale(dpr, dpr);
+  const xScale = scaleLinear().domain([range.xMin - extraSpaceX, range.xMax + extraSpaceX]).range([xAxisOffSet, settings.width + xAxisOffSet]);
+  const yScale = scaleLinear().domain([range.yMax + extraSpaceY, range.yMin - extraSpaceY]).range([yAxisOffSet, settings.height + yAxisOffSet]);
+  let colorGenerator;
+  if (Number.isFinite(range.geMin) && Number.isFinite(range.geMax)) {
+    colorGenerator = scaleLinear().domain([range.geMin, range.geMax]).range([settings.startColor, settings.stopColor]);
+  }
+  const color = (sample) => {
+    if (termType == SINGLECELL_GENE_EXPRESSION) {
+      if (!Number.isFinite(sample.geneExp)) return settings.startColor;
+      else if (sample.geneExp > range.geMax) return settings.stopColor;
+      else return colorGenerator(sample.geneExp);
+    }
+    return colorMap[sample.category] ? colorMap[sample.category].color : refColor;
+  };
+  const x = (sample) => {
+    const tmp = getCoordinate(sample.x, settings.minXScale, settings.maxXScale);
+    return xScale(tmp);
+  };
+  const y = (sample) => {
+    const tmp = getCoordinate(sample.y, settings.minYScale, settings.maxYScale);
+    return yScale(tmp);
+  };
+  for (const sample of samples) {
+    const c = rgb(color(sample));
+    c.opacity = settings.opacity;
+    ctx.fillStyle = c.toString();
+    ctx.beginPath();
+    ctx.arc(x(sample), y(sample), settings.radius, 0, Math.PI * 2);
+    ctx.fill();
+  }
+  return { src: canvas.toDataURL(), canvasWidth: width, canvasHeight: height };
+}
+export {
+  init
+};

package/routes/termdb.singlecellSamples.js

@@ -5,24 +5,10 @@ import { mayLog } from "#src/helpers.ts";
 import { joinUrl } from "#shared/joinUrl.js";
 import { run_rust } from "@sjcrh/proteinpaint-rust";
 import serverconfig from "#src/serverconfig.js";
-import { termdbSingleCellSamplesPayload } from "#types/checkers";
-import { validate_query_singleCell_DEgenes } from "./termdb.singlecellDEgenes.ts";
+import { validate_query_singleCell_DEgenes } from "../src/routes/termdb.singlecellDEgenes.ts";
 import { gdc_validate_query_singleCell_data } from "#src/mds3.gdc.js";
 import ky from "ky";
 import { SINGLECELL_CELLTYPE } from "#shared/terms.js";
-const api = {
-  endpoint: "termdb/singlecellSamples",
-  methods: {
-    get: {
-      ...termdbSingleCellSamplesPayload,
-      init
-    },
-    post: {
-      ...termdbSingleCellSamplesPayload,
-      init
-    }
-  }
-};
 function init({ genomes }) {
   return async (req, res) => {
     const q = req.query;
@@ -151,6 +137,10 @@ function validateDataNative(D, ds) {
       const plots2 = [];
       for (const plot of D.plots) {
         if (!q.plots.includes(plot.name)) continue;
+        if (plot.isMetaResult) {
+          const sampleName = plot?.sampleId || plot.name.replace(/\s/g, "_");
+          if (sampleName != sampleId) continue;
+        }
         const tsvfile = path.join(serverconfig.tpmasterdir, plot.folder, sampleId + (plot.fileSuffix || ""));
         try {
           await file_is_readable(tsvfile);
@@ -317,6 +307,6 @@ function colorColumn2terms(plots, ds) {
   ds.queries.singleCell.terms = [...termSet];
 }
 export {
-  api,
+  init,
   validate_query_singleCell
 };

package/routes/termdb.violinBox.js

@@ -1,4 +1,3 @@
-import { violinBoxPayload } from "#types/checkers";
 import { scaleLinear, scaleLog } from "d3";
 import { run_rust } from "@sjcrh/proteinpaint-rust";
 import { run_R } from "@sjcrh/proteinpaint-r";
@@ -10,19 +9,6 @@ import { isNumericTerm } from "#shared/terms.js";
 import { boxplot_getvalue } from "../src/utils.js";
 import { roundValueAuto } from "#shared/roundValue.js";
 import { mayLog } from "#src/helpers.ts";
-const api = {
-  endpoint: "termdb/violinBox",
-  methods: {
-    get: {
-      ...violinBoxPayload,
-      init
-    },
-    post: {
-      ...violinBoxPayload,
-      init
-    }
-  }
-};
 function init({ genomes }) {
   return async (req, res) => {
     const q = req.query;
@@ -535,7 +521,6 @@ function numericBins(tw, data) {
   return bins;
 }
 export {
-  api,
   buildBins,
   computeSampleType,
   divideValues,
@@ -544,6 +529,7 @@ export {
   getDensities,
   getDensity,
   getViolinWilcoxonData,
+  init,
   numericBins,
   parseValues,
   setHiddenPlots,

package/routes/wsimages.js

@@ -3,25 +3,10 @@ import qs from "qs";
 import path from "path";
 import { CookieJar } from "tough-cookie";
 import { promisify } from "util";
-import { wsImagesPayload } from "#types/checkers";
 import SessionManager from "../src/wsisessions/SessionManager.ts";
 import { ShardManager } from "#src/sharding/ShardManager.ts";
 import { TileServerShardingAlgorithm } from "#src/sharding/TileServerShardingAlgorithm.ts";
 import serverconfig from "#src/serverconfig.js";
-const routePath = "wsimages";
-const api = {
-  endpoint: `${routePath}`,
-  methods: {
-    get: {
-      ...wsImagesPayload,
-      init
-    },
-    post: {
-      ...wsImagesPayload,
-      init
-    }
-  }
-};
 function init({ genomes }) {
   return async (req, res) => {
     try {
@@ -187,5 +172,5 @@ function getHooks(cookieJar, getCookieString, setCookie) {
   };
 }
 export {
-  api
+  init
 };