* Update setting and refresh as needed

* Whether the current background is light (luminance > 0.5)

* Update frustum rendering based on current settings

* Create a 4x4 transformation matrix from position and Euler angles

* Format poses array with 4 numbers per line (one row per line) * This matches the placeholder example format

* Update the scene with multiple trajectories. * @param {Array} trajectories - Array of { id, name, poses, count, visible }

* Deep clone a 4x4 matrix

* Compute the bounding box of all camera positions

* Convert an array of poses to Three.js format * @param {Array} poses - Array of 4x4 matrices * @param {string} poseFormat - 'c2w' or 'w2c'

* Dispose of Three.js objects to prevent memory leaks

* Fit the camera to view all frustums

* Generate a sample pose sequence for testing * @param {number} count - Number of poses * @param {string} pattern - 'circle', 'line', 'helix

* Get statistics about the current scene

* Convert from OpenCV to OpenGL coordinate convention * OpenCV: X-right, Y-down, Z-forward (camera looks down +Z) * OpenGL: X-right, Y-up, Z

* Split input into separate trajectory blocks * Blocks are separated by blank lines (lines with only whitespace) * # comment lines before br

* Update trajectories without resetting the view (for format/convention changes)

* Validate and convert parsed data to [T, 4, 4] format * @param {Array} data * @param {string} format * @returns {Object} - { valid:

* Animation loop

* Cancel an in-progress export

* Clear all trajectory groups from the scene

* Compute the diagonal length of the bounding box

* Create a camera frustum geometry * @param {Array} poseMatrix - 4x4 transformation matrix * @param {number} index - Frame index within traj

* Create an identity 4x4 matrix

* Export the visualization as a video. * Animates frames appearing one by one (first to last), then holds.

* Extract trajectory name from a # comment line at the start of a block * @param {string} block - The block content * @param {number} index

* Extract position from a 4x4 transformation matrix

* Invert a 4x4 transformation matrix * For rigid body transformations: [R|t] -> [R^T | -R^T * t]

* Handle double click to focus on a point

* Handle window resize

* Parse a Python-like list string into a JavaScript array * Supports nested arrays, numbers (including scientific notation), and basic Python syn

* Parse multiple trajectories from input (separated by blank lines) * Supports optional trajectory names via # comment lines before each block.

* Parse Python list notation that might not be valid JSON * @param {string} input * @returns {Array}

* Preprocess input string to make it more JSON-compatible * @param {string} input * @returns {string}

* Convert position and quaternion to 4x4 matrix

* Reset the camera view

* Set visibility of a specific trajectory

* Convert a JavaScript 4x4 array to Three.js Matrix4

* Convert a single 4x4 pose matrix to camera-to-world format in OpenGL convention * This is the target format for Three.js visualization * @

* Extract rotation matrix (3x3) from a 4x4 transformation matrix

* Get the color for a trajectory (for UI display)

* Convert from OpenGL to OpenCV coordinate convention * This is the inverse operation of opencvToOpengl. * Since diag(1,-1,-1,1) is its own

* Legacy: Update the scene with single trajectory (for backward compatibility)

* Convert pose array to formatted string for display

* Legacy: Update poses without resetting view (for backward compatibility)