wellerlab 0.1.0__py3-none-any.whl

wellerlab/__init__.py

@@ -0,0 +1,17 @@
+"""
+WellerLab — the complete Orange3 tool suite of the Weller lab.
+
+One distribution, one Orange category ("Weller Lab"):
+
+    wellerlab.metabo  MetaboAnalyst-style feature-table statistics
+                      (import, preprocess, filter, univariate, heatmap, volcano)
+    wellerlab.plsda   PLS-DA and OPLS-DA (S-plot, VIP, Q2, permutation)
+    wellerlab.pca     PCA Pro
+    wellerlab.nmr     NMR preprocessing (baseline, binning, exclusion,
+                      filter, normalization, reference)
+
+The numerical cores (``metabo.metabo_core``, ``plsda.opls_core``) are free of
+Qt/Orange and can be imported and tested headlessly.
+"""
+
+__version__ = "0.1.0"

wellerlab/metabo/__init__.py

@@ -0,0 +1,3 @@
+"""wellerlab.metabo — MetaboAnalyst-style add-on for Orange3."""
+
+__version__ = "0.4.4"

wellerlab/metabo/metabo_core.py

@@ -0,0 +1,282 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+MetaboAnalyst-style univariate statistics core for GC-MS / GC-IMS
+feature tables (Compound Discoverer exports).
+
+This module is the analytics heart of the wellerlab.metabo add-on. It is
+deliberately free of any Qt / Orange dependency so it can be unit-tested
+headlessly with plain numpy/scipy. The widgets in `orangemetabo/widgets/`
+are thin GUI wrappers around the functions here.
+
+Pipeline (matches the validated ground truth `cv_anova_alle_97_features.csv`,
+97/97 features on F, p and FDR_BH):
+
+    load -> sum-normalise -> log2 -> autoscale (z-score per feature)
+         -> univariate statistics (one-way ANOVA / Welch t / Kruskal-Wallis)
+         -> Benjamini-Hochberg FDR
+
+All functions are pure: they take arrays / lists and return DataFrames or
+arrays. No file I/O except the optional `load_feature_table` reader.
+"""
+import csv
+import numpy as np
+import pandas as pd
+from scipy import stats
+
+
+# --------------------------------------------------------------------------
+# Feature-table reader (Compound Discoverer 2-header semicolon CSV)
+# --------------------------------------------------------------------------
+
+def load_feature_table(path):
+    """Read a Compound Discoverer feature-table CSV.
+
+    Expected layout (semicolon-separated, UTF-8-BOM):
+      row 0: "" , "Area: <sample>.raw", ...
+      row 1: "" , "<group>",           ...
+      row 2+: "<feature name>", values...
+
+    Returns (feature_names: list[str], samples: list[str],
+             groups: list[str], X: np.ndarray[features x samples]).
+    """
+    with open(path, encoding="utf-8-sig", newline="") as f:
+        rows = list(csv.reader(f, delimiter=";"))
+    samples = [h.replace("Area: ", "").replace(".raw", "").strip()
+               for h in rows[0][1:]]
+    groups = [g.strip() for g in rows[1][1:]]
+    feat = [r[0].strip() for r in rows[2:]]
+    X = np.array(
+        [[float(v) for v in r[1:1 + len(samples)]] for r in rows[2:]],
+        dtype=float,
+    )
+    return feat, samples, groups, X
+
+
+# --------------------------------------------------------------------------
+# Preprocessing
+# --------------------------------------------------------------------------
+
+def normalize_sum(X):
+    """Total-area (sum) normalisation: rescale each sample column so that
+    every column has the mean of the column totals."""
+    col_sums = X.sum(axis=0)
+    return X / col_sums * col_sums.mean()
+
+
+def log2_transform(X):
+    """log2 with a guard against non-positive values (clip to tiny eps)."""
+    eps = np.finfo(float).tiny
+    return np.log2(np.clip(X, eps, None))
+
+
+def impute_low(X, threshold=0.05, method="knn", k=3):
+    """Impute below-threshold values (fraction of column min or a hard cap).
+
+    Methods:
+      'constant' : replace with the column minimum (or 0).
+      'min'      : replace with the column minimum.
+      'knn'      : replace with the mean of the k nearest samples in the
+                   Euclidean distance of the non-imputed rows.
+    Returns (X_imputed, imputed_mask).
+    """
+    X = np.asarray(X, dtype=float).copy()
+    col_min = X.min(axis=0)
+    mask = X < (col_min * (1 + threshold))
+    if not mask.any():
+        return X, mask
+    if method in ("constant", "min"):
+        rows, cols = np.nonzero(mask)
+        X[rows, cols] = col_min[cols]
+        return X, mask
+    # knn: distance between samples (columns) over all feature rows;
+    # impute each flagged value with the mean of its k nearest samples.
+    n_rows, n_cols = X.shape
+    d = np.sqrt(((X[:, :, None] - X[:, None, :]) ** 2).sum(axis=0))  # c x c
+    np.fill_diagonal(d, np.inf)
+    order = d.argsort(axis=1)
+    for c in range(n_cols):
+        bad = np.nonzero(mask[:, c])[0]
+        if bad.size == 0:
+            continue
+        for r in bad:
+            # prefer samples that are not flagged on this same feature
+            nb = order[c, :max(k, 1)]
+            ok = [j for j in nb if not (mask[r, j] and j != c)]
+            if not ok:
+                X[r, c] = col_min[c]
+            else:
+                X[r, c] = X[r, ok].mean()
+    return X, mask
+
+
+def scale_rows(X, method="autoscale"):
+    """Per-feature (row) scaling.
+
+      'autoscale' : z-score (mean 0, std 1, ddof=1)
+      'pareto'    : (x - mean) / sqrt(std)
+      'none'      : unchanged
+    Constant rows are returned as zeros (division guard).
+    """
+    X = np.asarray(X, dtype=float)
+    mean = X.mean(axis=1, keepdims=True)
+    if method == "none":
+        return X
+    std = X.std(axis=1, keepdims=True, ddof=1)
+    denom = np.where(std > 0, np.sqrt(std) if method == "pareto" else std, 1.0)
+    return (X - mean) / denom
+
+
+# --------------------------------------------------------------------------
+# Multiple-testing correction
+# --------------------------------------------------------------------------
+
+def bh_fdr(p):
+    """Benjamini-Hochberg FDR for an array of p-values."""
+    p = np.asarray(p, dtype=float)
+    m = len(p)
+    if m == 0:
+        return p
+    order = p.argsort()
+    ranked = p[order]
+    q = np.minimum.accumulate((ranked * m / np.arange(1, m + 1))[::-1])[::-1]
+    qf = np.empty(m)
+    qf[order] = np.clip(q, 0, 1)
+    return qf
+
+
+# --------------------------------------------------------------------------
+# Univariate statistics
+# --------------------------------------------------------------------------
+
+def _groups_arrays(X, groups, levels):
+    """Yield the per-group column slices for every feature row."""
+    gi = {lv: np.array(groups) == lv for lv in levels}
+    return [X[:, idx] for idx in gi.values()]
+
+
+def univariate(X, groups, method="anova", base=None, treats=None,
+               feature_names=None):
+    """Run the selected univariate test for every feature row.
+
+    method:
+      'anova' : one-way ANOVA across all levels (>= 2 levels, >= 2 per level).
+      'welch' : Welch two-sample t-test, `treats` combined vs `base`.
+      'kruskal': one-way Kruskal-Wallis across all levels.
+
+    feature_names: optional list of row labels (same length as X rows);
+      when given, the `Feature` column holds these names, else row indices.
+
+    Returns (DataFrame, levels). The DataFrame has columns
+      Feature, stat, p, (log2FC for welch), FDR_BH,
+      sorted by ascending p.
+    """
+    X = np.asarray(X, dtype=float)
+    groups = list(groups)
+    levels = list(dict.fromkeys(groups))
+    n = X.shape[0]
+    names = list(feature_names) if feature_names is not None else list(range(n))
+    res = []
+    if method in ("anova", "kruskal"):
+        for i in range(n):
+            cols = [X[i, np.array(groups) == lv] for lv in levels]
+            if any(c.size < 2 for c in cols):
+                stat, p = np.nan, np.nan
+            elif method == "anova":
+                stat, p = stats.f_oneway(*cols)
+            else:
+                stat, p = stats.kruskal(*cols)
+            res.append(dict(Feature=names[i], stat=stat, p=p))
+    elif method == "welch":
+        if base not in levels or not treats:
+            raise ValueError("Welch test needs `base` and non-empty `treats`.")
+        b = np.array(groups) == base
+        a = np.isin(np.array(groups), treats)
+        for i in range(n):
+            if X[i, a].size < 2 or X[i, b].size < 2:
+                stat, p = np.nan, np.nan
+                fc = np.nan
+            else:
+                stat, p = stats.ttest_ind(X[i, a], X[i, b], equal_var=False)
+                fc = X[i, a].mean() - X[i, b].mean()
+            res.append(dict(Feature=names[i], stat=stat, p=p, log2FC=fc))
+    else:
+        raise ValueError(f"unknown method {method!r}")
+
+    df = pd.DataFrame(res)
+    df["p"] = pd.Series(df["p"]).astype(float)
+    df = df.sort_values("p", na_position="last").reset_index(drop=True)
+    df["FDR_BH"] = bh_fdr(df["p"].values)
+    return df, levels
+
+
+def add_group_means(df, X, groups, levels, feature_names=None):
+    """Append per-group mean columns (on the supplied, usually scaled, X).
+
+    `df` must contain a `Feature` column. When `feature_names` is given it
+    maps feature names to their row index in X; otherwise `Feature` values
+    are assumed to already be row indices.
+    """
+    X = np.asarray(X, dtype=float)
+    groups = np.asarray(groups)
+    out = df.copy()
+    if feature_names is not None:
+        name_to_row = {n: i for i, n in enumerate(feature_names)}
+    else:
+        name_to_row = None
+    for lv in levels:
+        vals = []
+        for f in out["Feature"]:
+            i = name_to_row.get(f) if name_to_row is not None else f
+            vals.append(
+                X[i, groups == lv].mean() if (groups == lv).any() else np.nan)
+        out[f"mean_{lv}"] = vals
+    return out
+
+
+def format_p(v):
+    """Human-friendly p-value string (scientific below 1e-4)."""
+    if v is None or (isinstance(v, float) and np.isnan(v)):
+        return "NA"
+    if v < 1e-4:
+        return f"{v:.2e}"
+    return f"{v:.4f}"
+
+
+# --------------------------------------------------------------------------
+# Volcano (contrast derived from per-group means)
+# --------------------------------------------------------------------------
+
+def volcano_table(df, group_a, group_b, fdr_col="FDR_BH", alpha=0.05, fc=1.0):
+    """Build a volcano table for the contrast `group_a` vs `group_b`.
+
+    Operates on a univariate results frame (as produced by `univariate` +
+    `add_group_means`): it needs a `Feature` column, the two `mean_<group>`
+    columns and an FDR column. Group means live in the (log2) space the data
+    was supplied in, so the fold change is their difference:
+
+        log2FC = mean_a - mean_b      (positive => higher in group_a)
+
+    Returns a DataFrame with columns
+      Feature, log2FC, FDR_BH, neglog10FDR, direction,
+    where direction is "up"  (FDR < alpha and log2FC >=  fc),
+                     "down"(FDR < alpha and log2FC <= -fc),
+                     "ns"  otherwise.
+    """
+    ca, cb = f"mean_{group_a}", f"mean_{group_b}"
+    for c in ("Feature", ca, cb, fdr_col):
+        if c not in df.columns:
+            raise ValueError(f"volcano needs column {c!r}")
+    lfc = df[ca].to_numpy(float) - df[cb].to_numpy(float)
+    fdr = df[fdr_col].to_numpy(float)
+    out = pd.DataFrame({
+        "Feature": df["Feature"].to_numpy(),
+        "log2FC": lfc,
+        "FDR_BH": fdr,
+        "neglog10FDR": -np.log10(np.clip(fdr, np.finfo(float).tiny, None)),
+    })
+    sig = fdr < alpha
+    out["direction"] = np.where(
+        sig & (lfc >= fc), "up",
+        np.where(sig & (lfc <= -fc), "down", "ns"))
+    return out

wellerlab/metabo/widgets/__init__.py

@@ -0,0 +1,17 @@
+"""Widget definitions for wellerlab.metabo."""
+
+from .owfeatureimport import OWFeatureImport  # noqa: F401
+from .owpreprocess import OWMetaboPreprocess  # noqa: F401
+from .owfeaturefilter import OWFeatureFilter  # noqa: F401
+from .owunivariate import OWUnivariateStats  # noqa: F401
+from .owheatmap import OWMetaboHeatmap  # noqa: F401
+from .owvolcano import OWVolcano  # noqa: F401
+
+__all__ = [
+    "OWFeatureImport",
+    "OWMetaboPreprocess",
+    "OWFeatureFilter",
+    "OWUnivariateStats",
+    "OWMetaboHeatmap",
+    "OWVolcano",
+]

wellerlab/metabo/widgets/_dialogs.py

@@ -0,0 +1,37 @@
+"""Small Qt dialog helpers shared by the Metabo widgets.
+
+Orange's ``Orange.widgets.utils.filedialogs`` API is not stable across
+releases: the ``OpenFileDialog`` / ``SaveFileDialog`` classes used by older
+widgets no longer exist in current Orange (they were replaced by the
+``open_filename_dialog`` / ``open_filename_dialog_save`` functions). To stay
+working on every Orange version the widgets call plain ``QFileDialog``
+directly through these two helpers — one idiom, no version-specific imports.
+"""
+
+
+def open_feature_table(parent, start_dir=""):
+    """Ask for a feature-table CSV/TXT. Returns a path or None (cancelled)."""
+    from AnyQt.QtWidgets import QFileDialog
+    path, _ = QFileDialog.getOpenFileName(
+        parent, "Open feature table", start_dir or "",
+        "Feature table (*.csv *.txt *.tsv);;All files (*)")
+    return path or None
+
+
+def save_figure(parent, fig, kind="PNG"):
+    """Ask for a path and write figure `fig` as PNG (dpi 300) or SVG.
+
+    `kind` is 'PNG' or 'SVG' (case-insensitive). Returns the path written,
+    or None if the user cancelled.
+    """
+    from AnyQt.QtWidgets import QFileDialog
+    kind = kind.upper()
+    ext = ".png" if kind == "PNG" else ".svg"
+    path, _ = QFileDialog.getSaveFileName(
+        parent, f"Save figure ({kind})", "", f"{kind} (*{ext});;All files (*)")
+    if not path:
+        return None
+    if not path.lower().endswith(ext):
+        path += ext
+    fig.savefig(path, dpi=300 if kind == "PNG" else None, facecolor="white")
+    return path

wellerlab/metabo/widgets/_plot.py

@@ -0,0 +1,194 @@
+"""Shared matplotlib-canvas helpers for the Metabo widgets.
+
+Orange's own plots are pyqtgraph based and get pan/zoom/reset for free; the
+Metabo heatmap and volcano are matplotlib canvases, so the interaction is
+implemented here explicitly — and, importantly, it survives redraws (a plain
+matplotlib canvas autoscales on every draw, which silently discards the user's
+zoom).
+
+Interaction provided by `PlotCanvas`:
+
+  * wheel over the plot zooms around the cursor,
+  * dragging with the left button pans,
+  * a left click (no drag) calls `on_click(axes, xdata, ydata)` — used by the
+    volcano for point selection, with a pixel tolerance so edge points work,
+  * `reset_view()` restores the automatic view; `after_draw()` keeps the
+    user's zoom across redraws.
+
+`attach_toolbar()` adds matplotlib's navigation toolbar (save / home / zoom
+rect / pan) and `draggable()` makes a legend movable.
+"""
+
+import numpy as np
+from typing import Callable, Optional
+from AnyQt.QtCore import Qt
+from matplotlib.backends.backend_qtagg import (
+    FigureCanvasQTAgg, NavigationToolbar2QT)
+from matplotlib.figure import Figure
+
+CLICK_TOLERANCE = 12        # px radius for click selection
+DRAG_THRESHOLD = 3          # px before a press counts as a pan drag
+
+
+class PlotCanvas(FigureCanvasQTAgg):
+    def __init__(self, figsize=(8, 5), dpi=100):
+        self.fig = Figure(figsize=figsize, dpi=dpi)
+        super().__init__(self.fig)
+        self.setFocusPolicy(Qt.StrongFocus)
+        self.main_axes = None      # the axes the view is kept for
+        self.home = None           # (xlim, ylim) of the automatic view
+        self.view = None           # the user's current view (None = home)
+        self.on_click: Optional[Callable] = None   # callback(axes, xdata, ydata)
+        self.toolbar = None
+        self._press = None
+
+    # ------------------------------------------------------------------ view
+    def after_draw(self, ax, new_data=False):
+        """Call after every redraw. Keeps the user's zoom unless data changed."""
+        axis = ax or (self.fig.axes[0] if self.fig.axes else None)
+        if axis is None:
+            return
+        self.main_axes = axis
+        if new_data or self.home is None:
+            self.home = (axis.get_xlim(), axis.get_ylim())
+            self.view = None
+        if self.view is not None:
+            axis.set_xlim(*self.view[0])
+            axis.set_ylim(*self.view[1])
+
+    def reset_view(self):
+        """Back to the automatic (home) view; also clears any toolbar mode."""
+        if self.toolbar is not None:
+            self.toolbar.mode = ""
+            try:
+                self.toolbar._update_buttons_checked()
+            except Exception:
+                pass
+        self.view = None
+        if self.home is not None and self.main_axes is not None:
+            self.main_axes.set_xlim(*self.home[0])
+            self.main_axes.set_ylim(*self.home[1])
+        self.draw_idle()
+
+    def _remember(self, ax):
+        if ax is self.main_axes:
+            self.view = (ax.get_xlim(), ax.get_ylim())
+
+    # --------------------------------------------------------------- helpers
+    def _axes_at(self, x, y):
+        for ax in reversed(self.fig.axes):
+            if ax.bbox.contains(x, y):
+                return ax
+        return None
+
+    @staticmethod
+    def _steps(event):
+        if not event.pixelDelta().isNull():
+            return event.pixelDelta().y()
+        return event.angleDelta().y() / 120.0
+
+    # ------------------------------------------------------------ wheel zoom
+    def zoom_at(self, ax, x, y, steps):
+        """Zoom `ax` around the display point (x, y) by `steps` wheel notches."""
+        cx, cy = ax.transData.inverted().transform((x, y))
+        k = 0.8 ** steps                       # wheel up (steps>0) zooms in
+        xl, yl = ax.get_xlim(), ax.get_ylim()
+        ax.set_xlim(cx + (xl[0] - cx) * k, cx + (xl[1] - cx) * k)
+        ax.set_ylim(cy + (yl[0] - cy) * k, cy + (yl[1] - cy) * k)
+        self._remember(ax)
+
+    def wheelEvent(self, event):
+        x, y = self.mouseEventCoords(event)
+        ax = self._axes_at(x, y)
+        steps = self._steps(event)
+        if ax is None or not steps:
+            super().wheelEvent(event)
+            return
+        self.zoom_at(ax, x, y, steps)
+        self.draw_idle()
+        event.accept()                          # don't let a parent scroll
+
+    # ------------------------------------------------- pan drag / click sel
+    def mousePressEvent(self, event):
+        if event.button() == Qt.LeftButton:
+            x, y = self.mouseEventCoords(event)
+            ax = self._axes_at(x, y)
+            if ax is not None:
+                self._press = (x, y, ax, ax.get_xlim(), ax.get_ylim(), False)
+        super().mousePressEvent(event)
+
+    def pan_by(self, ax, x0, y0, x1, y1, xl0, yl0):
+        """Pan `ax` so the display point (x0, y0) follows the cursor to (x1, y1)."""
+        inv = ax.transData.inverted()
+        dx = inv.transform((x0, y0))[0] - inv.transform((x1, y1))[0]
+        dy = inv.transform((x0, y0))[1] - inv.transform((x1, y1))[1]
+        ax.set_xlim(xl0[0] + dx, xl0[1] + dx)
+        ax.set_ylim(yl0[0] + dy, yl0[1] + dy)
+        self._remember(ax)
+
+    def mouseMoveEvent(self, event):
+        if self._press is not None and (event.buttons() & Qt.LeftButton):
+            x0, y0, ax, xl0, yl0, moved = self._press
+            x, y = self.mouseEventCoords(event)
+            if moved or abs(x - x0) + abs(y - y0) > DRAG_THRESHOLD:
+                self.pan_by(ax, x0, y0, x, y, xl0, yl0)
+                self._press = (x0, y0, ax, xl0, yl0, True)
+                self.draw_idle()
+        super().mouseMoveEvent(event)
+
+    def mouseReleaseEvent(self, event):
+        press, self._press = self._press, None
+        if (event.button() == Qt.LeftButton and press is not None
+                and not press[5] and self.on_click is not None):
+            ax = press[2]
+            x, y = self.mouseEventCoords(event)
+            self._remember(ax)
+            self.on_click(ax, *ax.transData.inverted().transform((x, y)))
+        super().mouseReleaseEvent(event)
+
+    # ------------------------------------------------------- nearest feature
+    def nearest_point(self, ax, xdata, ydata, offsets):
+        """Index of the scatter point nearest to (xdata, ydata), or None when
+        nothing is within CLICK_TOLERANCE pixels (so edge points are clickable)."""
+        if offsets is None or len(offsets) == 0:
+            return None
+        px, py = ax.transData.transform((xdata, ydata))
+        disp = ax.transData.transform(np.asarray(offsets, dtype=float))
+        d = np.hypot(disp[:, 0] - px, disp[:, 1] - py)
+        i = int(np.argmin(d))
+        return i if d[i] <= CLICK_TOLERANCE else None
+
+
+def attach_toolbar(box, canvas, parent):
+    """Add a slim matplotlib toolbar to `box`: Home (= reset view) and Save.
+
+    The pan/zoom/back/forward/subplots actions are removed: panning and zooming
+    are done directly on the canvas (`PlotCanvas`), and matplotlib's modal
+    tools would swallow the left button, so point selection became impossible
+    until the user figured out how to leave the mode again.
+    """
+    toolbar = NavigationToolbar2QT(canvas, parent)
+    acts = getattr(toolbar, "_actions", {})
+    for key in ("back", "forward", "pan", "zoom",
+                "configure_subplots", "edit_parameters"):
+        action = acts.get(key)
+        if action is not None:
+            toolbar.removeAction(action)
+    home = acts.get("home")
+    if home is not None:
+        home.setToolTip("Reset view")
+        try:
+            home.triggered.disconnect()
+        except (TypeError, RuntimeError):
+            pass
+        home.triggered.connect(lambda *_: canvas.reset_view())
+    box.layout().addWidget(toolbar)
+    canvas.toolbar = toolbar
+    return toolbar
+
+
+def draggable(legend):
+    """Make a matplotlib legend movable by dragging."""
+    if legend is not None:
+        legend.set_draggable(True)
+    return legend

wellerlab/metabo/widgets/icons/FeatureFilter.svg

@@ -0,0 +1,6 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="48" height="48" viewBox="0 0 48 48">
+  <rect width="48" height="48" rx="8" fill="#1F4E79"/>
+  <g><polyline points="7,32 13,32 15,20 18,32 24,32 26,14 29,32 34,32 36,24 39,32 41,32" fill="none" stroke="#fff" stroke-width="2" stroke-linejoin="round"/><line x1="7" y1="36" x2="41" y2="36" stroke="#fff" stroke-width="1.5" opacity="0.7"/></g>
+  <text x="24" y="45" font-family="Helvetica,Arial,sans-serif" font-size="7" fill="#fff"
+        fill-opacity="0.85" text-anchor="middle">FIL</text>
+</svg>

wellerlab/metabo/widgets/icons/FeatureImport.svg

@@ -0,0 +1,6 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="48" height="48" viewBox="0 0 48 48">
+  <rect width="48" height="48" rx="8" fill="#1F4E79"/>
+  <g><polyline points="7,32 13,32 15,20 18,32 24,32 26,14 29,32 34,32 36,24 39,32 41,32" fill="none" stroke="#fff" stroke-width="2" stroke-linejoin="round"/><line x1="7" y1="36" x2="41" y2="36" stroke="#fff" stroke-width="1.5" opacity="0.7"/></g>
+  <text x="24" y="45" font-family="Helvetica,Arial,sans-serif" font-size="7" fill="#fff"
+        fill-opacity="0.85" text-anchor="middle">IMP</text>
+</svg>

wellerlab/metabo/widgets/icons/Heatmap.svg

@@ -0,0 +1,6 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="48" height="48" viewBox="0 0 48 48">
+  <rect width="48" height="48" rx="8" fill="#1F4E79"/>
+  <g><polyline points="7,32 13,32 15,20 18,32 24,32 26,14 29,32 34,32 36,24 39,32 41,32" fill="none" stroke="#fff" stroke-width="2" stroke-linejoin="round"/><line x1="7" y1="36" x2="41" y2="36" stroke="#fff" stroke-width="1.5" opacity="0.7"/></g>
+  <text x="24" y="45" font-family="Helvetica,Arial,sans-serif" font-size="7" fill="#fff"
+        fill-opacity="0.85" text-anchor="middle">HM</text>
+</svg>

wellerlab/metabo/widgets/icons/Preprocess.svg

@@ -0,0 +1,6 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="48" height="48" viewBox="0 0 48 48">
+  <rect width="48" height="48" rx="8" fill="#1F4E79"/>
+  <g><polyline points="7,32 13,32 15,20 18,32 24,32 26,14 29,32 34,32 36,24 39,32 41,32" fill="none" stroke="#fff" stroke-width="2" stroke-linejoin="round"/><line x1="7" y1="36" x2="41" y2="36" stroke="#fff" stroke-width="1.5" opacity="0.7"/></g>
+  <text x="24" y="45" font-family="Helvetica,Arial,sans-serif" font-size="7" fill="#fff"
+        fill-opacity="0.85" text-anchor="middle">PRE</text>
+</svg>

wellerlab/metabo/widgets/icons/UnivariateStats.svg

@@ -0,0 +1,6 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="48" height="48" viewBox="0 0 48 48">
+  <rect width="48" height="48" rx="8" fill="#1F4E79"/>
+  <g><polyline points="7,32 13,32 15,20 18,32 24,32 26,14 29,32 34,32 36,24 39,32 41,32" fill="none" stroke="#fff" stroke-width="2" stroke-linejoin="round"/><line x1="7" y1="36" x2="41" y2="36" stroke="#fff" stroke-width="1.5" opacity="0.7"/></g>
+  <text x="24" y="45" font-family="Helvetica,Arial,sans-serif" font-size="7" fill="#fff"
+        fill-opacity="0.85" text-anchor="middle">UNI</text>
+</svg>

wellerlab/metabo/widgets/icons/Volcano.svg

@@ -0,0 +1,6 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="48" height="48" viewBox="0 0 48 48">
+  <rect width="48" height="48" rx="8" fill="#1F4E79"/>
+  <g><polyline points="7,32 13,32 15,20 18,32 24,32 26,14 29,32 34,32 36,24 39,32 41,32" fill="none" stroke="#fff" stroke-width="2" stroke-linejoin="round"/><line x1="7" y1="36" x2="41" y2="36" stroke="#fff" stroke-width="1.5" opacity="0.7"/></g>
+  <text x="24" y="45" font-family="Helvetica,Arial,sans-serif" font-size="7" fill="#fff"
+        fill-opacity="0.85" text-anchor="middle">VOL</text>
+</svg>