simview 4.2.0__tar.gz → 4.2.1__tar.gz

{simview-4.2.0/simview.egg-info → simview-4.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simview
-Version: 4.2.0
+Version: 4.2.1
 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-4.2.0 → simview-4.2.1}/pyproject.toml

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

{simview-4.2.0 → simview-4.2.1}/simview/static/js/SimView.js

@@ -383,6 +383,10 @@ export class SimView {
             }
         }
         this.appendBodyHistories(0);
+        // Whether a point-cloud body is listed depends on whether it turned
+        // out to carry per-frame data, which is only knowable now that
+        // appendBodyHistories has run (see BodyStateWindow.updateBodyList).
+        if (this.bodyStateWindow) this.bodyStateWindow.updateBodyList();
         if (this.errorMetrics) {
             this.errorMetrics.onHistoryReady();
         }
@@ -464,12 +468,18 @@ export class SimView {
             this.batchManager = new BatchManager(this, model);
             this.bodies = new Map();
 
-            // Auto-detect visualization mode based on first body: anything with a
-            // real surface (box/sphere/cylinder/mesh) defaults to mesh; pointclouds
-            // keep the default points mode.
+            // Auto-detect visualization mode from the first body the mode
+            // actually governs: anything with a real surface
+            // (box/sphere/cylinder/mesh) defaults to mesh. Point clouds are
+            // skipped rather than inspected -- they're outside the mode
+            // entirely (see Body#pointsVisible), and model.bodies[0] being a
+            // cloud must not leave a scene full of meshes defaulting to a
+            // mode that renders none of them.
             if (Array.isArray(model.bodies) && model.bodies.length > 0) {
-                const firstShape = model.bodies[0].shape;
-                if (firstShape && firstShape.type !== "pointcloud") {
+                const firstSolid = model.bodies.find(
+                    (b) => b.shape && b.shape.type !== "pointcloud"
+                );
+                if (firstSolid) {
                     console.log("Auto-switching visualization mode to 'mesh' based on body type");
                     this.uiState.bodyVisualizationMode = "mesh";
                 }
@@ -498,6 +508,9 @@ export class SimView {
                 console.debug("Using terrain data");
                 this.terrain = new Terrain(model.terrain, this);
                 this.scene.addObject3D(this.terrain.getObject3D());
+                // Terrain extent is what tells us how far this scene reaches,
+                // so the camera's clipping/orbit range can stop being a guess.
+                this.scene.applySceneExtent(this.terrain.bounds);
             } else {
                 throw new Error("Terrain data is missing in model");
             }

{simview-4.2.0 → simview-4.2.1}/simview/static/js/components/Scene.js

@@ -4,8 +4,10 @@ import {
     SCENE_CONFIG,
     RENDERER_CONFIG,
     CAMERA_CONFIG,
+    CONTROLS_CONFIG,
     LIGHTING_CONFIG,
 } from "../config.js";
+import { cameraRangeForBounds } from "../utils/cameraRange.js";
 
 export class Scene {
     constructor(app) {
@@ -31,6 +33,22 @@ export class Scene {
         this.setupWindowHandlers();
     }
 
+    // Sizes the camera's far plane and the orbit distance limit to the scene
+    // actually being viewed. Called once the terrain is known (see
+    // SimView.initFromModel) -- the config defaults are floors chosen for
+    // small scenes, and a several-hundred-metre recording clips against them.
+    applySceneExtent(bounds) {
+        const { far, maxDistance } = cameraRangeForBounds(bounds, {
+            far: CAMERA_CONFIG.far,
+            maxDistance: CONTROLS_CONFIG.maxDistance,
+        });
+        if (this.camera && this.camera.far !== far) {
+            this.camera.far = far;
+            this.camera.updateProjectionMatrix();
+        }
+        if (this.controls) this.controls.maxDistance = maxDistance;
+    }
+
     setupWindowHandlers() {
         window.addEventListener("resize", () => this.#handleWindowResize());
         window.addEventListener("error", (event) => this.#handleError(event));

{simview-4.2.0 → simview-4.2.1}/simview/static/js/config.js

@@ -1,5 +1,9 @@
 export const UI_DEFAULT_CONFIG = {
     bodyVisualizationMode: "points",
+    // Point-cloud bodies sit outside Body Visualization Mode (a cloud isn't a
+    // way of drawing a body, it's the whole object), so they get their own
+    // visibility toggle -- see Body#pointsVisible.
+    pointCloudsVisible: true,
     axesVisible: false,
     trailsVisible: false,
     smoothInterpolation: true,
@@ -31,6 +35,8 @@ export const FREQ_CONFIG = {
 
 export const CONTROLS_CONFIG = {
     minDistance: 1,
+    // Also a floor, widened alongside the far plane so the whole scene can
+    // actually be framed on a large map (see Scene.applySceneExtent).
     maxDistance: 500,
     enableDamping: false,
     dampingFactor: 0.05,
@@ -58,6 +64,9 @@ export const RENDERER_CONFIG = {
 export const CAMERA_CONFIG = {
     fov: 40,
     near: 0.1,
+    // A floor, not the final value: widened at load to span the terrain
+    // extent, so scenes hundreds of metres across don't clip their own
+    // terrain and bodies away (see Scene.applySceneExtent).
     far: 500,
     position: [-15, -15, 10],
     up: [0, 0, 1],

{simview-4.2.0 → simview-4.2.1}/simview/static/js/objects/Body.js

@@ -86,6 +86,10 @@ export class Body {
         this.bodyVectors = [];
         this.contactPoints = [];
         this.contactPointSizes = [];
+        // A point cloud is its own kind of object rather than a body drawn
+        // "as points", so it stays out of Body Visualization Mode entirely --
+        // "none" included -- and follows setPointCloudsVisible instead.
+        this.isPointCloud = bodyData.shape?.type === "pointcloud";
         this.representations = { mesh: [], wireframe: [], points: [] };
         this.createBatchGroups(bodyData);
 
@@ -356,8 +360,7 @@ export class Body {
             if (this.batchGroups[i]) this.batchGroups[i].visible = visible;
             const pointsRep = this.representations["points"];
             if (Array.isArray(pointsRep) && pointsRep[i]) {
-                pointsRep[i].visible =
-                    visible && this.app.uiState.bodyVisualizationMode === "points";
+                pointsRep[i].visible = visible && this.#pointsVisible();
             }
             if (this.contactPoints[i]) {
                 this.contactPoints[i].visible =
@@ -370,6 +373,26 @@ export class Body {
         this.updateAllInstances();
     }
 
+    // Should this body's points be on screen right now? A point-cloud body
+    // answers to its own "Show Point Clouds" toggle; every other body's
+    // points are one of its visualization modes, like mesh and wireframe.
+    #pointsVisible() {
+        return this.isPointCloud
+            ? this.app.uiState.pointCloudsVisible !== false
+            : this.app.uiState.bodyVisualizationMode === "points";
+    }
+
+    // Applies the "Show Point Clouds" toggle. A no-op on bodies that aren't
+    // point clouds -- their points belong to the visualization mode instead.
+    setPointCloudsVisible(visible) {
+        if (!this.isPointCloud) return;
+        const pointsRep = this.representations["points"];
+        if (!Array.isArray(pointsRep)) return;
+        pointsRep.forEach((points, i) => {
+            if (points) points.visible = visible && this.#isBatchVisible(i);
+        });
+    }
+
     #isBatchVisible(batchIndex) {
         const batchManager = this.app.batchManager;
         return batchManager?.isBatchVisible
@@ -415,7 +438,7 @@ export class Body {
             this.pointColors
         );
         if (!points) return;
-        points.visible = this.app.uiState.bodyVisualizationMode === "points";
+        points.visible = this.#pointsVisible();
         // Lets InteractionController resolve a raycast hit back to this
         // body/batch without a reverse lookup.
         points.userData.bodyName = this.name;
@@ -463,6 +486,15 @@ export class Body {
 
             const instancedMesh = new THREE.InstancedMesh(source, material, this.simBatches);
             instancedMesh.instanceMatrix.setUsage(THREE.DynamicDrawUsage);
+            // Instances are placed by setMatrixAt (see updateInstanceMatrix),
+            // which leaves this object's own matrixWorld at identity. THREE
+            // computes an InstancedMesh's bounding sphere lazily on the first
+            // frustum test and then caches it forever -- instanceMatrix.needsUpdate
+            // does not invalidate it -- so bodies that travel away from wherever
+            // they started get culled wholesale once that stale sphere leaves the
+            // frustum. Skip the test rather than recomputing the sphere every
+            // frame across every batch; trails do the same for the same reason.
+            instancedMesh.frustumCulled = false;
             instancedMesh.visible = this.app.uiState.bodyVisualizationMode === type;
             instancedMesh.castShadow = (type === "mesh");
             instancedMesh.receiveShadow = (type === "mesh");
@@ -696,6 +728,9 @@ export class Body {
 
     updateVisualizationMode(mode) {
         for (const [type, obj] of Object.entries(this.representations)) {
+            // A point cloud isn't one of the modes, so nothing the mode
+            // switch does -- including "none" -- should touch it.
+            if (type === "points" && this.isPointCloud) continue;
             if (obj instanceof THREE.InstancedMesh) {
                 obj.visible = type === mode;
             } else if (Array.isArray(obj)) {
@@ -804,7 +839,12 @@ export class Body {
 
     // Which of the mesh/wireframe/points representations this body actually has,
     // so the UI can only offer visualization modes that will show something.
+    // A point-cloud body reports none: its cloud is the object itself, not a
+    // way of drawing it, and it has its own toggle (see #pointsVisible). That
+    // keeps "points" out of the dropdown unless some body really does carry
+    // body-points, which is what made selecting it blank out every mesh body.
     getAvailableVisualizationModes() {
+        if (this.isPointCloud) return [];
         const modes = [];
         for (const type of ["mesh", "wireframe", "points"]) {
             const rep = this.representations[type];

{simview-4.2.0 → simview-4.2.1}/simview/static/js/ui/BodyStateWindow.js

@@ -310,7 +310,12 @@ export class BodyStateWindow {
         const list = document.createElement("ul");
         list.classList.add("body-list"); // Use CSS class
 
-        for (const name of this.app.bodies.keys()) {
+        for (const [name, body] of this.app.bodies) {
+            // A point cloud with no per-frame data is a static prop, not a
+            // body with a pose worth reading -- listing it only offers a
+            // permanently-zero Position/Rotation row. One that does move
+            // (validStates > 0) stays listed like any other body.
+            if (body.isPointCloud && !(body.validStates > 0)) continue;
             const item = document.createElement("li");
             item.classList.add("body-list-item"); // Use CSS class
             item.textContent = name;

{simview-4.2.0 → simview-4.2.1}/simview/static/js/ui/Controls.js

@@ -8,6 +8,7 @@ export class UIControls {
         this.app = app;
         this.attributeAvailability = this.determineAttributeAvailability();
         this.visualizationModes = this.determineAvailableVisualizationModes();
+        this.hasPointClouds = this.determineHasPointClouds();
         this.gui = this.createDatGUI();
         this.keyboardControlsListener = null;
         this.setupKeyboardControls(app);
@@ -44,15 +45,27 @@ export class UIControls {
 
     // Union of visualization modes actually available across all bodies, plus a
     // "none" option to hide bodies entirely (e.g. for terrain-only viewing).
+    // Point-cloud bodies contribute nothing and are unaffected by the mode --
+    // they have their own toggle -- so a scene of nothing but point clouds
+    // gets no mode control at all rather than a dropdown that only hides things.
     determineAvailableVisualizationModes() {
         const modes = new Set();
         this.app.bodies.forEach((body) => {
             body.getAvailableVisualizationModes().forEach((m) => modes.add(m));
         });
+        if (modes.size === 0) return [];
         modes.add("none");
         return [...modes];
     }
 
+    determineHasPointClouds() {
+        let found = false;
+        this.app.bodies.forEach((body) => {
+            if (body.isPointCloud) found = true;
+        });
+        return found;
+    }
+
     changeTargetBatch(key) {
         const { scene, batchManager } = this.app;
         const currentBatchTarget = batchManager.currentlyActiveBatch;
@@ -98,7 +111,10 @@ export class UIControls {
         // Only show body-related controls when there's actually a body to control
         if (this.app.bodies && this.app.bodies.size > 0) {
             let defaultVisualizationMode = this.app.uiState.bodyVisualizationMode;
-            if (!this.visualizationModes.includes(defaultVisualizationMode)) {
+            if (
+                this.visualizationModes.length > 0 &&
+                !this.visualizationModes.includes(defaultVisualizationMode)
+            ) {
                 defaultVisualizationMode =
                     this.visualizationModes.find((m) => m !== "none") || "none";
                 this.app.uiState.bodyVisualizationMode = defaultVisualizationMode;
@@ -106,6 +122,7 @@ export class UIControls {
 
             const controls = {
                 bodyVisualizationMode: defaultVisualizationMode,
+                showPointClouds: this.app.uiState.pointCloudsVisible !== false,
                 showAxes: this.app.uiState.axesVisible,
                 showTrails: this.app.uiState.trailsVisible,
                 smoothInterpolation: this.app.uiState.smoothInterpolation,
@@ -118,12 +135,24 @@ export class UIControls {
 
             this.bodyFolder = this.gui.addFolder("Body Options");
 
-            this.bodyFolder
-                .add(controls, "bodyVisualizationMode", this.visualizationModes)
-                .name("Body Visualization Mode (B)")
-                .onChange((value) => {
-                    this.updateVisualizationMode(value);
-                });
+            // Nothing to switch between when every body is a point cloud.
+            if (this.visualizationModes.length > 0) {
+                this.bodyFolder
+                    .add(controls, "bodyVisualizationMode", this.visualizationModes)
+                    .name("Body Visualization Mode (B)")
+                    .onChange((value) => {
+                        this.updateVisualizationMode(value);
+                    });
+            }
+
+            if (this.hasPointClouds) {
+                this.bodyFolder
+                    .add(controls, "showPointClouds")
+                    .name("Show Point Clouds")
+                    .onChange((value) => {
+                        this.updatePointCloudsVisibility(value);
+                    });
+            }
 
             this.bodyFolder
                 .add(controls, "showAxes")
@@ -629,6 +658,7 @@ export class UIControls {
                 switch (event.key.toLowerCase()) {
                     case "b":
                         const modes = this.visualizationModes;
+                        if (modes.length === 0) break;
                         const currentIndex = modes.indexOf(
                             this.app.uiState.bodyVisualizationMode
                         );
@@ -710,6 +740,15 @@ export class UIControls {
         this.app.uiState.bodyVisualizationMode = mode;
     }
 
+    // Point-cloud bodies are outside Body Visualization Mode (see
+    // Body#pointsVisible), so their visibility rides on this instead.
+    updatePointCloudsVisibility(visible) {
+        this.app.uiState.pointCloudsVisible = visible;
+        this.app.bodies.forEach((body) => {
+            if (body.setPointCloudsVisible) body.setPointCloudsVisible(visible);
+        });
+    }
+
     updateAxesVisibility(show) {
         this.app.bodies.forEach((body) => {
             body.toggleAxes(show);

{simview-4.2.0 → simview-4.2.1}/simview/static/js/ui/ScalarPlotter.js

@@ -391,6 +391,16 @@ export class ScalarPlotter {
         );
     }
 
+    // uPlot walks `incrs` and takes the first increment whose ticks fit the
+    // axis's available length. Offering exactly one (range/stepsPerYAxis) meant
+    // that in a short panel -- which is what the Analysis panel gives us -- no
+    // increment fit, and uPlot drew no ticks or labels at all. Coarser
+    // multiples let it degrade instead of giving up.
+    _yIncrements(min, max) {
+        const base = this.getChartInterval(min, max);
+        return [1, 2, 5, 10, 20, 50, 100].map((m) => base * m);
+    }
+
     getChartInterval(min, max) {
         const diff = max - min;
         if (diff === 0)
@@ -419,6 +429,17 @@ export class ScalarPlotter {
         return bestBatch;
     }
 
+    // The x extent every chart's scale is pinned to: the whole timeline. Falls
+    // back to a unit span when there are no times, so uPlot is never handed
+    // NaN/undefined bounds.
+    _timeExtent() {
+        const n = this.times?.length ?? 0;
+        if (n === 0) return [0, 1];
+        const first = this.times[0];
+        const last = this.times[n - 1];
+        return last > first ? [first, last] : [first, first + 1];
+    }
+
     _initializePlots() {
         const limOffset = 1e-2;
         this.scalarNames.forEach((name) => {
@@ -445,7 +466,15 @@ export class ScalarPlotter {
                     padding: [8, 8, 0, 8],
                     series,
                     scales: {
-                        x: { time: false, min: this.times[0], max: this.times[this.times.length - 1] },
+                        // uPlot treats a scale's `min`/`max` as outputs, not as
+                        // a pin: the initial autoscale over the empty data
+                        // passed below nulls them, and every later update goes
+                        // through setData(data, false), which never revisits x.
+                        // That left x null forever -- valToPos NaN, nothing
+                        // drawn. `range` is the actual pin (the same thing
+                        // ErrorMetrics does), and this axis is meant to span the
+                        // whole timeline regardless, with the line growing into it.
+                        x: { time: false, range: () => this._timeExtent() },
                         y: { min, max },
                     },
                     axes: [
@@ -463,7 +492,7 @@ export class ScalarPlotter {
                             ticks: { stroke: "rgb(73, 73, 73)" },
                             font: "12px Arial",
                             space: 30,
-                            incrs: [this.getChartInterval(min, max)],
+                            incrs: this._yIncrements(min, max),
                         },
                     ],
                     legend: { show: false },
@@ -667,7 +696,10 @@ export class ScalarPlotter {
         }
 
         if (!needRender) return;
-        activeChart.redraw(false, true);
+        // rebuildPaths must be true: the series data changes on every frame of
+        // playback, and redrawing without rebuilding just repaints the paths
+        // built for whatever data the chart first saw.
+        activeChart.redraw(true, true);
     }
 
     animate(now) {

simview-4.2.1/simview/static/js/utils/cameraRange.js

@@ -0,0 +1,37 @@
+// How far the camera has to see, and how far out it may orbit, for a scene of
+// a given horizontal extent. Pure arithmetic, no THREE/DOM, so it's unit
+// testable on its own (see tests/js/cameraRange.test.js).
+//
+// The defaults in config.js are sized for the small scenes SimView started
+// with (a few tens of metres). On a real recording -- a robot driving a few
+// hundred metres across a mapped terrain -- a fixed 500 m far plane clips the
+// terrain, and a fixed 500 m orbit limit means the whole run can never be
+// framed at once. Both are treated as floors and widened from the terrain
+// bounds instead.
+
+// Framing a scene of diameter D at SimView's ~40 degree vertical FOV needs the
+// camera roughly D / (2 * tan(fov/2)) ~= 1.4 * D away from the centre, so the
+// orbit limit is 1.5 * D and the far plane covers that viewpoint plus the far
+// side of the scene (2.5 * D), with a little margin on top.
+const ORBIT_FACTOR = 1.5;
+const FAR_FACTOR = 3;
+
+export function cameraRangeForBounds(bounds, defaults = {}) {
+    const far = Number.isFinite(defaults.far) ? defaults.far : 0;
+    const maxDistance = Number.isFinite(defaults.maxDistance)
+        ? defaults.maxDistance
+        : 0;
+    const fallback = { far, maxDistance };
+
+    if (!bounds || typeof bounds !== "object") return fallback;
+    const { minX, maxX, minY, maxY } = bounds;
+    if (![minX, maxX, minY, maxY].every((v) => Number.isFinite(v))) return fallback;
+
+    const diagonal = Math.hypot(maxX - minX, maxY - minY);
+    if (!(diagonal > 0)) return fallback;
+
+    return {
+        far: Math.max(far, diagonal * FAR_FACTOR),
+        maxDistance: Math.max(maxDistance, diagonal * ORBIT_FACTOR),
+    };
+}

{simview-4.2.0 → simview-4.2.1}/simview/static/js/utils/viewState.js

@@ -30,6 +30,12 @@ const BOOLEAN_FLAG_KEYS = [
     "terrainVisualizationModes.normals",
 ];
 
+// Deliberately NOT in the list above: `pointCloudsVisible`. Appending only
+// works for flags that default off -- a link made before the flag existed has
+// no bit for it, which decodes as false, so a default-on flag would arrive
+// switched off and hide point clouds on every old link. Adding it needs a
+// format version that can tell "absent" from "false".
+
 function getPath(obj, path) {
     return path.split(".").reduce((o, k) => (o && typeof o === "object" ? o[k] : undefined), obj);
 }

{simview-4.2.0 → simview-4.2.1/simview.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simview
-Version: 4.2.0
+Version: 4.2.1
 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-4.2.0 → simview-4.2.1}/simview.egg-info/SOURCES.txt

@@ -56,6 +56,7 @@ simview/static/js/utils/batchVisibility.js
 simview/static/js/utils/blobCodec.js
 simview/static/js/utils/blobWindow.js
 simview/static/js/utils/bodyTransforms.js
+simview/static/js/utils/cameraRange.js
 simview/static/js/utils/csv.js
 simview/static/js/utils/episodes.js
 simview/static/js/utils/errorMath.js