Add Docker support with Dockerfile, docker-compose.yml, and .dockerignore

- Introduced Dockerfile for building the application with necessary system dependencies for MuJoCo and OpenCV.
- Added docker-compose.yml to define the service configuration for the Nova Sim application.
- Created .dockerignore to exclude unnecessary files from the Docker build context.
- Updated SpotEnv and TrotGaitController comments for clarity on standing pose definitions.

.dockerignore

@@ -0,0 +1,60 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual environments
+venv/
+ENV/
+env/
+.venv/
+
+# IDEs
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Claude
+.claude/
+
+# Git
+.git/
+.gitignore
+
+# Docker
+Dockerfile
+.dockerignore
+docker-compose.yml
+
+# Jupyter
+.ipynb_checkpoints/
+
+# MuJoCo compiled
+*.mjb
+
+# Test files
+tests/
+*.test.py

Dockerfile

@@ -0,0 +1,54 @@
+FROM python:3.11-slim-bookworm
+
+# Install system dependencies for MuJoCo and OpenCV
+RUN apt-get update && apt-get install -y \
+    libgl1 \
+    libglx0 \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender1 \
+    libgomp1 \
+    libglfw3 \
+    libglew2.2 \
+    libosmesa6 \
+    libegl1 \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Set working directory
+WORKDIR /app
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Clone MuJoCo Menagerie for Spot model
+RUN git clone --depth 1 https://github.com/google-deepmind/mujoco_menagerie.git /mujoco_menagerie
+
+# Clone unitree_rl_gym for G1 RL policy
+RUN git clone --depth 1 https://github.com/unitreerobotics/unitree_rl_gym.git /unitree_rl_gym
+
+# Copy application code
+COPY . .
+
+# Update paths in the code to use container paths
+# G1 RL policy path
+RUN sed -i 's|robotsim_parent_dir = os.path.dirname(nova_sim_dir)|robotsim_parent_dir = "/"|g' \
+    /app/robots/g1/controllers/rl_policy.py
+
+# Spot model path
+RUN sed -i 's|robotsim_parent_dir = os.path.dirname(nova_sim_dir)|robotsim_parent_dir = "/"|g' \
+    /app/robots/spot/spot_env.py
+
+# Environment variables for headless rendering
+ENV MUJOCO_GL=osmesa
+ENV PYOPENGL_PLATFORM=osmesa
+
+# Expose port
+EXPOSE 3004
+
+# Run the server
+CMD ["python", "mujoco_server.py"]

docker-compose.yml

@@ -0,0 +1,11 @@
+version: '3.8'
+
+services:
+  nova-sim:
+    build: .
+    ports:
+      - "3004:3004"
+    environment:
+      - MUJOCO_GL=osmesa
+      - PYOPENGL_PLATFORM=osmesa
+    restart: unless-stopped

robots/spot/controllers/trot_gait.py

@@ -20,7 +20,7 @@ class TrotGaitController(BaseController):
     Uses simple sinusoidal trajectories for leg motion.
     """
 
-    # Standing pose
+    # Standing pose - from model's "home" keyframe
     STANDING_POSE = np.array([
         0.0, 1.04, -1.8,  # FL: hx, hy, kn
         0.0, 1.04, -1.8,  # FR
@@ -28,29 +28,20 @@ class TrotGaitController(BaseController):
         0.0, 1.04, -1.8,  # HR
     ], dtype=np.float32)
 
-    # Joint indices
-    FL_HX, FL_HY, FL_KN = 0, 1, 2
-    FR_HX, FR_HY, FR_KN = 3, 4, 5
-    HL_HX, HL_HY, HL_KN = 6, 7, 8
-    HR_HX, HR_HY, HR_KN = 9, 10, 11
-
     def __init__(self, num_joints: int = 12):
         super().__init__(num_joints)
 
         # Velocity command [vx, vy, vyaw]
         self.cmd = np.array([0.0, 0.0, 0.0], dtype=np.float32)
 
-        # Gait parameters
-        self.gait_freq = 2.0  # Hz - steps per second
-        self.step_height = 0.08  # meters - how high to lift feet
-        self.stride_length = 0.15  # meters - forward stride
+        # Gait parameters - tuned for visible motion
+        self.gait_freq = 2.0  # Hz - gait cycles per second
+        self.swing_height = 0.3  # How much to bend knee during swing (radians)
+        self.stride_length = 0.25  # Hip pitch amplitude (radians)
 
         # Phase offset for trot (diagonal pairs in sync)
         # FL and HR at phase 0, FR and HL at phase 0.5
-        self.phase_offsets = np.array([0.0, 0.0, 0.5, 0.5])  # FL, FR, HL, HR
-
-        # Smooth startup
-        self.ramp_time = 1.0
+        self.phase_offsets = np.array([0.0, 0.5, 0.5, 0.0])  # FL, FR, HL, HR
 
     def set_command(self, vx: float = 0.0, vy: float = 0.0, vyaw: float = 0.0):
         """Set velocity command for the robot."""
@@ -62,118 +53,80 @@ class TrotGaitController(BaseController):
         """Get current velocity command."""
         return self.cmd.copy()
 
-    def _leg_trajectory(self, phase: float, vx: float, vy: float, vyaw: float, leg_idx: int):
-        """
-        Compute leg joint angles for a given gait phase.
-
-        Args:
-            phase: Gait phase [0, 1)
-            vx: Forward velocity command
-            vy: Lateral velocity command
-            vyaw: Yaw rate command
-            leg_idx: Leg index (0=FL, 1=FR, 2=HL, 3=HR)
-
-        Returns:
-            (hx, hy, kn) joint angles
-        """
-        # Base standing angles
-        hx_base, hy_base, kn_base = 0.0, 1.04, -1.8
-
-        # Speed factor (0-1) based on command magnitude
-        speed = np.sqrt(vx**2 + vy**2 + vyaw**2)
-        speed_factor = min(1.0, speed / 1.0)
-
-        if speed_factor < 0.05:
-            # Standing - no motion
-            return hx_base, hy_base, kn_base
-
-        # Leg position relative to body center
-        # FL: (+x, +y), FR: (+x, -y), HL: (-x, +y), HR: (-x, -y)
-        leg_signs = [
-            (1, 1),   # FL
-            (1, -1),  # FR
-            (-1, 1),  # HL
-            (-1, -1), # HR
-        ]
-        sign_x, sign_y = leg_signs[leg_idx]
-
-        # Swing/stance phase
-        # phase < 0.5: swing (foot in air)
-        # phase >= 0.5: stance (foot on ground)
-        is_swing = phase < 0.5
-        swing_phase = phase / 0.5 if is_swing else 0.0
-        stance_phase = (phase - 0.5) / 0.5 if not is_swing else 0.0
-
-        # Hip pitch (hy) - controls forward/backward leg motion
-        stride = self.stride_length * speed_factor * vx
-        if is_swing:
-            # Swing forward
-            hy_offset = stride * (swing_phase - 0.5)
-        else:
-            # Push backward
-            hy_offset = stride * (0.5 - stance_phase)
-
-        # Knee (kn) - lift foot during swing
-        if is_swing:
-            # Lift foot using sinusoidal trajectory
-            lift = self.step_height * np.sin(np.pi * swing_phase)
-            kn_offset = lift * 2.0  # Convert to knee angle change
-        else:
-            kn_offset = 0.0
-
-        # Hip roll (hx) - lateral motion and turning
-        hx_offset = 0.0
-
-        # Lateral motion
-        if abs(vy) > 0.01:
-            lateral_stride = 0.1 * speed_factor * vy * sign_y
-            if is_swing:
-                hx_offset += lateral_stride * (swing_phase - 0.5)
-            else:
-                hx_offset += lateral_stride * (0.5 - stance_phase)
-
-        # Turning - differential stride
-        if abs(vyaw) > 0.01:
-            turn_factor = 0.1 * vyaw * sign_y
-            if is_swing:
-                hy_offset += turn_factor * (swing_phase - 0.5)
-            else:
-                hy_offset += turn_factor * (0.5 - stance_phase)
-
-        return hx_base + hx_offset, hy_base + hy_offset, kn_base + kn_offset
-
     def compute_action(self, obs: np.ndarray, data) -> np.ndarray:
         """Compute target joint positions for trot gait."""
-        # Smooth startup ramp
-        gain = min(1.0, self.time / self.ramp_time) if self.ramp_time > 0 else 1.0
+        vx, vy, vyaw = self.cmd
 
-        # Compute gait phase
-        gait_phase = (self.time * self.gait_freq) % 1.0
+        # Check if we should be walking
+        speed = np.sqrt(vx**2 + vy**2 + vyaw**2)
+        if speed < 0.05:
+            # Just stand
+            return self.STANDING_POSE.copy()
 
-        # Get command
-        vx, vy, vyaw = self.cmd
+        # Gait phase (0 to 1)
+        phase = (self.time * self.gait_freq) % 1.0
+
+        # Base standing angles (from model's home keyframe)
+        hy_stand = 1.04   # Hip pitch
+        kn_stand = -1.8   # Knee
 
-        # Compute joint targets for each leg
+        # Output array
         target = np.zeros(12, dtype=np.float32)
 
         for leg_idx in range(4):
-            # Apply phase offset for this leg
-            leg_phase = (gait_phase + self.phase_offsets[leg_idx]) % 1.0
+            # Get leg phase with offset
+            leg_phase = (phase + self.phase_offsets[leg_idx]) % 1.0
 
-            # Get joint angles
-            hx, hy, kn = self._leg_trajectory(leg_phase, vx, vy, vyaw, leg_idx)
+            # Determine if in swing (0-0.5) or stance (0.5-1.0)
+            in_swing = leg_phase < 0.5
 
-            # Store in target array
-            base_idx = leg_idx * 3
-            target[base_idx] = hx
-            target[base_idx + 1] = hy
-            target[base_idx + 2] = kn
+            # Compute phase within swing or stance (0 to 1)
+            if in_swing:
+                p = leg_phase / 0.5
+            else:
+                p = (leg_phase - 0.5) / 0.5
+
+            # Hip pitch: sinusoidal forward/back motion
+            # During swing: leg moves forward
+            # During stance: leg moves backward (pushes body forward)
+            if in_swing:
+                # Swing forward: start back, end front
+                hy_offset = self.stride_length * vx * (p - 0.5)
+            else:
+                # Stance backward: start front, end back
+                hy_offset = self.stride_length * vx * (0.5 - p)
 
-        # Blend with standing pose during startup
-        standing = self.STANDING_POSE.copy()
-        result = standing + gain * (target - standing)
+            # Knee: lift during swing phase
+            if in_swing:
+                # Sinusoidal lift
+                kn_offset = -self.swing_height * np.sin(np.pi * p)
+            else:
+                kn_offset = 0.0
+
+            # Hip roll for turning
+            is_left = leg_idx in [0, 2]
+            hx_offset = 0.0
+            if abs(vyaw) > 0.01:
+                # Differential motion for turning
+                sign = 1.0 if is_left else -1.0
+                if in_swing:
+                    hx_offset = sign * 0.1 * vyaw * np.sin(np.pi * p)
+
+            # Lateral motion
+            if abs(vy) > 0.01:
+                sign = 1.0 if is_left else -1.0
+                if in_swing:
+                    hx_offset += sign * 0.2 * vy * (p - 0.5)
+                else:
+                    hx_offset += sign * 0.2 * vy * (0.5 - p)
+
+            # Set joint targets
+            base_idx = leg_idx * 3
+            target[base_idx + 0] = hx_offset                    # hx (hip roll)
+            target[base_idx + 1] = hy_stand + hy_offset         # hy (hip pitch)
+            target[base_idx + 2] = kn_stand + kn_offset         # kn (knee)
 
-        return result
+        return target
 
     def reset(self):
         super().reset()

robots/spot/spot_env.py

@@ -36,10 +36,9 @@ class SpotEnv(gym.Env):
         "hr_hx", "hr_hy", "hr_kn",
     ]
 
-    # Standing pose from the model's keyframe
-    # hx=0, hy=1.04, kn=-1.8 for all legs
+    # Standing pose - from model's "home" keyframe
     DEFAULT_STANDING_POSE = np.array([
-        0.0, 1.04, -1.8,  # FL
+        0.0, 1.04, -1.8,  # FL: hx, hy, kn
         0.0, 1.04, -1.8,  # FR
         0.0, 1.04, -1.8,  # HL
         0.0, 1.04, -1.8,  # HR