@@ -150,16 +150,20 @@ async def get_barcode_data(
     project_id: str,
     features: str = "",
     max_samples: int = 500,
+    transform: str = "raw",
     user: User = Depends(get_current_user),
     db: AsyncSession = Depends(get_db),
 ):
-    """Get raw feature values per sample for barcode heatmap (viewer access).
+    """Get feature values per sample for barcode heatmap (viewer access).
 
     Returns a matrix of shape (n_features, n_samples) with samples ordered by class.
     Pass feature names as comma-separated string, max 100.
+    Transform: raw (default), log, or zscore.
     """
     if not features:
         raise HTTPException(400, "No features specified")
+    if transform not in data_analysis.VALID_TRANSFORMS:
+        raise HTTPException(400, f"Invalid transform: {transform}")
 
     feature_list = [f.strip() for f in features.split(",") if f.strip()][:100]
     if not feature_list:
@@ -169,11 +173,44 @@ async def get_barcode_data(
     x_path, y_path = _resolve_train_files(project)
 
     barcode = data_analysis.compute_barcode_data(
-        x_path, y_path, feature_list, max_samples=max_samples
+        x_path, y_path, feature_list, max_samples=max_samples, transform=transform,
     )
     return barcode
 
 
+@router.get("/{project_id}/class-heatmap")
+async def get_class_heatmap(
+    project_id: str,
+    features: str = "",
+    transform: str = "zscore",
+    user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """Compute features × class-mean heatmap (viewer access).
+
+    Returns a compact matrix of mean values per class for each feature.
+    Defaults to z-score transform, showing how each feature deviates from
+    the overall mean in each class — useful for spotting class-discriminative features.
+    Pass feature names as comma-separated string, max 100.
+    """
+    if not features:
+        raise HTTPException(400, "No features specified")
+    if transform not in data_analysis.VALID_TRANSFORMS:
+        raise HTTPException(400, f"Invalid transform: {transform}")
+
+    feature_list = [f.strip() for f in features.split(",") if f.strip()][:100]
+    if not feature_list:
+        raise HTTPException(400, "No valid features specified")
+
+    project, _ = await get_project_with_access(project_id, user, db, require_role="viewer")
+    x_path, y_path = _resolve_train_files(project)
+
+    result = data_analysis.compute_class_heatmap(
+        x_path, y_path, feature_list, transform=transform,
+    )
+    return result
+
+
 @router.get("/{project_id}/pcoa")
 async def get_pcoa(
     project_id: str,
 
@@ -232,9 +232,11 @@ def compute_barcode_data(
     feature_names: list[str],
     features_in_rows: bool = True,
     max_samples: int = 500,
+    transform: str = "raw",
 ) -> dict[str, Any]:
-    """Compute barcode heatmap data: raw feature values per sample, ordered by class.
+    """Compute barcode heatmap data: feature values per sample, ordered by class.
 
+    Supports transforms: raw (default), log, zscore.
     Returns a matrix (features x samples) plus metadata for heatmap rendering.
     """
     feature_names = feature_names[:100]
@@ -282,8 +284,11 @@ def compute_barcode_data(
         cumulative += int((y_sorted == cls).sum())
         class_boundaries.append(cumulative)
 
-    # Build matrix (features x samples)
-    matrix = X_sorted[valid_features].T.values.tolist()
+    # Build matrix (features x samples), applying transform if requested
+    values = X_sorted[valid_features].values.astype(float)  # shape (samples, features)
+    if transform != "raw":
+        values = apply_transform(values, transform=transform)
+    matrix = values.T.tolist()  # transpose to (features, samples)
 
     return {
         "matrix": matrix,
@@ -292,6 +297,61 @@ def compute_barcode_data(
         "sample_classes": y_sorted.astype(int).tolist(),
         "class_labels": [str(int(c)) for c in class_labels],
         "class_boundaries": class_boundaries,
+        "transform": transform,
+    }
+
+
+def compute_class_heatmap(
+    x_path: str,
+    y_path: str,
+    feature_names: list[str],
+    features_in_rows: bool = True,
+    transform: str = "zscore",
+) -> dict[str, Any]:
+    """Compute a class-mean heatmap: features × classes, showing mean per class
+    (optionally z-score standardized first). Compact and readable for highlighting
+    class-discriminative features.
+    """
+    feature_names = feature_names[:100]
+
+    X = pd.read_csv(x_path, sep="\t", index_col=0)
+    y = pd.read_csv(y_path, sep="\t", index_col=0)
+
+    if features_in_rows:
+        X = X.T  # rows=samples, cols=features
+
+    y_series = y.iloc[:, 0]
+    common = X.index.intersection(y_series.index)
+    X = X.loc[common]
+    y_series = y_series.loc[common]
+
+    valid_features = [f for f in feature_names if f in X.columns]
+    if not valid_features:
+        return {"matrix": [], "feature_names": [], "class_labels": [], "transform": transform}
+
+    mat = X[valid_features].values.astype(float)  # (samples, features)
+    mat = np.nan_to_num(mat, nan=0.0)
+
+    # Apply transform (z-score is typical for this view, but raw/log also allowed)
+    if transform != "raw":
+        mat = apply_transform(mat, transform=transform)
+
+    class_labels = sorted(y_series.unique())
+    # Compute per-class mean: (n_classes, n_features)
+    means = np.zeros((len(class_labels), len(valid_features)))
+    for ci, cls in enumerate(class_labels):
+        mask = (y_series == cls).values
+        if mask.any():
+            means[ci] = np.nanmean(mat[mask], axis=0)
+
+    # Return as (features × classes) for display (rows=features)
+    matrix = means.T.tolist()
+
+    return {
+        "matrix": matrix,
+        "feature_names": valid_features,
+        "class_labels": [str(int(c)) for c in class_labels],
+        "transform": transform,
     }
 
 
 
@@ -630,6 +630,7 @@
     "prevalence": "Prevalence",
     "abundance": "Abundance",
     "barcode": "Barcode",
+    "classHeatmap": "Class heatmap",
     "volcano": "Volcano",
     "pcoa": "PCoA",
     "pcoaMetric": "Distance metric",
 
@@ -630,6 +630,7 @@
     "prevalence": "Prévalence",
     "abundance": "Abondance",
     "barcode": "Code-barres",
+    "classHeatmap": "Heatmap par classe",
     "volcano": "Volcano",
     "pcoa": "ACoP",
     "pcoaMetric": "Métrique de distance",
 
@@ -175,6 +175,7 @@
             <button :class="{ active: vizTab === 'prevalence' }" @click="vizTab = 'prevalence'">{{ $t('data.prevalence') }}</button>
             <button :class="{ active: vizTab === 'abundance' }" @click="vizTab = 'abundance'">{{ $t('data.abundance') }}</button>
             <button :class="{ active: vizTab === 'barcode' }" @click="vizTab = 'barcode'">{{ $t('data.barcode') }}</button>
+            <button :class="{ active: vizTab === 'classHeatmap' }" @click="vizTab = 'classHeatmap'">{{ $t('data.classHeatmap') }}</button>
             <button :class="{ active: vizTab === 'volcano' }" @click="vizTab = 'volcano'">{{ $t('data.volcano') }}</button>
             <button :class="{ active: vizTab === 'pcoa' }" @click="vizTab = 'pcoa'">{{ $t('data.pcoa') }}</button>
           </nav>
@@ -213,10 +214,36 @@
 
         <!-- Barcode heatmap -->
         <section class="section viz-section" v-if="vizTab === 'barcode'">
+          <div class="viz-controls">
+            <label class="toggle-label">
+              <span>{{ $t('data.transform') }}</span>
+              <select v-model="dataTransform" @change="loadBarcodeData">
+                <option value="raw">Raw</option>
+                <option value="log">Log</option>
+                <option value="zscore">Z-score</option>
+              </select>
+            </label>
+          </div>
           <div ref="barcodeChartEl" class="plotly-chart plotly-chart-tall"></div>
           <p v-if="!featureStats" class="info-text">Upload datasets and run filtering to see barcode.</p>
         </section>
 
+        <!-- Class mean heatmap (features x classes) -->
+        <section class="section viz-section" v-if="vizTab === 'classHeatmap'">
+          <div class="viz-controls">
+            <label class="toggle-label">
+              <span>{{ $t('data.transform') }}</span>
+              <select v-model="dataTransform" @change="loadClassHeatmap">
+                <option value="raw">Raw</option>
+                <option value="log">Log</option>
+                <option value="zscore">Z-score</option>
+              </select>
+            </label>
+          </div>
+          <div ref="classHeatmapChartEl" class="plotly-chart plotly-chart-tall"></div>
+          <p v-if="!featureStats" class="info-text">Upload datasets and run filtering to see class heatmap.</p>
+        </section>
+
         <!-- Volcano plot -->
         <section class="section viz-section" v-if="vizTab === 'volcano'">
           <div ref="volcanoChartEl" class="plotly-chart plotly-chart-tall"></div>
@@ -332,6 +359,7 @@ const summary = ref(null)
 const featureStats = ref(null)
 const abundanceData = ref([])
 const barcodeData = ref(null)
+const classHeatmapData = ref(null)
 const mspAnnotations = ref({})
 const vizTab = ref('prevalence')
 const pcoaData = ref(null)
@@ -374,6 +402,7 @@ const selectedFeatures = ref([])
 const prevalenceChartEl = ref(null)
 const abundanceChartEl = ref(null)
 const barcodeChartEl = ref(null)
+const classHeatmapChartEl = ref(null)
 const volcanoChartEl = ref(null)
 const pcoaChartEl = ref(null)
 
@@ -663,14 +692,31 @@ async function loadBarcodeData() {
   if (feats.length === 0 || !hasTrainData.value) return
   try {
     const { data } = await axios.get(`/api/data-explore/${projectId.value}/barcode-data`, {
-      params: { features: feats.join(',') },
+      params: { features: feats.join(','), transform: dataTransform.value },
     })
     barcodeData.value = data
+    await nextTick()
+    renderBarcodeChart()
   } catch (e) {
     console.error('Failed to load barcode data:', e)
   }
 }
 
+async function loadClassHeatmap() {
+  const feats = plotFeatureNames.value
+  if (feats.length === 0 || !hasTrainData.value) return
+  try {
+    const { data } = await axios.get(`/api/data-explore/${projectId.value}/class-heatmap`, {
+      params: { features: feats.join(','), transform: dataTransform.value },
+    })
+    classHeatmapData.value = data
+    await nextTick()
+    renderClassHeatmapChart()
+  } catch (e) {
+    console.error('Failed to load class heatmap:', e)
+  }
+}
+
 async function loadPcoaJobs() {
   try {
     const { data } = await axios.get(`/api/analysis/${projectId.value}/jobs`)
@@ -1270,13 +1316,59 @@ function renderCurrentViz() {
   if (vizTab.value === 'prevalence') renderPrevalenceChart()
   else if (vizTab.value === 'abundance') renderAbundanceChart()
   else if (vizTab.value === 'barcode') renderBarcodeChart()
+  else if (vizTab.value === 'classHeatmap') {
+    if (!classHeatmapData.value) loadClassHeatmap()
+    else renderClassHeatmapChart()
+  }
   else if (vizTab.value === 'volcano') renderVolcanoChart()
   else if (vizTab.value === 'pcoa') {
     if (!pcoaData.value && !loadingPcoa.value) loadPcoa()
     else renderPcoaChart()
   }
 }
 
+async function renderClassHeatmapChart() {
+  await nextTick()
+  if (!classHeatmapChartEl.value || !classHeatmapData.value || classHeatmapData.value.matrix.length === 0) return
+  const c = chartColors()
+  const d = classHeatmapData.value
+
+  // Symmetric divergent colorscale centered at 0 (z-score) or around mean (raw/log)
+  const flat = d.matrix.flat().filter(v => Number.isFinite(v))
+  let maxAbs = 0
+  if (flat.length > 0) {
+    maxAbs = Math.max(Math.abs(Math.min(...flat)), Math.abs(Math.max(...flat)))
+  }
+  if (maxAbs === 0) maxAbs = 1
+
+  const isZscore = d.transform === 'zscore'
+  const colorscale = isZscore
+    ? [[0, '#0000b8'], [0.25, '#4472ff'], [0.5, '#f8f8f8'], [0.75, '#ff6060'], [1, '#b80000']]
+    : [[0, '#f8f8f8'], [0.5, '#ffa500'], [1, '#b80000']]
+
+  const trace = {
+    z: d.matrix,  // (features x classes)
+    x: d.class_labels,
+    y: d.feature_names.map(featureLabel),
+    type: 'heatmap',
+    colorscale,
+    zmin: isZscore ? -maxAbs : Math.min(...flat),
+    zmax: isZscore ? maxAbs : Math.max(...flat),
+    zmid: isZscore ? 0 : undefined,
+    hovertemplate: 'Feature: %{y}<br>Class: %{x}<br>Value: %{z:.3f}<extra></extra>',
+    colorbar: { title: { text: d.transform }, thickness: 12 },
+  }
+
+  const layout = chartLayout({
+    title: `Class mean heatmap (${d.transform})`,
+    xaxis: { title: 'Class', side: 'bottom' },
+    yaxis: { title: 'Feature', autorange: 'reversed', tickfont: { size: 10 } },
+    margin: { l: 220, r: 40, t: 50, b: 60 },
+  })
+
+  Plotly.newPlot(classHeatmapChartEl.value, [trace], layout, { responsive: true, displayModeBar: true })
+}
+
 // Watchers for chart rendering
 watch(vizTab, async () => {
   await nextTick()