simview 3.5__tar.gz → 3.6__tar.gz

{simview-3.5/simview.egg-info → simview-3.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simview
-Version: 3.5
+Version: 3.6
 Summary: THREE.js-based simulation visualization tool
 Author-email: Jan Vlk <vlkjan6@fel.cvut.cz>, Ales Kucera <kuceral4@fel.cvut.cz>, David Korcak <david.korcak@gmail.com>
 License-Expression: BSD-3-Clause

{simview-3.5 → simview-3.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "simview"
-version = "3.5"
+version = "3.6"
 readme = "README.md"
 requires-python = ">=3.12"
 license = "BSD-3-Clause"

{simview-3.5 → simview-3.6}/simview/__main__.py

@@ -82,14 +82,18 @@ def run_info(path: Path, as_json: bool) -> None:
 
 
 def run_terrain(path: Path, args: argparse.Namespace) -> None:
-    """Print terrain value(s) at a point or over an area, from the scene JSON
-    at `path`, to stdout. With `--batches A B`, compares two batches instead
-    of querying a single one."""
+    """Print terrain value(s) at a point, over an area, or along a body's
+    trajectory, from the scene JSON at `path`, to stdout. With `--batches
+    A B`, compares two batches instead of querying a single one (for
+    `--along-body`, both batches' terrains are sampled along batch A's
+    trajectory -- see `query_along_body_diff`)."""
     from simview import terrain as terrain_mod
 
-    if (args.point is None) == (args.area is None):
+    mode_count = sum(v is not None for v in (args.point, args.area, args.along_body))
+    if mode_count != 1:
         logger.error(
-            "Error: 'simview terrain' requires exactly one of --point or --area."
+            "Error: 'simview terrain' requires exactly one of --point, --area, "
+            "or --along-body."
         )
         sys.exit(1)
     if args.area is not None and len(args.area) not in (0, 4):
@@ -106,40 +110,67 @@ def run_terrain(path: Path, args: argparse.Namespace) -> None:
     diff_mode = args.batches is not None
 
     try:
-        model_data = terrain_mod.load_scene_model(path)
-        if diff_mode:
-            batch_a, batch_b = args.batches
-            if args.point is not None:
-                result = terrain_mod.query_point_diff(
+        if args.along_body is not None:
+            model_data, states_data = terrain_mod.load_scene(path)
+            if diff_mode:
+                batch_a, batch_b = args.batches
+                result = terrain_mod.query_along_body_diff(
                     model_data,
-                    args.point[0],
-                    args.point[1],
+                    states_data,
+                    args.along_body,
                     batch_a,
                     batch_b,
                     args.layer,
+                    args.every,
                 )
-                text = terrain_mod.format_point_diff_text(result)
-                csv_text = terrain_mod.format_point_diff_csv(result)
+                text = terrain_mod.format_along_diff_text(result)
+                csv_text = terrain_mod.format_along_diff_csv(result)
             else:
-                bounds = tuple(args.area) if args.area else None
-                result = terrain_mod.query_area_diff(
-                    model_data, bounds, batch_a, batch_b, args.layer, args.stride
+                result = terrain_mod.query_along_body(
+                    model_data,
+                    states_data,
+                    args.along_body,
+                    args.layer,
+                    args.batch,
+                    args.every,
                 )
-                text = terrain_mod.format_area_diff_text(result)
-                csv_text = terrain_mod.format_area_diff_csv(result)
-        elif args.point is not None:
-            result = terrain_mod.query_point(
-                model_data, args.point[0], args.point[1], args.layer, args.batch
-            )
-            text = terrain_mod.format_point_text(result)
-            csv_text = terrain_mod.format_point_csv(result)
+                text = terrain_mod.format_along_text(result)
+                csv_text = terrain_mod.format_along_csv(result)
         else:
-            bounds = tuple(args.area) if args.area else None
-            result = terrain_mod.query_area(
-                model_data, bounds, args.layer, args.batch, args.stride
-            )
-            text = terrain_mod.format_area_text(result)
-            csv_text = terrain_mod.format_area_csv(result)
+            model_data = terrain_mod.load_scene_model(path)
+            if diff_mode:
+                batch_a, batch_b = args.batches
+                if args.point is not None:
+                    result = terrain_mod.query_point_diff(
+                        model_data,
+                        args.point[0],
+                        args.point[1],
+                        batch_a,
+                        batch_b,
+                        args.layer,
+                    )
+                    text = terrain_mod.format_point_diff_text(result)
+                    csv_text = terrain_mod.format_point_diff_csv(result)
+                else:
+                    bounds = tuple(args.area) if args.area else None
+                    result = terrain_mod.query_area_diff(
+                        model_data, bounds, batch_a, batch_b, args.layer, args.stride
+                    )
+                    text = terrain_mod.format_area_diff_text(result)
+                    csv_text = terrain_mod.format_area_diff_csv(result)
+            elif args.point is not None:
+                result = terrain_mod.query_point(
+                    model_data, args.point[0], args.point[1], args.layer, args.batch
+                )
+                text = terrain_mod.format_point_text(result)
+                csv_text = terrain_mod.format_point_csv(result)
+            else:
+                bounds = tuple(args.area) if args.area else None
+                result = terrain_mod.query_area(
+                    model_data, bounds, args.layer, args.batch, args.stride
+                )
+                text = terrain_mod.format_area_text(result)
+                csv_text = terrain_mod.format_area_csv(result)
     except (json.JSONDecodeError, ValueError, KeyError) as e:
         logger.error("Error: %s", e)
         sys.exit(1)
@@ -154,7 +185,10 @@ def run_terrain(path: Path, args: argparse.Namespace) -> None:
 
 def run_diff(path: Path, args: argparse.Namespace) -> None:
     """Print a trajectory divergence report between two batches of the scene
-    JSON at `path`, to stdout."""
+    JSON at `path`, to stdout. With `--fail-on-exceed`, additionally exits
+    with a non-zero code once printing is done: 0 = within thresholds, 1 =
+    usage/parse error, 2 = a threshold was exceeded (see `--fail-on-exceed`'s
+    help text)."""
     from simview import diff as diff_mod
 
     if args.batches is None:
@@ -166,6 +200,16 @@ def run_diff(path: Path, args: argparse.Namespace) -> None:
     if args.json and args.csv:
         logger.error("Error: --json and --csv are mutually exclusive.")
         sys.exit(1)
+    if (
+        args.fail_on_exceed
+        and args.pos_threshold is None
+        and args.rot_threshold_deg is None
+    ):
+        logger.error(
+            "Error: --fail-on-exceed requires --pos-threshold and/or "
+            "--rot-threshold-deg."
+        )
+        sys.exit(1)
 
     try:
         model_data, states_data = diff_mod.load_scene(path)
@@ -193,6 +237,15 @@ def run_diff(path: Path, args: argparse.Namespace) -> None:
     else:
         print(text)
 
+    if args.fail_on_exceed:
+        exceeded = any(
+            body["summary"]["first_frame_exceeding_pos_threshold"] is not None
+            or body["summary"]["first_frame_exceeding_rot_threshold"] is not None
+            for body in result["bodies"].values()
+        )
+        if exceeded:
+            sys.exit(2)
+
 
 def run_render(path: Path, args: argparse.Namespace) -> None:
     """Headlessly render one PNG screenshot of the scene JSON at `path`, for
@@ -249,12 +302,13 @@ def build_parser() -> argparse.ArgumentParser:
         help=(
             "Path(s) to simulation JSON file(s) to visualize, 'clear' to clear "
             "cache, 'info <file>' to print a structural summary of one scene "
-            "file, 'terrain <file>' to query terrain values at a point or over "
-            "an area, 'diff <file>' to compare two batches' trajectories, or "
-            "'render <file>' to headlessly save a PNG screenshot (needs the "
-            "'render' extra). Multiple visualize-mode files are merged into "
-            "one scene, each file's batches appended as extra batches (e.g. a "
-            "real-world recording plus a simulated rerun)."
+            "file, 'terrain <file>' to query terrain values at a point, over "
+            "an area, or along a body's trajectory, 'diff <file>' to compare "
+            "two batches' trajectories, or 'render <file>' to headlessly save "
+            "a PNG screenshot (needs the 'render' extra). Multiple "
+            "visualize-mode files are merged into one scene, each file's "
+            "batches appended as extra batches (e.g. a real-world recording "
+            "plus a simulated rerun)."
         ),
     )
     parser.add_argument(
@@ -287,7 +341,7 @@ def build_parser() -> argparse.ArgumentParser:
         help=(
             "With 'simview terrain <file>', query terrain value(s) at a single "
             "(x, y) point (bilinear-interpolated). Mutually exclusive with "
-            "--area."
+            "--area and --along-body."
         ),
     )
     parser.add_argument(
@@ -299,7 +353,23 @@ def build_parser() -> argparse.ArgumentParser:
             "With 'simview terrain <file>', query terrain values over a "
             "rectangular area: pass no values for the whole terrain extent, "
             "or exactly 4 values 'XMIN XMAX YMIN YMAX' for a sub-box. Mutually "
-            "exclusive with --point."
+            "exclusive with --point and --along-body."
+        ),
+    )
+    parser.add_argument(
+        "--along-body",
+        type=str,
+        default=None,
+        metavar="BODY",
+        help=(
+            "With 'simview terrain <file>', sample terrain value(s) "
+            "bilinear-interpolated at BODY's (x, y) position in every "
+            "sampled state (e.g. friction/stiffness under a robot's driven "
+            "path). BODY is matched the same way as 'simview diff' --body "
+            "(full label, or any single name inside a rigidly-grouped body). "
+            "With --batches A B, samples both batches' terrains along batch "
+            "A's trajectory instead and reports the delta per layer. "
+            "Mutually exclusive with --point and --area."
         ),
     )
     parser.add_argument(
@@ -333,10 +403,11 @@ def build_parser() -> argparse.ArgumentParser:
         metavar=("A", "B"),
         help=(
             "Two batch indices to compare. Required by 'simview diff <file>'. "
-            "With 'simview terrain <file> --point|--area', switches into "
-            "cross-batch diff mode (value_a/value_b/delta per layer) instead "
-            "of a single-batch query, and takes precedence over --batch if "
-            "both are given."
+            "With 'simview terrain <file> --point|--area|--along-body', "
+            "switches into cross-batch diff mode (value_a/value_b/delta per "
+            "layer) instead of a single-batch query, and takes precedence "
+            "over --batch if both are given. For --along-body, both batches' "
+            "terrains are sampled along batch A's trajectory."
         ),
     )
     parser.add_argument(
@@ -355,7 +426,10 @@ def build_parser() -> argparse.ArgumentParser:
         "--every",
         type=int,
         default=1,
-        help="With 'simview diff <file>', sample every Nth frame (default: 1).",
+        help=(
+            "With 'simview diff <file>' or 'simview terrain <file> "
+            "--along-body', sample every Nth frame (default: 1)."
+        ),
     )
     parser.add_argument(
         "--pos-threshold",
@@ -386,6 +460,18 @@ def build_parser() -> argparse.ArgumentParser:
             "the browser Error Metrics panel's per-axis toggle."
         ),
     )
+    parser.add_argument(
+        "--fail-on-exceed",
+        action="store_true",
+        help=(
+            "With 'simview diff <file>', exit with code 2 (after printing the "
+            "normal output) if any diffed body's trajectory exceeds "
+            "--pos-threshold or --rot-threshold-deg; requires at least one of "
+            "them. Exit codes: 0 = within thresholds, 1 = usage/parse error, "
+            "2 = threshold exceeded -- lets scripts/CI tell divergence apart "
+            "from a broken invocation."
+        ),
+    )
     parser.add_argument(
         "--host",
         type=str,

{simview-3.5 → simview-3.6}/simview/info.py

@@ -142,6 +142,7 @@ def _summarize_model(model: dict, warnings: list[str]) -> dict:
         "scalar_names": model.get("scalarNames") or [],
         "dt": model.get("dt"),
         "collapse": model.get("collapse"),
+        "metadata": model.get("metadata"),
         "terrain": _summarize_terrain(terrain) if terrain is not None else None,
         "bodies": {
             "count": len(bodies),
@@ -445,6 +446,12 @@ def format_text(summary: dict) -> str:
         lines.append(f"  Scalars: {', '.join(model['scalar_names']) or '(none)'}")
         lines.append(f"  dt: {model['dt']}   Collapse: {model['collapse']}")
 
+        metadata = model["metadata"]
+        if metadata:
+            lines.append("\nMetadata")
+            for key, value in metadata.items():
+                lines.append(f"  {key}: {value}")
+
         terrain = model["terrain"]
         if terrain is None:
             lines.append("\nTerrain: (none)")

{simview-3.5 → simview-3.6}/simview/model.py

@@ -2,7 +2,7 @@ import base64
 import logging
 from dataclasses import dataclass, field
 from enum import StrEnum
-from typing import Any
+from typing import Any, cast
 
 import numpy as np
 import torch
@@ -488,6 +488,10 @@ class SimViewModel:
     bodies: dict[str, SimViewBody] = field(default_factory=dict)
     static_objects: dict[str, SimViewStaticObject] = field(default_factory=dict)
     batch_names: list[str] | None = None
+    # Free-form, JSON-serializable run provenance (engine name, checkpoint path,
+    # git commit, CLI args, ...) with no meaning to the viewer itself -- just
+    # carried through so a scene saved months ago is still self-describing.
+    metadata: dict[str, Any] | None = None
 
     def __post_init__(self):
         if self.batch_names is not None and len(self.batch_names) != self.batch_size:
@@ -524,14 +528,50 @@ class SimViewModel:
     def create_terrain(
         self,
         heightmap: torch.Tensor,
-        normals: torch.Tensor,
-        x_lim: tuple[float, float],
-        y_lim: tuple[float, float],
+        normals: torch.Tensor | None = None,
+        x_lim: tuple[float, float] | None = None,
+        y_lim: tuple[float, float] | None = None,
+        grid_res: float | None = None,
         friction_map: torch.Tensor | None = None,
         stiffness_map: torch.Tensor | None = None,
     ) -> None:
+        """Adds terrain to the internal simulation model.
+
+        Args:
+            heightmap (torch.Tensor): 2D or 3D tensor of terrain heights.
+            normals (torch.Tensor | None): 3D or 4D tensor of terrain normals. If None,
+                normals are automatically computed from the heightmap gradients.
+            x_lim (tuple[float, float] | None): (min, max) coordinates for the X axis.
+            y_lim (tuple[float, float] | None): (min, max) coordinates for the Y axis.
+            grid_res (float | None): Grid resolution. If x_lim and y_lim are omitted,
+                they will be automatically inferred assuming the grid is centered at 0.
+            friction_map (torch.Tensor | None): Optional friction coefficient map.
+            stiffness_map (torch.Tensor | None): Optional stiffness coefficient map.
+        """
         if heightmap.ndim == 2:
             heightmap = heightmap.unsqueeze(0)  # add batch dim
+
+        if x_lim is None or y_lim is None:
+            if grid_res is None:
+                raise ValueError("Must provide either (x_lim, y_lim) or grid_res")
+            H_dim, W_dim = heightmap.shape[-2:]
+            x_lim = x_lim or (-W_dim * grid_res / 2.0, W_dim * grid_res / 2.0)
+            y_lim = y_lim or (-H_dim * grid_res / 2.0, H_dim * grid_res / 2.0)
+
+        if normals is None:
+            H_dim, W_dim = heightmap.shape[-2:]
+            res_x = (x_lim[1] - x_lim[0]) / W_dim
+            res_y = (y_lim[1] - y_lim[0]) / H_dim
+            dzdy, dzdx = torch.gradient(heightmap, spacing=(res_y, res_x), dim=(-2, -1))
+            nx = -dzdx
+            ny = -dzdy
+            nz = torch.ones_like(nx)
+            computed_normals = torch.stack([nx, ny, nz], dim=-3)
+            computed_normals = computed_normals / torch.linalg.norm(
+                computed_normals, dim=-3, keepdim=True
+            )
+            normals = cast(torch.Tensor, computed_normals.to(dtype=heightmap.dtype))
+
         if normals.ndim == 3:  # channels first
             normals = normals.unsqueeze(0)  # add batch dim
         if friction_map is not None and friction_map.ndim == 2:
@@ -640,6 +680,8 @@ class SimViewModel:
         }
         if self.batch_names is not None:
             r["batchNames"] = self.batch_names
+        if self.metadata is not None:
+            r["metadata"] = self.metadata
         return r
 
     @classmethod
@@ -683,6 +725,7 @@ class SimViewModel:
             bodies=bodies,
             static_objects=static_objects,
             batch_names=d.get("batchNames"),
+            metadata=d.get("metadata"),
         )
 
     @property

{simview-3.5 → simview-3.6}/simview/scene.py

@@ -165,10 +165,17 @@ class SimulationScene:
         bodies: dict[str, SimViewBody] | None = None,
         static_objects: dict[str, SimViewStaticObject] | None = None,
         batch_names: list[str] | None = None,
+        metadata: dict[str, Any] | None = None,
     ) -> None:
         """
         Initializes the simulation data container.
         Manages the SimViewModel and the time-series states.
+
+        `metadata` is free-form, JSON-serializable run provenance (e.g. engine
+        name, checkpoint path, git commit, CLI args) with no meaning to the
+        viewer -- it's carried through to `simview info` and the browser so a
+        saved scene stays self-describing. Can also be set/updated later via
+        `self.model.metadata`.
         """
         self.model = SimViewModel(
             batch_size=batch_size,
@@ -179,6 +186,7 @@ class SimulationScene:
             bodies=bodies if bodies is not None else {},
             static_objects=static_objects if static_objects is not None else {},
             batch_names=batch_names,
+            metadata=metadata,
         )
         self.states: list[dict] = []
 
@@ -208,6 +216,7 @@ class SimulationScene:
             bodies=model.bodies,
             static_objects=model.static_objects,
             batch_names=model.batch_names,
+            metadata=model.metadata,
         )
         scene.states = list(states)
         return scene
@@ -515,18 +524,32 @@ class SimulationScene:
     def create_terrain(
         self,
         heightmap: torch.Tensor,
-        normals: torch.Tensor,
-        x_lim: tuple[float, float],
-        y_lim: tuple[float, float],
+        normals: torch.Tensor | None = None,
+        x_lim: tuple[float, float] | None = None,
+        y_lim: tuple[float, float] | None = None,
+        grid_res: float | None = None,
         friction_map: torch.Tensor | None = None,
         stiffness_map: torch.Tensor | None = None,
     ) -> None:
-        """Adds terrain to the simulation model."""
+        """Adds terrain to the simulation model.
+
+        Args:
+            heightmap (torch.Tensor): 2D or 3D tensor of terrain heights.
+            normals (torch.Tensor | None): 3D or 4D tensor of terrain normals. If None,
+                normals are automatically computed from the heightmap gradients.
+            x_lim (tuple[float, float] | None): (min, max) coordinates for the X axis.
+            y_lim (tuple[float, float] | None): (min, max) coordinates for the Y axis.
+            grid_res (float | None): Grid resolution. If x_lim and y_lim are omitted,
+                they will be automatically inferred assuming the grid is centered at 0.
+            friction_map (torch.Tensor | None): Optional friction coefficient map.
+            stiffness_map (torch.Tensor | None): Optional stiffness coefficient map.
+        """
         self.model.create_terrain(
             heightmap,
-            normals,
-            x_lim,
-            y_lim,
+            normals=normals,
+            x_lim=x_lim,
+            y_lim=y_lim,
+            grid_res=grid_res,
             friction_map=friction_map,
             stiffness_map=stiffness_map,
         )

{simview-3.5 → simview-3.6}/simview/static/js/SimView.js

@@ -12,6 +12,7 @@ import { StaticObject } from "./objects/StaticObject.js";
 import { Legend } from "./ui/Legend.js";
 import { BatchLegend } from "./ui/BatchLegend.js";
 import { ErrorMetrics } from "./ui/ErrorMetrics.js";
+import { TerrainProfile } from "./ui/TerrainProfile.js";
 import { AnalysisPanel } from "./ui/AnalysisPanel.js";
 import { InteractionController } from "./components/InteractionController.js";
 import { buildBodyMeta, resolveStateBodies, topoSortBodies } from "./utils/bodyTransforms.js";
@@ -33,6 +34,7 @@ export class SimView {
         this.animationController = null;
         this.scalarPlotter = null;
         this.errorMetrics = null;
+        this.terrainProfile = null;
         this.analysisPanel = null;
         this.legend = null;
         this.batchLegend = null;
@@ -325,6 +327,11 @@ export class SimView {
         try {
             this.disposeOfAll();
 
+            // Free-form run provenance carried through from the Python side
+            // (see SimViewModel.metadata) -- no meaning to the viewer itself,
+            // just displayed read-only in the "Scene Info" GUI folder.
+            this.metadata = model.metadata ?? null;
+
             this.batchManager = new BatchManager(this, model);
             this.bodies = new Map();
 
@@ -367,7 +374,10 @@ export class SimView {
             }
             const hasScalars = model.scalarNames && model.scalarNames.length > 0;
             const hasErrorMetrics = this.batchManager.simBatches >= 2;
-            if (hasScalars || hasErrorMetrics) {
+            // Terrain tab needs an actual body path to sample against, so it's
+            // skipped for a scene with terrain but no bodies.
+            const hasTerrainProfile = !!this.terrain && this.bodies && this.bodies.size > 0;
+            if (hasScalars || hasErrorMetrics || hasTerrainProfile) {
                 this.analysisPanel = new AnalysisPanel(this);
             }
             if (hasScalars) {
@@ -382,6 +392,10 @@ export class SimView {
                 this.errorMetrics = new ErrorMetrics(this);
                 this.analysisPanel.attachErrorMetrics(this.errorMetrics);
             }
+            if (hasTerrainProfile) {
+                this.terrainProfile = new TerrainProfile(this);
+                this.analysisPanel.attachTerrainProfile(this.terrainProfile);
+            }
             this.interactionController = new InteractionController(this);
             this.uiControls = new UIControls(this);
             this.bodyStateWindow = new BodyStateWindow(this);
@@ -509,6 +523,10 @@ export class SimView {
             this.errorMetrics.dispose();
             this.errorMetrics = null;
         }
+        if (this.terrainProfile) {
+            this.terrainProfile.dispose();
+            this.terrainProfile = null;
+        }
         if (this.analysisPanel) {
             this.analysisPanel.dispose();
             this.analysisPanel = null;
@@ -548,6 +566,9 @@ export class SimView {
         if (this.errorMetrics) {
             this.errorMetrics.animate(now);
         }
+        if (this.terrainProfile) {
+            this.terrainProfile.animate(now);
+        }
 
         // 3. Render the scene
         if (this.scene) {

{simview-3.5 → simview-3.6}/simview/static/js/components/BatchManager.js

@@ -79,6 +79,7 @@ export class BatchManager {
         this._persistBatchNames();
         if (this.app.batchLegend) this.app.batchLegend.refresh();
         if (this.app.errorMetrics) this.app.errorMetrics.refreshBatchLabels();
+        if (this.app.terrainProfile) this.app.terrainProfile.refreshBatchLabels();
     }
 
     async _persistBatchNames() {

{simview-3.5 → simview-3.6}/simview/static/js/config.js

@@ -26,6 +26,7 @@ export const FREQ_CONFIG = {
     bodyStateWindow: 30,
     playbackControls: 20,
     errorMetrics: 20,
+    terrainProfile: 20,
 };
 
 export const CONTROLS_CONFIG = {

{simview-3.5 → simview-3.6}/simview/static/js/ui/AnalysisPanel.js

@@ -11,6 +11,7 @@ export class AnalysisPanel {
         this.mode = "scalars";
         this.scalarPlotter = null;
         this.errorMetrics = null;
+        this.terrainProfile = null;
         this.modeTabElements = {};
 
         this._injectStyles();
@@ -132,15 +133,19 @@ export class AnalysisPanel {
         this.modeTabBar.className = "analysis-mode-tab-bar";
         this.modeTabElements.scalars = this._addModeTab("Scalars", "scalars");
         this.modeTabElements.errorMetrics = this._addModeTab("Error Metrics", "errorMetrics");
+        this.modeTabElements.terrain = this._addModeTab("Terrain", "terrain");
 
         this.scalarsSection = document.createElement("div");
         this.scalarsSection.className = "analysis-section";
         this.errorMetricsSection = document.createElement("div");
         this.errorMetricsSection.className = "analysis-section";
+        this.terrainSection = document.createElement("div");
+        this.terrainSection.className = "analysis-section";
 
         this.content.appendChild(this.modeTabBar);
         this.content.appendChild(this.scalarsSection);
         this.content.appendChild(this.errorMetricsSection);
+        this.content.appendChild(this.terrainSection);
         this.container.appendChild(this.header);
         this.container.appendChild(this.content);
         document.body.appendChild(this.container);
@@ -168,20 +173,45 @@ export class AnalysisPanel {
         this._refreshLayout();
     }
 
+    attachTerrainProfile(terrainProfile) {
+        this.terrainProfile = terrainProfile;
+        this.terrainSection.appendChild(terrainProfile.content);
+        this._refreshLayout();
+    }
+
+    // Sections currently attached, in tab order -- drives the tab bar
+    // (shown whenever >= 2 are attached, with individual tabs for any
+    // sections not attached hidden), the title fallback (the lone
+    // section's own title when only one is attached), and which mode a
+    // stale `this.mode` falls back to if its section gets detached.
+    _sections() {
+        return [
+            { key: "scalars", instance: this.scalarPlotter, title: "Scalars" },
+            { key: "errorMetrics", instance: this.errorMetrics, title: "Error Metrics" },
+            { key: "terrain", instance: this.terrainProfile, title: "Terrain" },
+        ];
+    }
+
     _refreshLayout() {
-        const hasScalars = !!this.scalarPlotter;
-        const hasErrorMetrics = !!this.errorMetrics;
-        const showModeBar = hasScalars && hasErrorMetrics;
+        const sections = this._sections();
+        const attached = sections.filter((s) => !!s.instance);
+        const showModeBar = attached.length >= 2;
         this.modeTabBar.classList.toggle("visible", showModeBar);
 
-        if (!hasScalars) this.mode = "errorMetrics";
-        else if (!hasErrorMetrics) this.mode = "scalars";
+        for (const section of sections) {
+            const tab = this.modeTabElements[section.key];
+            if (tab) tab.style.display = section.instance ? "" : "none";
+        }
+
+        if (!attached.some((s) => s.key === this.mode)) {
+            this.mode = attached[0] ? attached[0].key : this.mode;
+        }
 
         this.titleEl.textContent = showModeBar
             ? "Analysis"
-            : hasErrorMetrics
-              ? "Error Metrics"
-              : "Scalars";
+            : attached[0]
+              ? attached[0].title
+              : "Analysis";
 
         this._applyMode();
     }
@@ -192,23 +222,14 @@ export class AnalysisPanel {
             "visible",
             this.mode === "errorMetrics"
         );
-        if (this.modeTabElements.scalars) {
-            this.modeTabElements.scalars.classList.toggle(
-                "active",
-                this.mode === "scalars"
-            );
-        }
-        if (this.modeTabElements.errorMetrics) {
-            this.modeTabElements.errorMetrics.classList.toggle(
-                "active",
-                this.mode === "errorMetrics"
-            );
-        }
-        if (this.scalarPlotter) {
-            this.scalarPlotter.setVisible(this.isExpanded && this.mode === "scalars");
-        }
-        if (this.errorMetrics) {
-            this.errorMetrics.setVisible(this.isExpanded && this.mode === "errorMetrics");
+        this.terrainSection.classList.toggle("visible", this.mode === "terrain");
+
+        for (const section of this._sections()) {
+            const tab = this.modeTabElements[section.key];
+            if (tab) tab.classList.toggle("active", this.mode === section.key);
+            if (section.instance) {
+                section.instance.setVisible(this.isExpanded && this.mode === section.key);
+            }
         }
     }