openscvx 0.3.2.dev173__tar.gz → 0.3.2.dev184__tar.gz

{openscvx-0.3.2.dev173/openscvx.egg-info → openscvx-0.3.2.dev184}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscvx
-Version: 0.3.2.dev173
+Version: 0.3.2.dev184
 Summary: A general Python-based successive convexification implementation which uses a JAX backend.
 Author-email: Chris Hayner and Griffin Norris <haynec@uw.edu>
 License: Apache Software License

{openscvx-0.3.2.dev173 → openscvx-0.3.2.dev184}/examples/plotting_viser.py

@@ -58,6 +58,7 @@ def create_animated_plotting_server(
     target_radius: float = 1.0,
     show_control_plot: str | None = None,
     show_control_norm_plot: str | None = None,
+    show_grid: bool = True,
 ) -> viser.ViserServer:
     """Create an animated trajectory visualization server.
 
@@ -101,6 +102,7 @@ def create_animated_plotting_server(
             showing each control component vs time with animated markers
         show_control_norm_plot: If provided with a control name, displays norm plot
             showing ‖control‖₂ vs time with animated marker
+        show_grid: Whether to show the grid (default True)
 
     Returns:
         ViserServer instance (animation runs in background thread)
@@ -135,7 +137,7 @@ def create_animated_plotting_server(
     colors = compute_velocity_colors(vel)
 
     # Create server
-    server = create_server(pos)
+    server = create_server(pos, show_grid=show_grid)
 
     # Add static elements
     if "vertices" in results:
@@ -257,6 +259,7 @@ def create_scp_animated_plotting_server(
     frame_duration_ms: int = 500,
     scene_scale: float = 1.0,
     cmap_name: str = "viridis",
+    show_grid: bool = True,
 ) -> viser.ViserServer:
     """Create an animated visualization of SCP iteration convergence.
 
@@ -289,6 +292,7 @@ def create_scp_animated_plotting_server(
         scene_scale: Divide all positions by this factor. Use >1 for large-scale
             trajectories (e.g., 100.0 for km-scale problems).
         cmap_name: Matplotlib colormap name for iteration coloring (default: "viridis")
+        show_grid: Whether to show the grid (default True)
 
     Returns:
         ViserServer instance (animation runs in background thread)
@@ -322,7 +326,7 @@ def create_scp_animated_plotting_server(
         attitudes = [X[:, attitude_slice] for X in X_history]
 
     # Create server using final iteration's positions for grid sizing
-    server = create_server(positions[-1])
+    server = create_server(positions[-1], show_grid=show_grid)
 
     # Add static elements (gates, obstacles) if present
     if "vertices" in results:

openscvx-0.3.2.dev184/examples/spacecraft/proxops_cw.py

@@ -0,0 +1,188 @@
+"""Proximity Operations (ProxOps) using Clohessy-Wiltshire dynamics.
+
+This example demonstrates optimal trajectory generation for spacecraft
+proximity operations and docking using the Clohessy-Wiltshire (CW) equations
+for relative motion in a circular orbit.
+See [Clohessy-Wiltshire equations](https://en.wikipedia.org/wiki/Clohessy%E2%80%93Wiltshire_equations)
+for further details.
+The problem includes:
+
+- 3D relative position and velocity dynamics (CW equations)
+- Fuel-optimal control (minimize delta-v)
+- Thrust magnitude constraints
+- Approach cone constraint for safe docking corridor
+- Final docking at target (origin)
+
+!!! tip "The CW frame convention:"
+    - x: radial direction (outward from Earth)
+    - y: along-track direction (velocity direction)
+    - z: cross-track direction (normal to orbit plane)
+"""
+
+import os
+import sys
+
+import numpy as np
+
+# Add grandparent directory to path to import examples.plotting
+current_dir = os.path.dirname(os.path.abspath(__file__))
+grandparent_dir = os.path.dirname(os.path.dirname(current_dir))
+sys.path.append(grandparent_dir)
+
+import openscvx as ox
+from examples.plotting_viser import (
+    create_animated_plotting_server,
+    create_scp_animated_plotting_server,
+)
+from openscvx import Problem
+from openscvx.plotting import plot_scp_iterations
+from openscvx.plotting.viser import add_glideslope_cone
+
+# Problem parameters
+n_nodes = 5  # Number of discretization nodes
+total_time = 180.0  # Total maneuver time in seconds
+
+# Orbital parameters (ISS-like orbit at ~400 km altitude)
+mu = 3.986004418e14  # Earth gravitational parameter [m^3/s^2]
+a = 6.778e6  # Semi-major axis [m] (Earth radius + 400 km)
+n = np.sqrt(mu / a**3)  # Mean motion [rad/s] (~0.00113 rad/s)
+
+# Define state components
+# Position in CW frame [x, y, z] in meters
+position = ox.State("position", shape=(3,))
+position.max = np.array([100.0, 100.0, 100.0])
+position.min = np.array([-100.0, -100.0, -100.0])
+position.initial = np.array([0.0, -100.0, 0.0])  # Start 100m behind target (V-bar position)
+position.final = np.array([0.0, 0.0, 0.0])  # Dock at origin
+position.guess = np.linspace(position.initial, position.final, n_nodes)
+
+# Velocity in CW frame [vx, vy, vz] in m/s
+velocity = ox.State("velocity", shape=(3,))
+v_max = 2.0  # Maximum relative velocity [m/s]
+velocity.max = np.array([v_max, v_max, v_max])
+velocity.min = np.array([-v_max, -v_max, -v_max])
+velocity.initial = [0.0, 2.0, 0.0]
+velocity.final = np.array([0.0, 0.0, 0.0])  # Zero relative velocity at docking
+velocity.guess = np.zeros((n_nodes, 3))
+
+# Define control: acceleration from thrusters [ax, ay, az] in m/s^2
+accel = ox.Control("accel", shape=(3,))
+a_max = 0.1  # Maximum acceleration [m/s^2] (typical for reaction control thrusters)
+accel.max = np.array([a_max, a_max, a_max])
+accel.min = np.array([-a_max, -a_max, -a_max])
+accel.guess = np.zeros((n_nodes, 3))
+
+# Define list of all states and controls
+states = [position, velocity]
+controls = [accel]
+
+# Generate constraints
+constraints = []
+
+# Box constraints for states
+for state in states:
+    constraints.extend(
+        [
+            ox.ctcs(state <= state.max),
+            ox.ctcs(state.min <= state),
+        ]
+    )
+
+# R-bar approach cone constraint (from below, -x direction)
+# Enforces sqrt(y^2 + z^2) <= tan(theta) * (-x)
+# This requires the spacecraft to approach from negative x (below target)
+# and stay within a cone centered on the -x axis
+cone_half_angle = 20 * np.pi / 180  # 20 degree half-angle
+constraints.append(
+    ox.ctcs(ox.linalg.Norm(position[1:]) <= np.tan(cone_half_angle) * (-position[0])).over(
+        (n_nodes - 3, n_nodes - 1)
+    )
+)
+# Enforce entrance to the cone at safe distance
+constraints.append((-position[0] >= 20.0).at([n_nodes - 3]))
+
+# Clohessy-Wiltshire dynamics
+dynamics = {
+    "position": velocity,
+    "velocity": ox.Concat(
+        3 * n**2 * position[0] + 2 * n * velocity[1] + accel[0],
+        -2 * n * velocity[0] + accel[1],
+        -(n**2) * position[2] + accel[2],
+    ),
+}
+
+# Time configuration (free final time to minimize fuel)
+time = ox.Time(
+    initial=0.0,
+    final=("free", total_time),
+    min=0.0,
+    max=total_time,
+)
+
+# Build the problem
+problem = Problem(
+    dynamics=dynamics,
+    states=states,
+    controls=controls,
+    time=time,
+    constraints=constraints,
+    N=n_nodes,
+)
+
+# Solver settings (FOH is default, no need to set explicitly)
+problem.settings.dis.dis_type = "ZOH"
+problem.settings.scp.k_max = 100
+problem.settings.scp.w_tr = 1e0
+problem.settings.scp.w_tr_adapt = 1.2
+problem.settings.scp.lam_cost = 1e-1
+problem.settings.scp.lam_vc = 1e1
+problem.settings.scp.lam_vb = 1e0
+
+# Plotting metadata
+plotting_dict = {
+    "mean_motion": n,
+}
+
+if __name__ == "__main__":
+    problem.initialize()
+    results = problem.solve()
+    results = problem.post_process()
+    results.update(plotting_dict)
+
+    # Plot results
+    plot_scp_iterations(results).show()
+
+    # Create animation
+    traj_server = create_animated_plotting_server(results, thrust_key="accel", show_grid=False)
+
+    # Add R-bar approach cone (opens in -x direction)
+    add_glideslope_cone(
+        traj_server,
+        apex=(0, 0, 0),
+        height=20.0,  # Cone extends 100m in -x direction
+        glideslope_angle_deg=cone_half_angle * 180 / np.pi,
+        axis=(-1, 0, 0),  # R-bar: negative radial direction
+        color=(200, 80, 80),
+        opacity=0.5,
+    )
+
+    # Create SCP iteration visualization
+    scp_server = create_scp_animated_plotting_server(
+        results,
+        frame_duration_ms=200,
+        scene_scale=1.0,
+        show_grid=False,
+    )
+
+    # Add R-bar approach cone to SCP visualization
+    add_glideslope_cone(
+        scp_server,
+        apex=(0, 0, 0),
+        height=20.0,
+        glideslope_angle_deg=cone_half_angle * 180 / np.pi,
+        axis=(-1, 0, 0),
+        color=(200, 80, 80),
+        opacity=0.5,
+    )
+
+    scp_server.sleep_forever()

{openscvx-0.3.2.dev173 → openscvx-0.3.2.dev184}/openscvx/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.3.2.dev173'
-__version_tuple__ = version_tuple = (0, 3, 2, 'dev173')
+__version__ = version = '0.3.2.dev184'
+__version_tuple__ = version_tuple = (0, 3, 2, 'dev184')
 
-__commit_id__ = commit_id = 'g99c4b988b'
+__commit_id__ = commit_id = 'gb43481d6f'

{openscvx-0.3.2.dev173 → openscvx-0.3.2.dev184}/openscvx/plotting/viser/primitives.py

@@ -228,14 +228,16 @@ def _generate_cone_mesh(
     height: float,
     half_angle_deg: float,
     n_segments: int = 32,
+    axis: np.ndarray | tuple = (0.0, 0.0, 1.0),
 ) -> tuple[np.ndarray, np.ndarray]:
-    """Generate a cone mesh with apex at given position, opening upward.
+    """Generate a cone mesh with apex at given position, opening along specified axis.
 
     Args:
         apex: Apex position (3,) - the tip of the cone
-        height: Height of the cone (extends in +Z direction from apex)
-        half_angle_deg: Half-angle of the cone from the vertical axis in degrees
+        height: Height of the cone (extends along axis direction from apex)
+        half_angle_deg: Half-angle of the cone from the axis in degrees
         n_segments: Number of segments around the circumference
+        axis: Unit vector direction the cone opens toward (default +Z)
 
     Returns:
         Tuple of (vertices, faces) where vertices is (V, 3) and faces is (F, 3)
@@ -243,21 +245,36 @@ def _generate_cone_mesh(
     half_angle_rad = np.radians(half_angle_deg)
     base_radius = height * np.tan(half_angle_rad)
 
+    # Normalize axis
+    axis = np.asarray(axis, dtype=np.float32)
+    axis = axis / np.linalg.norm(axis)
+
+    # Build orthonormal basis: find two vectors perpendicular to axis
+    # Pick a reference vector not parallel to axis
+    if abs(axis[0]) < 0.9:
+        ref = np.array([1.0, 0.0, 0.0], dtype=np.float32)
+    else:
+        ref = np.array([0.0, 1.0, 0.0], dtype=np.float32)
+
+    # Gram-Schmidt to get perpendicular vectors
+    u = ref - np.dot(ref, axis) * axis
+    u = u / np.linalg.norm(u)
+    v = np.cross(axis, u)
+
     # Vertices: apex + base circle points
     vertices = [apex.copy()]  # Apex at index 0
 
+    # Base center position
+    base_center = apex + height * axis
+
     # Base circle vertices
     for i in range(n_segments):
         angle = 2 * np.pi * i / n_segments
-        x = apex[0] + base_radius * np.cos(angle)
-        y = apex[1] + base_radius * np.sin(angle)
-        z = apex[2] + height
-        vertices.append([x, y, z])
+        offset = base_radius * (np.cos(angle) * u + np.sin(angle) * v)
+        vertices.append(base_center + offset)
 
     # Center of base for closing the bottom
-    base_center = apex.copy()
-    base_center[2] += height
-    vertices.append(base_center)  # Index n_segments + 1
+    vertices.append(base_center.copy())  # Index n_segments + 1
 
     vertices = np.array(vertices, dtype=np.float32)
 
@@ -287,25 +304,28 @@ def add_glideslope_cone(
     apex: np.ndarray | tuple = (0.0, 0.0, 0.0),
     height: float = 2000.0,
     glideslope_angle_deg: float = 86.0,
+    axis: np.ndarray | tuple = (0.0, 0.0, 1.0),
     color: tuple[int, int, int] = (100, 200, 100),
     opacity: float = 0.2,
     wireframe: bool = False,
     n_segments: int = 32,
 ) -> viser.MeshHandle:
-    """Add a glideslope constraint cone to the scene.
+    """Add a glideslope/approach constraint cone to the scene.
 
     The glideslope constraint typically has the form:
-        ||position_xy|| <= tan(angle) * position_z
+        ||position_perp|| <= tan(angle) * position_along_axis
 
-    This creates a cone with apex at the landing site, opening upward.
+    This creates a cone with apex at the target, opening along the specified axis.
 
     Args:
         server: ViserServer instance
-        apex: Apex position (landing site), default is origin
+        apex: Apex position (docking/landing site), default is origin
         height: Height of the cone visualization
-        glideslope_angle_deg: Glideslope angle in degrees (measured from vertical).
-            For constraint ||r_xy|| <= tan(theta) * z, pass theta here.
+        glideslope_angle_deg: Glideslope angle in degrees (measured from axis).
+            For constraint ||r_perp|| <= tan(theta) * r_axis, pass theta here.
             Common values: 86 deg (very wide), 70 deg (moderate), 45 deg (steep)
+        axis: Unit vector direction the cone opens toward. Default (0,0,1) for +Z.
+            Use (-1,0,0) for R-bar approach (from below in radial direction).
         color: RGB color tuple
         opacity: Opacity (0-1)
         wireframe: If True, render as wireframe
@@ -316,7 +336,7 @@ def add_glideslope_cone(
     """
     apex = np.asarray(apex, dtype=np.float32)
 
-    vertices, faces = _generate_cone_mesh(apex, height, glideslope_angle_deg, n_segments)
+    vertices, faces = _generate_cone_mesh(apex, height, glideslope_angle_deg, n_segments, axis=axis)
 
     handle = server.scene.add_mesh_simple(
         "/constraints/glideslope_cone",

{openscvx-0.3.2.dev173 → openscvx-0.3.2.dev184}/openscvx/plotting/viser/server.py

@@ -46,12 +46,14 @@ def compute_grid_size(pos: np.ndarray, padding: float = 1.2) -> float:
 def create_server(
     pos: np.ndarray,
     dark_mode: bool = True,
+    show_grid: bool = True,
 ) -> viser.ViserServer:
     """Create a viser server with basic scene setup.
 
     Args:
         pos: Position array for computing grid size
         dark_mode: Whether to use dark theme
+        show_grid: Whether to show the grid (default True)
 
     Returns:
         ViserServer instance with grid and origin frame
@@ -96,13 +98,14 @@ def create_server(
         dark_mode=dark_mode,
     )
 
-    grid_size = compute_grid_size(pos)
-    server.scene.add_grid(
-        "/grid",
-        width=grid_size,
-        height=grid_size,
-        position=np.array([0.0, 0.0, 0.0]),
-    )
+    if show_grid:
+        grid_size = compute_grid_size(pos)
+        server.scene.add_grid(
+            "/grid",
+            width=grid_size,
+            height=grid_size,
+            position=np.array([0.0, 0.0, 0.0]),
+        )
     server.scene.add_frame(
         "/origin",
         wxyz=(1.0, 0.0, 0.0, 0.0),

{openscvx-0.3.2.dev173 → openscvx-0.3.2.dev184/openscvx.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscvx
-Version: 0.3.2.dev173
+Version: 0.3.2.dev184
 Summary: A general Python-based successive convexification implementation which uses a JAX backend.
 Author-email: Chris Hayner and Griffin Norris <haynec@uw.edu>
 License: Apache Software License

{openscvx-0.3.2.dev173 → openscvx-0.3.2.dev184}/openscvx.egg-info/SOURCES.txt

@@ -69,6 +69,7 @@ examples/realtime/cinema_vp_realtime.py
 examples/realtime/drone_racing_realtime.py
 examples/realtime/dubins_car_realtime.py
 examples/realtime/obstacle_avoidance_realtime.py
+examples/spacecraft/proxops_cw.py
 figures/ctlos_cine.gif
 figures/ctlos_dr.gif
 figures/dtlos_cine.gif