inital upload

Dockerfile

@@ -0,0 +1,28 @@
+FROM python:3.11-slim
+
+# non-interactive apt + wheels only (faster, avoids abuse flags)
+ENV DEBIAN_FRONTEND=noninteractive
+ENV PIP_DISABLE_PIP_VERSION_CHECK=1
+ENV PIP_NO_CACHE_DIR=1
+ENV PIP_ONLY_BINARY=:all:
+
+# only nginx (no supervisor)
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    nginx \
+ && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /workspace
+
+# your working versions
+COPY requirements.txt ./
+RUN pip install -r requirements.txt
+
+# app + nginx config + entrypoint
+COPY app.py robots.py nginx.conf run.sh ./
+RUN chmod +x /workspace/run.sh \
+ && rm -f /etc/nginx/nginx.conf \
+ && ln -s /workspace/nginx.conf /etc/nginx/nginx.conf
+
+EXPOSE 7860
+CMD ["/workspace/run.sh"]
+

app.py

@@ -0,0 +1,57 @@
+import gradio as gr
+import numpy as np
+from robots import LiveRobot
+
+ROBOTS = ["ur5", "ur10", "tiago", "talos", "icub"]
+
+# single global instance to keep the MeshCat connection alive
+robot = LiveRobot("ur5")
+
+with gr.Blocks(title="Pinocchio + MeshCat — Live") as demo:
+    gr.Markdown("### 🤖 Pinocchio + MeshCat — Live Viewer\n"
+                "Sliders update the robot in real time (no reload).")
+
+    with gr.Row():
+        robot_dd = gr.Dropdown(ROBOTS, value="ur5", label="Robot")
+        neutral_btn = gr.Button("Neutral")
+
+    viewer = gr.HTML(robot.iframe())
+
+    # sliders are created based on current robot model
+    slider_group = gr.Group()
+    sliders = []
+    for label, (lo, hi), qi in zip(robot.labels, robot.bounds, robot.idxs):
+        sliders.append(gr.Slider(minimum=lo, maximum=hi, step=0.01,
+                                 value=float(robot.q[qi]), label=label))
+
+    def on_sliders(*vals):
+        robot.set_joints(vals)
+        # return nothing for viewer; iframe stays connected
+        return gr.update()
+
+    for s in sliders:
+        s.change(on_sliders, inputs=sliders, outputs=viewer, queue=False)
+
+    def on_neutral():
+        # reset joints and reflect slider values
+        values = robot.neutral()
+        updates = [gr.update(value=v) for v in values]
+        return [gr.update()] + updates
+
+    neutral_btn.click(on_neutral, outputs=[viewer] + sliders, queue=False)
+
+    def on_change_robot(name):
+        global robot
+        robot = LiveRobot(name)
+        # rebuild slider values to the new robot's neutral
+        values = [float(robot.q[i]) for i in robot.idxs]
+        viewer_html = robot.iframe()
+        updates = [gr.update(value=0, label=label, minimum=lo, maximum=hi)
+                   for (label,(lo,hi)) in zip(robot.labels, robot.bounds)]
+        return [gr.update(value=viewer_html)] + updates
+
+    robot_dd.change(on_change_robot, inputs=robot_dd,
+                    outputs=[viewer] + sliders, queue=False)
+
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", server_port=8501)

nginx.conf

@@ -0,0 +1,28 @@
+worker_processes 1;
+events { worker_connections 1024; }
+http {
+  include       mime.types;
+  default_type  application/octet-stream;
+  sendfile      on;
+  map $http_upgrade $connection_upgrade { default upgrade; '' close; }
+
+  upstream app     { server 127.0.0.1:8501; }
+  # upstream meshcat { server 127.0.0.1:6001; }
+
+  server {
+    listen 7860;
+
+    location / {
+      proxy_pass http://app;
+      proxy_set_header Host $host;
+      proxy_set_header X-Real-IP $remote_addr;
+    }
+
+    # location /meshcat/ {
+    #   proxy_http_version 1.1;
+    #   proxy_set_header Upgrade $http_upgrade;
+    #   proxy_set_header Connection $connection_upgrade;
+    #   proxy_pass http://meshcat/;
+    # }
+  }
+}

requirements.txt

@@ -0,0 +1,5 @@
+gradio==5.49.1
+meshcat==0.3.2
+pin==3.8.0            # Pinocchio (package name is "pin")
+example-robot-data==4.1.0
+numpy==2.3.4

robots.py

@@ -0,0 +1,66 @@
+import numpy as np
+import example_robot_data as erd
+import pinocchio as pin
+import meshcat
+from meshcat.servers.zmqserver import start_zmq_server_as_subprocess
+
+from pinocchio.visualize import MeshcatVisualizer
+
+def _actuated_dof_indices(model):
+    idxs, labels, bounds = [], [], []
+    for j in range(1, len(model.joints)):
+        J = model.joints[j]
+        if J.shortname() == "JointModelFreeFlyer":
+            continue
+        if J.nq == 1:
+            i0 = J.idx_q
+            lo = float(model.lowerPositionLimit[i0])
+            hi = float(model.upperPositionLimit[i0])
+            if not np.isfinite(lo): lo = -3.14
+            if not np.isfinite(hi): hi =  3.14
+            idxs.append(i0)
+            labels.append(model.names[j])
+            bounds.append((lo, hi))
+    return idxs, labels, bounds
+
+class LiveRobot:
+    """
+    Starts a local MeshCat ZMQ+Web server and keeps a persistent connection.
+    The web UI is proxied at /meshcat/ by nginx (see nginx.conf).
+    """
+    def __init__(self, robot_name="ur5"):
+        # Start one MeshCat server (zmq + web) and connect
+        self.proc, self.zmq_url, self.web_url = start_zmq_server_as_subprocess(server_args=[])
+        print(f"MeshCat ZMQ server at {self.zmq_url}, web at {self.web_url}")
+        self.vis = meshcat.Visualizer(zmq_url=self.zmq_url)
+
+        self.rdata = erd.load(robot_name)
+        self.model = self.rdata.model
+        self.data = self.model.createData()
+
+        self.viz = MeshcatVisualizer(
+            self.model, self.rdata.collision_model, self.rdata.visual_model
+        )
+        self.viz.initViewer(self.vis)
+        self.viz.loadViewerModel()
+
+        self.q = pin.neutral(self.model)
+        self.viz.display(self.q)
+
+        self.idxs, self.labels, self.bounds = _actuated_dof_indices(self.model)
+
+    def set_joints(self, vals):
+        q = self.q.copy()
+        for v, qi in zip(vals, self.idxs):
+            q[qi] = float(v)
+        self.q = q
+        self.viz.display(self.q)
+
+    def neutral(self):
+        self.q = pin.neutral(self.model)
+        self.viz.display(self.q)
+        return [float(self.q[i]) for i in self.idxs]
+
+    def iframe(self, width="100%", height=640):
+        # nginx proxies the MeshCat web app at /meshcat/
+        return f'<iframe src="{self.web_url}" style="width:{width};height:{height}px;border:0"></iframe>'

run.sh

@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# 1) start MeshCat (websocket server) on 6001 in the background
+meshcat-server --host 127.0.0.1 --port 6001 --open False &
+
+# 2) start nginx (daemonizes to background by default; uses /workspace/nginx.conf)
+nginx
+
+# 3) run Gradio app on 8501 in the foreground (container stays alive on this)
+exec python app.py