@sjcrh/proteinpaint-server 2.85.1 → 2.86.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sjcrh/proteinpaint-server",
-  "version": "2.85.1",
+  "version": "2.86.0",
   "type": "module",
   "description": "a genomics visualization tool for exploring a cohort's genotype and phenotype data",
   "main": "src/app.js",
@@ -44,7 +44,7 @@
     "@babel/register": "^7.14.5",
     "@types/node": "^20.11.24",
     "@types/tough-cookie": "^4.0.5",
-    "@typescript-eslint/eslint-plugin": "^5.60.0",
+    "@typescript-eslint/eslint-plugin": "^8.13.0",
     "babel-loader": "^8.2.2",
     "esbuild": "^0.19.12",
     "glob": "^10.4.5",
@@ -55,16 +55,17 @@
     "ts-node": "^10.9.1",
     "ts-patch": "^3.0.2",
     "tsx": "^4.7.1",
-    "typedoc": "^0.24.8",
-    "typedoc-plugin-missing-exports": "^2.0.1",
+    "typedoc": "^0.26.11",
+    "typedoc-plugin-missing-exports": "^3.0.0",
+    "typedoc-plugin-replace-text": "^4.0.0",
     "typescript": "^5.6.3",
     "typia": "^4.1.14"
   },
   "dependencies": {
-    "@sjcrh/augen": "2.85.0",
+    "@sjcrh/augen": "2.86.0",
     "@sjcrh/proteinpaint-rust": "2.84.0",
-    "@sjcrh/proteinpaint-shared": "2.85.0",
-    "@sjcrh/proteinpaint-types": "2.85.0",
+    "@sjcrh/proteinpaint-shared": "2.86.0",
+    "@sjcrh/proteinpaint-types": "2.86.0",
     "better-sqlite3": "^9.4.1",
     "body-parser": "^1.15.2",
     "canvas": "~2.11.2",

package/routes/brainImaging.js

@@ -1,9 +1,9 @@
-import fs from "fs";
 import path from "path";
 import serverconfig from "#src/serverconfig.js";
 import { brainImagingPayload } from "#types";
 import { spawn } from "child_process";
 import { getData } from "../src/termdb.matrix.js";
+import { isNumericTerm } from "@sjcrh/proteinpaint-shared/terms.js";
 const api = {
   endpoint: "brainImaging",
   methods: {
@@ -38,8 +38,8 @@ function init({ genomes }) {
         plane = "T";
         index = query.t;
       }
-      const brainImage = await getBrainImage(query, genomes, plane, index);
-      res.send({ brainImage, plane });
+      const [brainImage, legend] = await getBrainImage(query, genomes, plane, index);
+      res.send({ brainImage, plane, legend });
     } catch (e) {
       console.log(e);
       res.status(404).send("Sample brain image not found");
@@ -53,7 +53,6 @@ async function getBrainImage(query, genomes, plane, index) {
   if (q[key].referenceFile && q[key].samples) {
     const refFile = path.join(serverconfig.tpmasterdir, q[key].referenceFile);
     const dirPath = path.join(serverconfig.tpmasterdir, q[key].samples);
-    const files = fs.readdirSync(dirPath).filter((file) => file.endsWith(".nii") && fs.statSync(path.join(dirPath, file)).isFile());
     const terms = [];
     const divideByTW = query.divideByTW;
     const overlayTW = query.overlayTW;
@@ -68,16 +67,34 @@ async function getBrainImage(query, genomes, plane, index) {
       const sampleId = ds.sampleName2Id.get(sampleName);
       const sampleData = data.samples[sampleId];
       const samplePath = path.join(dirPath, sampleName) + ".nii";
-      const divideCategory = divideByTW ? sampleData[divideByTW.$id].value : "default";
-      const overlayCategory = overlayTW ? sampleData[overlayTW.$id].value : "default";
+      let divideCategory = "default";
+      let overlayCategory = "default";
+      if (divideByTW) {
+        const value = sampleData[divideByTW.$id];
+        if (value)
+          divideCategory = divideByTW.term.values?.[value.key]?.label || value.key;
+      }
+      if (overlayTW) {
+        const value = sampleData[overlayTW.$id];
+        if (value)
+          overlayCategory = overlayTW.term.values?.[value.key]?.label || value.key;
+      }
       if (!divideByCat[divideCategory])
         divideByCat[divideCategory] = {};
-      if (!divideByCat[divideCategory][overlayCategory])
-        divideByCat[divideCategory][overlayCategory] = {
-          samples: [],
-          color: overlayTW?.term?.values?.[overlayCategory]?.color || "red"
-        };
-      divideByCat[divideCategory][overlayCategory].samples.push(samplePath);
+      if (!query.legendFilter?.includes(overlayCategory)) {
+        if (!divideByCat[divideCategory][overlayCategory]) {
+          let color = overlayTW?.term?.values?.[overlayCategory]?.color || "red";
+          if (overlayTW && isNumericTerm(overlayTW.term)) {
+            const bins = data.refs.byTermId[overlayTW.$id].bins;
+            color = bins.find((b) => b.label == overlayCategory).color;
+          }
+          divideByCat[divideCategory][overlayCategory] = {
+            samples: [],
+            color
+          };
+        }
+        divideByCat[divideCategory][overlayCategory].samples.push(samplePath);
+      }
     }
     const lengths = [];
     for (const dcategory in divideByCat)
@@ -87,25 +104,33 @@ async function getBrainImage(query, genomes, plane, index) {
       }
     const maxLength = Math.max(...lengths);
     const brainImageDict = {};
+    const legend = {};
     for (const dcategory in divideByCat) {
       let catNum = 0;
       const filesByCat = divideByCat[dcategory];
-      for (const category in filesByCat)
+      for (const category in filesByCat) {
+        if (filesByCat[category].samples.length < 1)
+          continue;
         catNum += filesByCat[category].samples.length;
+        if (!legend[category])
+          legend[category] = { color: filesByCat[category].color, maxLength };
+      }
       const url = await generateBrainImage(refFile, plane, index, maxLength, JSON.stringify(filesByCat));
       brainImageDict[dcategory] = { url, catNum };
     }
-    return brainImageDict;
+    if (query.legendFilter) {
+      for (const cat of query.legendFilter) {
+        legend[cat] = {
+          color: "white",
+          maxLength,
+          crossedOut: true
+        };
+      }
+    }
+    return [brainImageDict, legend];
   } else {
     throw "no reference or sample files";
   }
-  function getFilesByCat(tw) {
-    const filesByCat = {};
-    for (const [key2, value] of Object.entries(tw.term.values)) {
-      filesByCat[key2] = { samples: [], color: value.color || "red" };
-    }
-    return filesByCat;
-  }
 }
 async function generateBrainImage(refFile, plane, index, maxLength, filesJson) {
   return new Promise((resolve, reject) => {

package/routes/termdb.boxplot.js

@@ -2,6 +2,7 @@ import { boxplotPayload } from "#types";
 import { getData } from "../src/termdb.matrix.js";
 import { boxplot_getvalue } from "../src/utils.js";
 import { sortKey2values } from "../src/termdb.violin.js";
+import { roundValue } from "#shared/roundValue.js";
 const api = {
   endpoint: "termdb/boxplot",
   methods: {
@@ -26,8 +27,8 @@ function init({ genomes }) {
       if (!ds)
         throw "invalid ds";
       const terms = [q.tw];
-      if (q.divideTw)
-        terms.push(q.divideTw);
+      if (q.overlayTw)
+        terms.push(q.overlayTw);
       const data = await getData(
         {
           filter: q.filter,
@@ -41,19 +42,25 @@ function init({ genomes }) {
         throw data.error;
       const sampleType = `All ${data.sampleType?.plural_name || "samples"}`;
       const key2values = /* @__PURE__ */ new Map();
-      const overlayTerm = q.divideTw;
+      const overlayTerm = q.overlayTw;
+      const uncomputableValues = {};
       for (const val of Object.values(data.samples)) {
         const value = val[q.tw.$id];
         if (!Number.isFinite(value?.value))
           continue;
-        if (q.tw.term.values?.[value.value]?.uncomputable)
+        if (q.tw.term.values?.[value.value]?.uncomputable) {
+          const label = q.tw.term.values[value.value].label;
+          uncomputableValues[label] = (uncomputableValues[label] || 0) + 1;
           continue;
+        }
         if (overlayTerm) {
           if (!val[overlayTerm?.$id])
             continue;
           const value2 = val[overlayTerm.$id];
-          if (overlayTerm.term?.values?.[value2.key]?.uncomputable)
-            continue;
+          if (overlayTerm.term?.values?.[value2.key]?.uncomputable) {
+            const label = overlayTerm.term.values[value2?.key]?.label;
+            uncomputableValues[label] = (uncomputableValues[label] || 0) + 1;
+          }
           if (!key2values.has(value2.key))
             key2values.set(value2.key, []);
           key2values.get(value2.key).push(value.value);
@@ -64,49 +71,61 @@ function init({ genomes }) {
         }
       }
       const plots = [];
-      let absMin, absMax, maxLabelLgth;
+      let absMin = null, absMax = null, maxLabelLgth = null;
       for (const [key, values] of sortKey2values(data, key2values, overlayTerm)) {
         const sortedValues = values.sort((a, b) => a - b);
-        if (absMin === null || absMin === void 0 || sortedValues[0] < absMin)
+        if (absMin === null || sortedValues[0] < absMin)
           absMin = sortedValues[0];
-        if (absMax === null || absMax === void 0 || sortedValues[sortedValues.length - 1] > absMax)
+        if (absMax === null || sortedValues[sortedValues.length - 1] > absMax)
           absMax = sortedValues[sortedValues.length - 1];
         const vs = sortedValues.map((v) => {
           const value = { value: v };
           return value;
         });
+        const boxplot = boxplot_getvalue(vs);
+        if (!boxplot)
+          throw "boxplot_getvalue failed [termdb.boxplot init()]";
+        const descrStats = setDescrStats(boxplot, sortedValues);
         const _plot = {
-          // label,
           // values,
-          // plotValueCount: values.length
-          boxplot: boxplot_getvalue(vs),
-          min: sortedValues[0],
-          max: sortedValues[sortedValues.length - 1]
+          boxplot,
+          descrStats
         };
         if (overlayTerm) {
-          let label = overlayTerm?.term?.values?.[key]?.label || key;
-          label = `${label}, n=${values.length}`;
-          if (!maxLabelLgth || label.length > maxLabelLgth)
-            maxLabelLgth = label.length;
+          const _key = overlayTerm?.term?.values?.[key]?.label || key;
+          const plotLabel = `${_key}, n=${values.length}`;
+          if (maxLabelLgth === null || plotLabel.length > maxLabelLgth)
+            maxLabelLgth = plotLabel.length;
           const plot = Object.assign(_plot, {
-            seriesId: key,
-            color: overlayTerm?.term?.values?.[key]?.color || null
+            color: overlayTerm?.term?.values?.[key]?.color || null,
+            key: _key,
+            seriesId: key
           });
-          plot.boxplot.label = label;
+          plot.boxplot.label = plotLabel;
           plots.push(plot);
         } else {
-          const label = `${sampleType}, n=${values.length}`;
-          if (!maxLabelLgth || label.length > maxLabelLgth.length)
-            maxLabelLgth = label.length;
-          _plot.boxplot.label = label;
-          plots.push(_plot);
+          const plotLabel = `${sampleType}, n=${values.length}`;
+          if (maxLabelLgth === null || plotLabel.length > maxLabelLgth)
+            maxLabelLgth = plotLabel.length;
+          const plot = Object.assign(_plot, {
+            key: sampleType
+          });
+          plot.boxplot.label = plotLabel;
+          plots.push(plot);
         }
       }
+      if (absMin == null || absMax == null || maxLabelLgth == null)
+        throw "absMin, absMax, or maxLabelLgth is null [termdb.boxplot init()]";
+      if (q.tw.term?.values)
+        setUncomputablePlots(q.tw, plots);
+      if (overlayTerm && overlayTerm.term?.values)
+        setUncomputablePlots(overlayTerm, plots);
       const returnData = {
         absMin,
         absMax,
         maxLabelLgth,
-        plots
+        plots,
+        uncomputableValues: setUncomputableValues(uncomputableValues)
       };
       res.send(returnData);
     } catch (e) {
@@ -116,6 +135,42 @@ function init({ genomes }) {
     }
   };
 }
+function setUncomputablePlots(term, plots) {
+  for (const v of Object.values(term.term.values)) {
+    const plot = plots.find((p) => p.key === v.label);
+    if (plot)
+      plot.uncomputable = v.uncomputable;
+  }
+  return plots;
+}
+function setDescrStats(boxplot, sortedValues) {
+  const mean = sortedValues.reduce((s2, i) => s2 + i, 0) / sortedValues.length;
+  let s = 0;
+  for (const v of sortedValues) {
+    s += Math.pow(v - mean, 2);
+  }
+  const sd = Math.sqrt(s / (sortedValues.length - 1));
+  const squareDiffs = sortedValues.map((x) => (x - mean) ** 2).reduce((a, b) => a + b, 0);
+  const variance = squareDiffs / (sortedValues.length - 1);
+  return [
+    { id: "total", label: "Total", value: sortedValues.length },
+    { id: "min", label: "Minimum", value: roundValue(sortedValues[0], 2) },
+    { id: "p25", label: "1st quartile", value: roundValue(boxplot.p25, 2) },
+    { id: "median", label: "Median", value: roundValue(boxplot.p50, 2) },
+    { id: "mean", label: "Mean", value: roundValue(mean, 2) },
+    { id: "p75", label: "3rd quartile", value: roundValue(boxplot.p75, 2) },
+    { id: "max", label: "Maximum", value: roundValue(sortedValues[sortedValues.length - 1], 2) },
+    { id: "sd", label: "Standard deviation", value: isNaN(sd) ? null : roundValue(sd, 2) },
+    { id: "variance", label: "Variance", value: roundValue(variance, 2) },
+    { id: "iqr", label: "Inter-quartile range", value: roundValue(boxplot.iqr, 2) }
+  ];
+}
+function setUncomputableValues(values) {
+  if (Object.entries(values)?.length) {
+    return Object.entries(values).map(([label, v]) => ({ label, value: v }));
+  } else
+    return null;
+}
 export {
   api
 };