refactor!: Implementing RealVectorState in JS/WASM

juniorsundar · juniorsundar · commit 438c9a98a02b · 2025-11-15T23:23:21.000+04:00
diff --git a/oxmpl-js/src/base/mod.rs b/oxmpl-js/src/base/mod.rs
@@ -7,12 +7,14 @@ pub mod js_state_convert;
 pub mod path;
 pub mod planner;
 pub mod problem_definition;
+pub mod real_vector_state;
 pub mod real_vector_state_space;
 pub mod state_validity_checker;
 
 pub use goal::JsGoal;
 pub use path::JsPath;
 pub use planner::JsPlannerConfig;
 pub use problem_definition::JsProblemDefinition;
+pub use real_vector_state::JsRealVectorState;
 pub use real_vector_state_space::JsRealVectorStateSpace;
 pub use state_validity_checker::JsStateValidityChecker;
diff --git a/oxmpl-js/src/base/path.rs b/oxmpl-js/src/base/path.rs
@@ -2,8 +2,7 @@
 //
 // SPDX-License-Identifier: BSD-3-Clause
 
-use crate::base::js_state_convert::*;
-use js_sys::Float64Array;
+use js_sys::Array;
 use oxmpl::base::{planner::Path, state::RealVectorState};
 use wasm_bindgen::prelude::*;
 
@@ -16,11 +15,21 @@ pub struct JsPath {
 #[wasm_bindgen(js_class = Path)]
 impl JsPath {
     #[wasm_bindgen(js_name = getStates)]
-    pub fn get_states(&self) -> Vec<Float64Array> {
-        self.states.0.iter().map(state_to_js_array).collect()
+    pub fn get_states(&self) -> Array {
+        self.states
+            .0
+            .iter()
+            .map(|s| {
+                s.values
+                    .iter()
+                    .map(|&v| JsValue::from_f64(v))
+                    .collect::<Array>()
+            })
+            .collect::<Array>()
     }
 
-    pub fn length(&self) -> usize {
+    #[wasm_bindgen(js_name = getLength)]
+    pub fn get_length(&self) -> usize {
         self.states.0.len()
     }
 }
diff --git a/oxmpl-js/src/base/problem_definition.rs b/oxmpl-js/src/base/problem_definition.rs
@@ -20,7 +20,7 @@ impl JsProblemDefinition {
     pub fn new(space: &JsRealVectorStateSpace, start: Vec<f64>, goal: JsGoal) -> Self {
         let start_state = RealVectorState::new(start);
         let problem_def = ProblemDefinition {
-            space: space.inner.clone(),
+            space: Arc::new(space.inner.lock().unwrap().clone()),
             start_states: vec![start_state],
             goal: Arc::new(goal),
         };
diff --git a/oxmpl-js/src/base/real_vector_state.rs b/oxmpl-js/src/base/real_vector_state.rs
@@ -0,0 +1,30 @@
+// Copyright (c) 2025 Junior Sundar
+//
+// SPDX-License-Identifier: BSD-3-Clause
+
+use std::sync::Arc;
+
+use oxmpl::base::state::RealVectorState as OxmplRealVectorState;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name = RealVectorState)]
+pub struct JsRealVectorState {
+    #[wasm_bindgen(skip)]
+    pub inner: Arc<OxmplRealVectorState>,
+}
+
+#[wasm_bindgen(js_class = RealVectorState)]
+impl JsRealVectorState {
+    #[wasm_bindgen(constructor)]
+    pub fn new(values: Vec<f64>) -> Self {
+        let state = OxmplRealVectorState::new(values);
+        Self {
+            inner: Arc::new(state),
+        }
+    }
+
+    #[wasm_bindgen(getter)]
+    pub fn values(&self) -> Vec<f64> {
+        self.inner.values.clone()
+    }
+}
diff --git a/oxmpl-js/src/base/real_vector_state_space.rs b/oxmpl-js/src/base/real_vector_state_space.rs
@@ -3,17 +3,19 @@
 // SPDX-License-Identifier: BSD-3-Clause
 
 use oxmpl::base::{
-    space::{RealVectorStateSpace, StateSpace},
+    space::{RealVectorStateSpace as OxmplRealVectorStateSpace, StateSpace},
     state::RealVectorState,
 };
 use rand::rng;
-use std::sync::Arc;
+use std::sync::{Arc, Mutex};
 use wasm_bindgen::prelude::*;
 
+use crate::base::JsRealVectorState;
+
 #[wasm_bindgen(js_name = RealVectorStateSpace)]
 pub struct JsRealVectorStateSpace {
     #[wasm_bindgen(skip)]
-    pub inner: Arc<RealVectorStateSpace>,
+    pub inner: Arc<Mutex<OxmplRealVectorStateSpace>>,
 }
 
 #[wasm_bindgen(js_class = RealVectorStateSpace)]
@@ -39,30 +41,40 @@ impl JsRealVectorStateSpace {
             None
         };
 
-        match RealVectorStateSpace::new(dimension, bounds_vec) {
+        match OxmplRealVectorStateSpace::new(dimension, bounds_vec) {
             Ok(space) => Ok(Self {
-                inner: Arc::new(space),
+                inner: Arc::new(Mutex::new(space)),
             }),
             Err(e) => Err(e.to_string()),
         }
     }
 
-    pub fn sample(&self) -> Result<Vec<f64>, String> {
+    #[wasm_bindgen(js_name = sample)]
+    pub fn sample(&self) -> Result<JsRealVectorState, String> {
         let mut rng = rng();
-        match self.inner.sample_uniform(&mut rng) {
-            Ok(state) => Ok(state.values),
+        match self.inner.lock().unwrap().sample_uniform(&mut rng) {
+            Ok(state) => Ok(JsRealVectorState::new(state.values)),
             Err(e) => Err(e.to_string()),
         }
     }
 
-    pub fn distance(&self, state1: Vec<f64>, state2: Vec<f64>) -> f64 {
-        let s1 = RealVectorState::new(state1);
-        let s2 = RealVectorState::new(state2);
-        self.inner.distance(&s1, &s2)
+    #[wasm_bindgen(js_name = distance)]
+    pub fn distance(&self, state1: &JsRealVectorState, state2: &JsRealVectorState) -> f64 {
+        let s1 = RealVectorState::new(state1.inner.values.clone());
+        let s2 = RealVectorState::new(state2.inner.values.clone());
+        self.inner.lock().unwrap().distance(&s1, &s2)
     }
 
     #[wasm_bindgen(js_name = getDimension)]
     pub fn get_dimension(&self) -> usize {
-        self.inner.dimension
+        self.inner.lock().unwrap().dimension
+    }
+
+    #[wasm_bindgen(js_name = setLongestValidLineSegmentFraction)]
+    pub fn set_longest_valid_segment_fraction(&mut self, fraction: f64) {
+        self.inner
+            .lock()
+            .unwrap()
+            .set_longest_valid_segment_fraction(fraction);
     }
 }
diff --git a/oxmpl-js/tests/test_prm_integration.test.js b/oxmpl-js/tests/test_prm_integration.test.js
@@ -85,21 +85,22 @@ describe('PRM Integration Tests', () => {
     let path;
     try {
       path = planner.solve(timeoutSecs);
-      console.log(`Solution found with ${path.length()} states.`);
+      console.log(`Solution found with ${path.getLength()} states.`);
     } catch (error) {
       throw new Error(`Planner failed to find a solution when one should exist. Error: ${error}`);
     }
 
     // VALIDATE THE SOLUTION PATH
     const states = path.getStates();
-    const pathLength = path.length();
+    const pathLength = path.getLength();
 
     expect(pathLength).toBeGreaterThan(1);
     expect(states.length).toBe(pathLength);
 
     // Check start position
-    const pathStart = states[0];
-    const startDistance = space.distance(pathStart, startState);
+    const pathStart = new oxmpl.RealVectorState(states[0]);
+    const startStateObj = new oxmpl.RealVectorState(startState);
+    const startDistance = space.distance(pathStart, startStateObj);
     expect(startDistance).toBeLessThan(1e-9);
 
     // Check goal is reached
diff --git a/oxmpl-js/tests/test_rrt_connect_integration.test.js b/oxmpl-js/tests/test_rrt_connect_integration.test.js
@@ -84,21 +84,22 @@ describe('RRT Connect Integration Tests', () => {
     let path;
     try {
       path = planner.solve(timeoutSecs);
-      console.log(`Solution found with ${path.length()} states.`);
+      console.log(`Solution found with ${path.getLength()} states.`);
     } catch (error) {
       throw new Error(`Planner failed to find a solution when one should exist. Error: ${error}`);
     }
 
     // VALIDATE THE SOLUTION PATH
     const states = path.getStates();
-    const pathLength = path.length();
+    const pathLength = path.getLength();
 
     expect(pathLength).toBeGreaterThan(1);
     expect(states.length).toBe(pathLength);
 
     // Check start position
-    const pathStart = states[0];
-    const startDistance = space.distance(pathStart, startState);
+    const pathStart = new oxmpl.RealVectorState(states[0]);
+    const startStateObj = new oxmpl.RealVectorState(startState);
+    const startDistance = space.distance(pathStart, startStateObj);
     expect(startDistance).toBeLessThan(1e-9);
 
     // Check goal is reached
diff --git a/oxmpl-js/tests/test_rrt_integration.test.js b/oxmpl-js/tests/test_rrt_integration.test.js
@@ -84,21 +84,22 @@ describe('RRT Integration Tests', () => {
     let path;
     try {
       path = planner.solve(timeoutSecs);
-      console.log(`Solution found with ${path.length()} states.`);
+      console.log(`Solution found with ${path.getLength()} states.`);
     } catch (error) {
       throw new Error(`Planner failed to find a solution when one should exist. Error: ${error}`);
     }
 
     // VALIDATE THE SOLUTION PATH
     const states = path.getStates();
-    const pathLength = path.length();
+    const pathLength = path.getLength();
 
     expect(pathLength).toBeGreaterThan(1);
     expect(states.length).toBe(pathLength);
 
     // Check start position
-    const pathStart = states[0];
-    const startDistance = space.distance(pathStart, startState);
+    const pathStart = new oxmpl.RealVectorState(states[0]);
+    const startStateObj = new oxmpl.RealVectorState(startState);
+    const startDistance = space.distance(pathStart, startStateObj);
     expect(startDistance).toBeLessThan(1e-9);
 
     // Check goal is reached
diff --git a/oxmpl-js/tests/test_rrt_star_integration.test.js b/oxmpl-js/tests/test_rrt_star_integration.test.js
@@ -85,21 +85,22 @@ describe('RRT* Integration Tests', () => {
     let path;
     try {
       path = planner.solve(timeoutSecs);
-      console.log(`Solution found with ${path.length()} states.`);
+      console.log(`Solution found with ${path.getLength()} states.`);
     } catch (error) {
       throw new Error(`Planner failed to find a solution when one should exist. Error: ${error}`);
     }
 
     // VALIDATE THE SOLUTION PATH
     const states = path.getStates();
-    const pathLength = path.length();
+    const pathLength = path.getLength();
 
     expect(pathLength).toBeGreaterThan(1);
     expect(states.length).toBe(pathLength);
 
     // Check start position
-    const pathStart = states[0];
-    const startDistance = space.distance(pathStart, startState);
+    const pathStart = new oxmpl.RealVectorState(states[0]);
+    const startStateObj = new oxmpl.RealVectorState(startState);
+    const startDistance = space.distance(pathStart, startStateObj);
     expect(startDistance).toBeLessThan(1e-9);
 
     // Check goal is reached
