Initial commit

.dockerignore

@@ -0,0 +1 @@
+files

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

.idea/JAX-IK.iml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="jdk" jdkName="main" jdkType="Python SDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>

.idea/misc.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Black">
+    <option name="sdkName" value="Python 3.12" />
+  </component>
+  <component name="ProjectRootManager" version="2" project-jdk-name="main" project-jdk-type="Python SDK" />
+</project>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/JAX-IK.iml" filepath="$PROJECT_DIR$/.idea/JAX-IK.iml" />
+    </modules>
+  </component>
+</project>

.idea/ruff.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="RuffConfigService">
+    <option name="alwaysUseGlobalRuff" value="true" />
+    <option name="enableRuffLogging" value="true" />
+    <option name="runRuffOnSave" value="true" />
+    <option name="useIntellijLspClient" value="false" />
+    <option name="useLsp4ij" value="true" />
+    <option name="useRuffFormat" value="true" />
+    <option name="useRuffImportOptimizer" value="true" />
+    <option name="useRuffServer" value="true" />
+  </component>
+</project>

.idea/vcs.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>

Dockerfile

@@ -0,0 +1,29 @@
+FROM python:3.11
+
+WORKDIR /code
+
+COPY ./requirements.txt /code/requirements.txt
+
+RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+
+RUN pip install psutil
+
+RUN yes | pip uninstall jax-cuda12-plugin jax-cuda12-pjrt
+
+# Set up a new user named "user" with user ID 1000
+RUN useradd -m -u 1000 user
+
+# Switch to the "user" user
+USER user
+
+# Set home to the user's home directory
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+
+# Set the working directory to the user's home directory
+WORKDIR $HOME/app
+
+# Copy the current directory contents into the container at $HOME/app setting the owner to the user
+COPY --chown=user . $HOME/app
+
+CMD ["python", "app.py"]

Makefile

@@ -0,0 +1,9 @@
+image_name := hvosstechfak/jaxik_demo
+
+build:
+	docker build . -t ${image_name}
+
+run:
+	-docker stop jaxik;
+	-docker rm jaxik;
+	docker run --ipc=host --name jaxik --network=host ${image_name}

README.md

@@ -0,0 +1,16 @@
+---
+title: JAX IK
+emoji: ⚡
+colorFrom: gray
+colorTo: yellow
+sdk: docker
+sdk_version: 5.35.0
+app_file: app.py
+pinned: false
+license: cc-by-nc-sa-4.0
+short_description: https://github.com/hvoss-techfak/TF-JAX-IK
+app_port: 17861
+---
+
+Please see the code here:
+https://github.com/hvoss-techfak/TF-JAX-IK

app.py

@@ -0,0 +1,749 @@
+import logging, faulthandler, sys, time, os, requests, zipfile, io, gc, threading, psutil, json, configargparse
+faulthandler.enable()
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger("jax_ik_server")
+
+def _excepthook(t, v, tb):
+    logger.exception("Uncaught exception", exc_info=(t, v, tb))
+sys.excepthook = _excepthook
+
+# Environment (CPU only)
+os.environ['JAX_PLATFORMS'] = 'cpu'
+os.environ['CUDA_VISIBLE_DEVICES'] = ''
+
+import jax
+jax.config.update("jax_default_device", "cpu")
+import numpy as np
+
+from fastapi import FastAPI, Request, Response
+from fastapi.staticfiles import StaticFiles
+from fastapi.middleware.cors import CORSMiddleware
+from starlette.responses import FileResponse, JSONResponse
+
+from jax_ik.helper import deform_mesh, load_mesh_data_from_gltf, load_mesh_data_from_urdf
+from jax_ik.hand_specification import HandSpecification
+from jax_ik.smplx_statics import left_arm_bounds_dict, right_arm_bounds_dict, complete_full_body_bounds_dict
+from jax_ik.ik import InverseKinematicsSolver
+from jax_ik.objectives import (
+    BoneZeroRotationObj,
+    CombinedDerivativeObj,
+    DistanceObjTraj,
+    SphereCollisionPenaltyObjTraj,
+)
+try:
+    from collision_objectives import FastSphereCollisionPenaltyObjTraj as _FastColl
+except Exception:  # fallback if file missing
+    _FastColl = SphereCollisionPenaltyObjTraj
+
+def download_and_setup_files():
+    os.makedirs("files", exist_ok=True)
+    # Pepper
+    pepper_dir = "files/pepper_description-master"
+    if not os.path.isdir(pepper_dir):
+        logger.info("Downloading Pepper model...")
+        try:
+            r = requests.get(os.environ.get("PEPPER_DOWNLOAD"), stream=True)
+            r.raise_for_status()
+            with zipfile.ZipFile(io.BytesIO(r.content)) as z:
+                z.extractall("files/")
+        except Exception as e:
+            logger.warning(f"Pepper download failed: {e}")
+    # SMPLX
+    smplx_file = "files/smplx.glb"
+    if not os.path.isfile(smplx_file):
+        logger.info("Downloading SMPLX model...")
+        try:
+            r = requests.get(os.environ.get("SMPLX_DOWNLOAD"))
+            r.raise_for_status()
+            open(smplx_file, "wb").write(r.content)
+        except Exception as e:
+            logger.warning(f"SMPLX download failed: {e}")
+
+class IKServer:
+    def __init__(self, args):
+        self.args = args
+        self.solve_lock = threading.Lock()
+        self.config_lock = threading.Lock()
+        self.process = psutil.Process(os.getpid())
+
+        # Failure / resilience counters
+        self.agent_fail_count = 0
+        self.urdf_fail_count = 0
+        self.last_agent_error = None
+        self.last_urdf_error = None
+        self.agent_solve_counter = 0
+        self.urdf_solve_counter = 0
+        self.max_fail_retries = 2          # total attempts (initial + retries)
+        self.circuit_breaker_threshold = 5 # open after N consecutive failures
+        self.circuit_open_until = 0        # epoch time until which solves short-circuit
+        self.circuit_backoff_seconds = 5
+
+        # Numeric safety
+        self.max_num_steps_global = 20000
+        self.max_learning_rate = 5.0
+
+        # Animation buffers
+        self.animation_frames_agent = []
+        self.animation_frames_urdf = []
+
+        # FastAPI app
+        self.app = FastAPI()
+        self.app.add_middleware(
+            CORSMiddleware,
+            allow_origins=["*"], allow_credentials=True,
+            allow_methods=["*"], allow_headers=["*"],
+        )
+        os.makedirs("static", exist_ok=True)
+        os.makedirs("files", exist_ok=True)
+        self.app.mount("/static", StaticFiles(directory="static"), name="static")
+        self.app.mount("/files", StaticFiles(directory="files"), name="files")
+
+        # Initialize models
+        self._init_agent()
+        self._setup_agent_objectives()
+        self._init_urdf()
+        self._setup_urdf_objectives()
+
+        # Cleanup timing
+        self.last_cleanup_time = time.time()
+        self.cleanup_interval = 30
+
+        self._register_routes()
+        logger.info("Server ready.")
+        if getattr(self.args, 'warmup', True):
+            threading.Thread(target=self._warmup_all, daemon=True).start()
+
+    # ---------- Utility / Safety ----------
+    def _safe_int(self, v, default, lo=None, hi=None):
+        try:
+            v = int(v)
+        except Exception:
+            v = default
+        if lo is not None and v < lo: v = lo
+        if hi is not None and v > hi: v = hi
+        return v
+
+    def _safe_float(self, v, default, lo=None, hi=None):
+        try:
+            v = float(v)
+            if np.isnan(v) or np.isinf(v): raise ValueError
+        except Exception:
+            v = default
+        if lo is not None and v < lo: v = lo
+        if hi is not None and v > hi: v = hi
+        return v
+
+    def _sanitize_num_steps(self, steps):
+        return self._safe_int(steps, self.args.num_steps, 1, self.max_num_steps_global)
+
+    def _sanitize_bones(self, bones, is_urdf=False):
+        if not isinstance(bones, (list, tuple)):
+            return []
+        allowed = self.urdf_available_bones if is_urdf else self.available_bones
+        return [b for b in bones if b in allowed]
+
+    def _create_solver(self, bones, is_urdf, num_steps):
+        if is_urdf:
+            return InverseKinematicsSolver(
+                model_file=self.urdf_file,
+                controlled_bones=bones,
+                bounds=None,
+                threshold=self.args.threshold,
+                num_steps=int(num_steps),
+                compute_sdf=False,
+            )
+        bounds = []
+        for b in bones:
+            if b in self.bounds_dict:
+                lower, upper = self.bounds_dict[b]
+                bounds.extend(list(zip(lower, upper)))
+            else:
+                bounds.extend([(-90, 90)] * 3)
+        return InverseKinematicsSolver(
+            model_file=self.args.gltf_file,
+            controlled_bones=bones,
+            bounds=bounds,
+            threshold=self.args.threshold,
+            num_steps=int(num_steps),
+            compute_sdf=False,
+        )
+
+    def _rebuild_solver_safe(self, is_urdf=False, force_defaults=False):
+        try:
+            if is_urdf:
+                bones = self.urdf_default_controlled_bones if force_defaults else self.urdf_current_controlled_bones
+                bones = self._sanitize_bones(bones, True) or self.urdf_default_controlled_bones
+                self.urdf_solver = self._create_solver(bones, True, self.urdf_current_num_steps)
+                self.urdf_initial_rotations = np.zeros(len(self.urdf_solver.controlled_bones)*3, dtype=np.float32)
+                self.urdf_best_angles = self.urdf_initial_rotations.copy()
+            else:
+                bones = self.default_controlled_bones if force_defaults else self.current_controlled_bones
+                bones = self._sanitize_bones(bones, False) or self.default_controlled_bones
+                self.solver = self._create_solver(bones, False, self.current_num_steps)
+                self.initial_rotations = np.zeros(len(self.solver.controlled_bones)*3, dtype=np.float32)
+                self.best_angles = self.initial_rotations.copy()
+            return True
+        except Exception as e:
+            (self.last_urdf_error if is_urdf else setattr(self, 'last_agent_error', str(e)))
+            logger.exception("Solver rebuild failed")
+            return False
+
+    def _attempt_solver_recovery(self, is_urdf=False):
+        logger.warning("Attempting full solver recovery (reset to defaults)")
+        if is_urdf:
+            self.urdf_current_controlled_bones = self.urdf_default_controlled_bones.copy()
+            return self._rebuild_solver_safe(True, force_defaults=True)
+        else:
+            self.current_controlled_bones = self.default_controlled_bones.copy()
+            return self._rebuild_solver_safe(False, force_defaults=True)
+
+    # ---------- Warmup ----------
+    def _warmup_agent(self):
+        try:
+            mand = [DistanceObjTraj(target_points=np.array([0.0,0.2,0.35]), bone_name=self.current_end_effector, use_head=True, weight=1.0)]
+            opt = [BoneZeroRotationObj(weight=0.01)]
+            _ = self.solver.solve(initial_rotations=self.initial_rotations, learning_rate=self.args.learning_rate,
+                                   mandatory_objective_functions=tuple(mand), optional_objective_functions=tuple(opt),
+                                   ik_points=1, verbose=False,patience=1,)
+            logger.info("Agent warmup complete")
+        except Exception as e:
+            logger.warning(f"Agent warmup failed: {e}")
+    def _warmup_urdf(self):
+        try:
+            mand = [DistanceObjTraj(target_points=np.array([0.3,0.3,0.35]), bone_name=self.urdf_current_end_effector, use_head=True, weight=1.0)]
+            opt = [BoneZeroRotationObj(weight=0.01)]
+            _ = self.urdf_solver.solve(initial_rotations=self.urdf_initial_rotations, learning_rate=self.args.learning_rate,
+                                        mandatory_objective_functions=tuple(mand), optional_objective_functions=tuple(opt),
+                                        ik_points=1, verbose=False,patience=1)
+            logger.info("URDF warmup complete")
+        except Exception as e:
+            logger.warning(f"URDF warmup failed: {e}")
+    def _warmup_all(self):
+        t0 = time.time()
+        logger.info("Starting background warmup...")
+        self._warmup_agent()
+        self._warmup_urdf()
+        logger.info(f"Warmup finished in {time.time()-t0:.2f}s")
+
+    # ---------- Initialization ----------
+    def _init_agent(self):
+        self.current_num_steps = self._sanitize_num_steps(self.args.num_steps)
+        basic = InverseKinematicsSolver(
+            model_file=self.args.gltf_file,
+            controlled_bones=["left_collar"],
+            bounds=[(-90,90)]*3,
+            threshold=self.args.threshold,
+            num_steps=self.current_num_steps,
+            compute_sdf=False,
+        )
+        self.available_bones = basic.fk_solver.bone_names
+        self.bounds_dict = complete_full_body_bounds_dict
+        if self.args.hand == "left":
+            self.default_controlled_bones = list(left_arm_bounds_dict.keys())#["left_collar","left_shoulder","left_elbow","left_wrist"]
+            self.default_end_effector = "left_index3"
+        else:
+            self.default_controlled_bones = list(right_arm_bounds_dict.keys())
+            self.default_end_effector = "right_index3"
+        self.selectable_bones = [b for b in self.available_bones if b in self.bounds_dict]
+        self.current_controlled_bones = self.default_controlled_bones.copy()
+        self.current_end_effector = self.default_end_effector
+        # Direct solver creation (no cache)
+        self.solver = self._create_solver(self.current_controlled_bones, False, self.current_num_steps)
+        self.initial_rotations = np.zeros(len(self.solver.controlled_bones) * 3, dtype=np.float32)
+        self.best_angles = self.initial_rotations.copy()
+        self.mesh_data = load_mesh_data_from_gltf(self.args.gltf_file, self.solver.fk_solver)
+        self.animation_frames_agent = self._frames_from_angles([self.initial_rotations], False)
+
+    def _init_urdf(self):
+        self.urdf_current_num_steps = self._sanitize_num_steps(self.args.num_steps)
+        self.urdf_file = "files/pepper_description-master/urdf/pepper.urdf"
+        basic = InverseKinematicsSolver(
+            model_file=self.urdf_file,
+            controlled_bones=["LShoulder"],
+            bounds=None,
+            threshold=self.args.threshold,
+            num_steps=self.urdf_current_num_steps,
+            compute_sdf=False,
+        )
+        self.urdf_available_bones = basic.fk_solver.bone_names
+        self.urdf_default_controlled_bones = ["LShoulder","LBicep","LElbow","LForeArm","l_wrist"]
+        self.urdf_default_end_effector = "LFinger13_link"
+        self.urdf_selectable_bones = list(self.urdf_available_bones)
+        self.urdf_current_controlled_bones = self.urdf_default_controlled_bones.copy()
+        self.urdf_current_end_effector = self.urdf_default_end_effector
+        self.urdf_solver = self._create_solver(self.urdf_current_controlled_bones, True, self.urdf_current_num_steps)
+        self.urdf_initial_rotations = np.zeros(len(self.urdf_solver.controlled_bones) * 3, dtype=np.float32)
+        self.urdf_best_angles = self.urdf_initial_rotations.copy()
+        self.urdf_mesh_data = load_mesh_data_from_urdf(self.urdf_file, self.urdf_solver.fk_solver)
+        self.animation_frames_urdf = self._frames_from_angles([self.urdf_initial_rotations], True)
+
+    # ---------- Objectives ----------
+    def _setup_agent_objectives(self):
+        self.distance_obj = DistanceObjTraj(
+            target_points=np.array([0.0,0.2,0.35]),
+            bone_name=self.current_end_effector,
+            use_head=True,
+            weight=1.0,
+        )
+        use_fast = os.environ.get("USE_FAST_COLLISION", "1") != "0"
+        CollCls = _FastColl if use_fast else SphereCollisionPenaltyObjTraj
+        self.collision_obj = CollCls(
+            {"center":[0.1,0.0,0.35],"radius":0.1},
+            min_clearance=0.0,
+            weight=1.0,
+        )
+        # store defaults for config exposure
+        self.collision_default_center = [0.1,0.0,0.35]
+        self.collision_default_radius = 0.1
+        self.collision_default_min_clearance = 0.0
+
+    def _setup_urdf_objectives(self):
+        self.urdf_distance_obj = DistanceObjTraj(
+            target_points=np.array([0.3,0.3,0.35]),
+            bone_name=self.urdf_current_end_effector,
+            use_head=True,
+            weight=1.0,
+        )
+        use_fast = os.environ.get("USE_FAST_COLLISION", "1") != "0"
+        CollCls = _FastColl if use_fast else SphereCollisionPenaltyObjTraj
+        self.urdf_collision_obj = CollCls(
+            {"center":[0.2,0.0,0.35],"radius":0.1},
+            min_clearance=0.0,
+            weight=1.0,
+        )
+        self.urdf_collision_default_center = [0.2,0.0,0.35]
+        self.urdf_collision_default_radius = 0.1
+        self.urdf_collision_default_min_clearance = 0.0
+
+    # ---------- Build objectives per request ----------
+    def _build_agent_objectives(self, payload):
+        tgt = np.array(payload.get("target",[0.0,0.2,0.35]))
+        self.distance_obj.update_params({"bone_name": self.current_end_effector, "target_points": tgt, "weight": float(payload.get("distance_weight",1.0))})
+        # collision updates (weight, center, radius, min_clearance)
+        collision_enabled = payload.get("collision_enabled", False)
+        coll_update = {"weight": float(payload.get("collision_weight",1.0)) if collision_enabled else 0.0}
+        center = payload.get("collision_center")
+        if isinstance(center, (list, tuple)) and len(center)==3:
+            coll_update["center"] = center
+        radius = payload.get("collision_radius")
+        if radius is not None:
+            coll_update["radius"] = float(radius)
+        if "collision_min_clearance" in payload:
+            coll_update["min_clearance"] = float(payload.get("collision_min_clearance", 0.0))
+        # Always update params so compiled graph stays stable
+        self.collision_obj.update_params(coll_update)
+        subpoints = self._safe_int(payload.get("subpoints",1), 1, 1, 100)
+        mandatory, optional = [], []
+        if payload.get("distance_enabled", True): mandatory.append(self.distance_obj)
+        # Always include collision objective to avoid JIT retrace when toggling
+        optional.append(self.collision_obj)
+        if payload.get("bone_zero_enabled", True):
+            optional.append(BoneZeroRotationObj(weight=float(payload.get("bone_zero_weight",0.05))))
+        if payload.get("derivative_enabled", True) and subpoints > 1:
+            optional.append(CombinedDerivativeObj(max_order=3, weights=[float(payload.get("derivative_weight",0.05))]*3))
+        elif not payload.get("bone_zero_enabled", True) and not payload.get("derivative_enabled", True):
+            optional.append(BoneZeroRotationObj(weight=0.01))
+        # Hand specification
+        hand_shape = payload.get("hand_shape","None")
+        hand_position = payload.get("hand_position","None")
+        params = {
+            "is_pointing": hand_shape=="Pointing",
+            "is_shaping": hand_shape=="Shaping",
+            "is_flat": hand_shape=="Flat",
+            "look_forward": hand_position=="Look Forward",
+            "look_45_up": hand_position=="Look 45° Up",
+            "look_45_down": hand_position=="Look 45° Down",
+            "look_up": hand_position=="Look Up",
+            "look_down": hand_position=="Look Down",
+            "look_45_x_downwards": hand_position=="Look 45° X Downwards",
+            "look_45_x_upwards": hand_position=="Look 45° X Upwards",
+            "look_x_inward": hand_position=="Look X Inward",
+            "look_to_body": hand_position=="Look to Body",
+            "arm_down": hand_position=="Arm Down",
+            "arm_45_down": hand_position=="Arm 45° Down",
+            "arm_flat": hand_position=="Arm Flat",
+        }
+        if any(params.values()):
+            spec = HandSpecification(**params)
+            optional.extend(spec.get_objectives(
+                left_hand=self.args.hand=="left",
+                controlled_bones=self.current_controlled_bones,
+                full_trajectory=subpoints>1,
+                last_position=True,
+                weight=0.5,
+            ))
+        return mandatory, optional, subpoints
+
+    def _build_urdf_objectives(self, payload):
+        tgt = np.array(payload.get("target",[0.3,0.3,0.35]))
+        self.urdf_distance_obj.update_params({"bone_name": self.urdf_current_end_effector, "target_points": tgt, "weight": float(payload.get("distance_weight",1.0))})
+        collision_enabled = payload.get("collision_enabled", False)
+        coll_update = {"weight": float(payload.get("collision_weight",1.0)) if collision_enabled else 0.0}
+        center = payload.get("collision_center")
+        if isinstance(center, (list, tuple)) and len(center)==3:
+            coll_update["center"] = center
+        radius = payload.get("collision_radius")
+        if radius is not None:
+            coll_update["radius"] = float(radius)
+        if "collision_min_clearance" in payload:
+            coll_update["min_clearance"] = float(payload.get("collision_min_clearance", 0.0))
+        self.urdf_collision_obj.update_params(coll_update)
+        subpoints = self._safe_int(payload.get("subpoints",1),1,1,100)
+        mandatory, optional = [], []
+        if payload.get("distance_enabled", True): mandatory.append(self.urdf_distance_obj)
+        # Always include collision objective with weight possibly zero
+        optional.append(self.urdf_collision_obj)
+        if payload.get("bone_zero_enabled", True):
+            optional.append(BoneZeroRotationObj(weight=float(payload.get("bone_zero_weight",0.05))))
+        if payload.get("derivative_enabled", True) and subpoints > 1:
+            optional.append(CombinedDerivativeObj(max_order=3, weights=[float(payload.get("derivative_weight",0.05))]*3))
+        elif not payload.get("bone_zero_enabled", True) and not payload.get("derivative_enabled", True):
+            optional.append(BoneZeroRotationObj(weight=0.01))
+        return mandatory, optional, subpoints
+
+    # ---------- Frames ----------
+    def _frames_from_angles(self, angles_seq, is_urdf):
+        frames = []
+        for ang in angles_seq:
+            try:
+                if is_urdf:
+                    verts = deform_mesh(ang, self.urdf_solver.fk_solver, self.urdf_mesh_data)
+                    faces = self.urdf_mesh_data["faces"]
+                else:
+                    verts = deform_mesh(ang, self.solver.fk_solver, self.mesh_data)
+                    faces = self.mesh_data["faces"]
+                frames.append({"vertices": verts.tolist(), "faces": faces.tolist()})
+            except Exception as e:
+                logger.warning(f"Mesh deformation failed: {e}")
+        return frames
+
+    # ---------- Configuration ----------
+    def configure_agent(self, bones, eff, num_steps=None):
+        with self.config_lock:
+            if num_steps is None:
+                num_steps = self.current_num_steps
+            num_steps = self._sanitize_num_steps(num_steps)
+            bones = self._sanitize_bones(bones, False) or self.default_controlled_bones
+            if eff not in getattr(self, 'available_bones', []):
+                eff = self.default_end_effector
+            changed = (bones != self.current_controlled_bones or eff != self.current_end_effector or int(num_steps) != int(self.current_num_steps))
+            if changed:
+                try:
+                    self.current_controlled_bones = bones
+                    self.current_end_effector = eff
+                    self.current_num_steps = int(num_steps)
+                    self.solver = self._create_solver(bones, False, self.current_num_steps)
+                    self.initial_rotations = np.zeros(len(self.solver.controlled_bones)*3, dtype=np.float32)
+                    self.best_angles = self.initial_rotations.copy()
+                    self._setup_agent_objectives()
+                except Exception as e:
+                    self.agent_fail_count += 1
+                    self.last_agent_error = str(e)
+                    logger.exception("configure_agent failed; attempting default recovery")
+                    if not self._attempt_solver_recovery(False):
+                        raise
+            return {"controlled_bones": self.current_controlled_bones, "end_effector": self.current_end_effector, "num_steps": self.current_num_steps}
+
+    def configure_urdf(self, bones, eff, num_steps=None):
+        with self.config_lock:
+            if num_steps is None:
+                num_steps = self.urdf_current_num_steps
+            num_steps = self._sanitize_num_steps(num_steps)
+            bones = self._sanitize_bones(bones, True) or self.urdf_default_controlled_bones
+            if eff not in getattr(self, 'urdf_available_bones', []):
+                eff = self.urdf_default_end_effector
+            changed = (bones != self.urdf_current_controlled_bones or eff != self.urdf_current_end_effector or int(num_steps) != int(self.urdf_current_num_steps))
+            if changed:
+                try:
+                    self.urdf_current_controlled_bones = bones
+                    self.urdf_current_end_effector = eff
+                    self.urdf_current_num_steps = int(num_steps)
+                    self.urdf_solver = self._create_solver(bones, True, self.urdf_current_num_steps)
+                    self.urdf_initial_rotations = np.zeros(len(self.urdf_solver.controlled_bones)*3, dtype=np.float32)
+                    self.urdf_best_angles = self.urdf_initial_rotations.copy()
+                    self._setup_urdf_objectives()
+                except Exception as e:
+                    self.urdf_fail_count += 1
+                    self.last_urdf_error = str(e)
+                    logger.exception("configure_urdf failed; attempting default recovery")
+                    if not self._attempt_solver_recovery(True):
+                        raise
+            return {"controlled_bones": self.urdf_current_controlled_bones, "end_effector": self.urdf_current_end_effector, "num_steps": self.urdf_current_num_steps}
+
+    # ---------- Solve (hardened) ----------
+    def _solve_core(self, solver, init, mand, opt, subpoints, lr):
+        return solver.solve(
+            initial_rotations=init,
+            learning_rate=lr,
+            mandatory_objective_functions=tuple(mand),
+            optional_objective_functions=tuple(opt),
+            ik_points=subpoints,
+            verbose=False,
+            patience=100,
+        )
+
+    def solve_agent(self, payload, last_only=False):
+        if time.time() < self.circuit_open_until:
+            return {"status":"circuit_open","error":"agent circuit open","frames":len(self.animation_frames_agent)}
+        mand, opt, sub = self._build_agent_objectives(payload)
+        lr = self._safe_float(payload.get("learning_rate", self.args.learning_rate), self.args.learning_rate, 1e-5, self.max_learning_rate)
+        attempts = 0
+        best_angles = None; obj_val = float('inf'); steps = 0; error_msg=None; recovered=False
+        start=time.time()
+        while attempts < self.max_fail_retries:
+            attempts += 1
+            try:
+                best_angles, obj_val, steps = self._solve_core(self.solver, self.initial_rotations, mand, opt, sub, lr)
+                break
+            except Exception as e:
+                self.agent_fail_count += 1
+                error_msg = str(e)
+                self.last_agent_error = error_msg
+                logger.warning(f"Agent solve attempt {attempts} failed: {e}")
+                if attempts < self.max_fail_retries:
+                    # First retry: rebuild current; second: full recovery
+                    if attempts == 1:
+                        self._rebuild_solver_safe(False, force_defaults=False)
+                    else:
+                        recovered = self._attempt_solver_recovery(False)
+                else:
+                    break
+        if best_angles is None:
+            # Provide at least one frame (initial)
+            frame_angles = [self.initial_rotations]
+            if recovered:
+                frame_angles = [self.initial_rotations]
+        else:
+            self.best_angles = best_angles[-1].copy()
+            self.initial_rotations = self.best_angles.copy()
+            frame_angles = [best_angles[-1]] if last_only else best_angles
+        self.animation_frames_agent = self._frames_from_angles(frame_angles, False)
+        self.agent_solve_counter += 1
+        # Circuit breaker update
+        if best_angles is None and self.agent_fail_count >= self.circuit_breaker_threshold:
+            self.circuit_open_until = time.time() + self.circuit_backoff_seconds
+        status = "ok" if best_angles is not None else ("recovered" if recovered else "failed")
+        return {
+            "status":status,
+            "solve_time": time.time()-start,
+            "iterations": steps,
+            "objective": obj_val,
+            "frames": len(self.animation_frames_agent),
+            "solve_id": self.agent_solve_counter,
+            "attempts": attempts,
+            "error": error_msg,
+        }
+
+    def solve_urdf(self, payload, last_only=False):
+        if time.time() < self.circuit_open_until:
+            return {"status":"circuit_open","error":"urdf circuit open","frames":len(self.animation_frames_urdf)}
+        mand, opt, sub = self._build_urdf_objectives(payload)
+        lr = self._safe_float(payload.get("learning_rate", self.args.learning_rate), self.args.learning_rate, 1e-5, self.max_learning_rate)
+        attempts=0
+        best_angles=None; obj_val=float('inf'); steps=0; error_msg=None; recovered=False
+        start=time.time()
+        while attempts < self.max_fail_retries:
+            attempts += 1
+            try:
+                best_angles, obj_val, steps = self._solve_core(self.urdf_solver, self.urdf_initial_rotations, mand, opt, sub, lr)
+                break
+            except Exception as e:
+                self.urdf_fail_count += 1
+                error_msg = str(e)
+                self.last_urdf_error = error_msg
+                logger.warning(f"URDF solve attempt {attempts} failed: {e}")
+                if attempts < self.max_fail_retries:
+                    if attempts == 1:
+                        self._rebuild_solver_safe(True, force_defaults=False)
+                    else:
+                        recovered = self._attempt_solver_recovery(True)
+                else:
+                    break
+        if best_angles is None:
+            frame_angles = [self.urdf_initial_rotations]
+            if recovered:
+                frame_angles = [self.urdf_initial_rotations]
+        else:
+            self.urdf_best_angles = best_angles[-1].copy()
+            self.urdf_initial_rotations = self.urdf_best_angles.copy()
+            frame_angles = [best_angles[-1]] if last_only else best_angles
+        self.animation_frames_urdf = self._frames_from_angles(frame_angles, True)
+        self.urdf_solve_counter += 1
+        if best_angles is None and self.urdf_fail_count >= self.circuit_breaker_threshold:
+            self.circuit_open_until = time.time() + self.circuit_backoff_seconds
+        status = "ok" if best_angles is not None else ("recovered" if recovered else "failed")
+        return {
+            "status":status,
+            "solve_time": time.time()-start,
+            "iterations": steps,
+            "objective": obj_val,
+            "frames": len(self.animation_frames_urdf),
+            "solve_id": self.urdf_solve_counter,
+            "attempts": attempts,
+            "error": error_msg,
+        }
+
+    # ---------- Housekeeping ----------
+    def _cleanup(self):
+        now = time.time()
+        if now - self.last_cleanup_time < self.cleanup_interval:
+            return
+        try:
+            gc.collect()
+            # Removed cache invalidation logic (no caches anymore)
+        except Exception:
+            pass
+        self.last_cleanup_time = now
+
+    # ---------- API ----------
+    def _register_routes(self):
+        @self.app.get("/")
+        def index():
+            return FileResponse("static/index.html")
+
+        @self.app.get("/threejs_viewer")
+        def legacy():
+            return FileResponse("static/index.html")
+
+        @self.app.get("/animation")
+        def animation(request: Request):
+            model = request.query_params.get("model","agent").lower()
+            data = self.animation_frames_urdf if model == "pepper" else self.animation_frames_agent
+            return Response(content=json.dumps(data), media_type="application/json")
+
+        @self.app.get("/config")
+        def cfg(model: str = "agent"):
+            if model.lower() == "pepper":
+                return {
+                    "model":"pepper",
+                    "available_bones": self.urdf_available_bones,
+                    "selectable_bones": self.urdf_selectable_bones,
+                    "default_controlled_bones": self.urdf_current_controlled_bones,
+                    "default_end_effector": self.urdf_current_end_effector,
+                    "end_effector_choices": self.urdf_available_bones,
+                    "hand_shapes": [],
+                    "hand_positions": [],
+                    "max_subpoints": 20,
+                    "default_num_steps": self.urdf_current_num_steps,
+                    "collision_default_center": getattr(self, 'urdf_collision_default_center', [0.2,0.0,0.35]),
+                    "collision_default_radius": getattr(self, 'urdf_collision_default_radius', 0.1),
+                    "collision_default_min_clearance": getattr(self, 'urdf_collision_default_min_clearance', 0.0),
+                }
+            return {
+                "model":"agent",
+                "available_bones": self.available_bones,
+                "selectable_bones": self.selectable_bones,
+                "default_controlled_bones": self.current_controlled_bones,
+                "default_end_effector": self.current_end_effector,
+                "end_effector_choices": self.available_bones,
+                "hand_shapes":["None","Pointing","Shaping","Flat"],
+                "hand_positions":[
+                    "None","Look Forward","Look 45° Up","Look 45° Down","Look Up","Look Down",
+                    "Look 45° X Downwards","Look 45° X Upwards","Look X Inward","Look to Body",
+                    "Arm Down","Arm 45° Down","Arm Flat"
+                ],
+                "max_subpoints": 20,
+                "default_num_steps": self.current_num_steps,
+                "collision_default_center": getattr(self, 'collision_default_center', [0.1,0.0,0.35]),
+                "collision_default_radius": getattr(self, 'collision_default_radius', 0.1),
+                "collision_default_min_clearance": getattr(self, 'collision_default_min_clearance', 0.0),
+            }
+
+        @self.app.post("/configure")
+        async def configure(request: Request):
+            payload = await request.json()
+            model = payload.get("model","agent").lower()
+            num_steps = self._sanitize_num_steps(payload.get("num_steps", self.args.num_steps))
+            try:
+                if model == "pepper":
+                    cfg = self.configure_urdf(payload.get("controlled_bones", []), payload.get("end_effector"), num_steps=num_steps)
+                else:
+                    cfg = self.configure_agent(payload.get("controlled_bones", []), payload.get("end_effector"), num_steps=num_steps)
+                return JSONResponse({"status":"ok","config":cfg})
+            except Exception as e:
+                return JSONResponse({"status":"error","message":str(e)}, status_code=500)
+
+        @self.app.post("/solve")
+        async def solve(request: Request):
+            payload = await request.json()
+            model = payload.get("model","agent").lower()
+            return_mode = payload.get("frames_mode", "auto")
+            num_steps = self._sanitize_num_steps(payload.get("num_steps", self.args.num_steps))
+            subpoints = self._safe_int(payload.get("subpoints",1),1,1,100)
+            last_only = (return_mode != 'all' and subpoints == 1)
+            self._cleanup()
+            with self.solve_lock:
+                try:
+                    if model == "pepper":
+                        self.configure_urdf(payload.get("controlled_bones", []), payload.get("end_effector", self.urdf_current_end_effector), num_steps=num_steps)
+                        result = self.solve_urdf(payload, last_only=last_only); result["model"]="pepper"; result["num_steps"] = num_steps
+                        if last_only:
+                            frames = list(self.animation_frames_urdf)
+                        elif return_mode == "all" or (return_mode == "auto" and subpoints > 1):
+                            frames = list(self.animation_frames_urdf)
+                        else:
+                            frames = [self.animation_frames_urdf[-1]]
+                        result["frames_data"] = frames
+                    else:
+                        self.configure_agent(payload.get("controlled_bones", []), payload.get("end_effector", self.current_end_effector), num_steps=num_steps)
+                        result = self.solve_agent(payload, last_only=last_only); result["model"]="agent"; result["num_steps"] = num_steps
+                        if last_only:
+                            frames = list(self.animation_frames_agent)
+                        elif return_mode == "all" or (return_mode == "auto" and subpoints > 1):
+                            frames = list(self.animation_frames_agent)
+                        else:
+                            frames = [self.animation_frames_agent[-1]]
+                        result["frames_data"] = frames
+                    status = result.get("status","ok")
+                    top_status = "ok" if status in ("ok","recovered") else status
+                    return JSONResponse({"status":top_status,"result":result})
+                except Exception as e:
+                    logger.exception("Solve failed unrecoverably")
+                    return JSONResponse({"status":"error","message":str(e)}, status_code=500)
+
+        @self.app.post("/reset")
+        def reset():
+            with self.solve_lock:
+                self._attempt_solver_recovery(False)
+                self._attempt_solver_recovery(True)
+                return {"status":"ok","message":"solvers reset"}
+
+        @self.app.get("/health")
+        def health():
+            rss = self.process.memory_info().rss if self.process else 0
+            return {
+                "status":"ok",
+                "agent_frames": len(self.animation_frames_agent),
+                "urdf_frames": len(self.animation_frames_urdf),
+                "agent_fail_count": self.agent_fail_count,
+                "urdf_fail_count": self.urdf_fail_count,
+                "last_agent_error": self.last_agent_error,
+                "last_urdf_error": self.last_urdf_error,
+                "circuit_open_for": max(0, int(self.circuit_open_until - time.time())),
+                "memory_rss_mb": round(rss/1024/1024,1),
+            }
+
+        @self.app.get("/favicon.ico")
+        def favicon():
+            return Response(status_code=204)
+
+# ---------- Main ----------
+def main():
+    parser = configargparse.ArgumentParser(description="Inverse Kinematics Solver - Three.js Web UI", default_config_files=["config.ini"])
+    parser.add_argument("--gltf_file", type=str, default="files/smplx.glb")
+    parser.add_argument("--hand", type=str, choices=["left","right"], default="left")
+    parser.add_argument("--threshold", type=float, default=0.005)
+    parser.add_argument("--num_steps", type=int, default=100)
+    parser.add_argument("--learning_rate", type=float, default=0.2)
+    parser.add_argument("--subpoints", type=int, default=1)
+    parser.add_argument("--api_port", type=int, default=17861)
+    parser.add_argument("--warmup", action='store_true', default=True, help="Enable background JIT warmup")
+    args = parser.parse_args()
+
+    download_and_setup_files()
+    srv = IKServer(args)
+    import uvicorn
+    uvicorn.run(srv.app, host="0.0.0.0", port=args.api_port)
+
+if __name__ == "__main__":
+    main()

collision_objectives.py

@@ -0,0 +1,83 @@
+import jax
+import jax.numpy as jnp
+import numpy as np
+from jax.tree_util import register_pytree_node_class
+from jax_ik.objectives import ObjectiveFunction
+
+@register_pytree_node_class
+class FastSphereCollisionPenaltyObjTraj(ObjectiveFunction):
+    """Vectorized sphere collision penalty over bone segments.
+
+    Weight stored as Python float (static aux) to avoid tracer-to-Python
+    concretization when objective always present with varying weight.
+    """
+    def __init__(self, sphere_collider: dict, weight: float = 1.0, min_clearance: float = 0.05, segment_radius: float = 0.02):
+        self.center = jnp.asarray(sphere_collider["center"], jnp.float32)
+        self.radius = jnp.asarray(sphere_collider["radius"], jnp.float32)
+        self.min_clearance = jnp.asarray(min_clearance, jnp.float32)
+        self.segment_radius = jnp.asarray(segment_radius, jnp.float32)
+        self.weight = float(weight)
+
+    # pytree impl ------------------------------------------------------------
+    def tree_flatten(self):
+        # weight treated as static (aux) so changing it may retrace but avoids concretization errors
+        return (self.center, self.radius, self.min_clearance, self.segment_radius), (self.weight,)
+
+    @classmethod
+    def tree_unflatten(cls, aux, leaves):
+        (weight,) = aux
+        c, r, mc, sr = leaves
+        return cls(dict(center=c, radius=r), weight, mc, sr)
+
+    # API --------------------------------------------------------------------
+    def update_params(self, p: dict) -> None:
+        if "sphere_collider" in p:
+            collider = p["sphere_collider"]
+            if "center" in collider:
+                self.center = jnp.asarray(collider["center"], jnp.float32)
+            if "radius" in collider:
+                self.radius = jnp.asarray(collider["radius"], jnp.float32)
+        if "center" in p:
+            self.center = jnp.asarray(p["center"], jnp.float32)
+        if "radius" in p:
+            self.radius = jnp.asarray(p["radius"], jnp.float32)
+        if "min_clearance" in p:
+            self.min_clearance = jnp.asarray(p["min_clearance"], jnp.float32)
+        if "segment_radius" in p:
+            self.segment_radius = jnp.asarray(p["segment_radius"], jnp.float32)
+        if "weight" in p:
+            self.weight = float(p["weight"])
+
+    def get_params(self) -> dict:
+        return dict(
+            sphere_collider=dict(center=np.asarray(self.center).tolist(), radius=float(self.radius)),
+            min_clearance=float(self.min_clearance),
+            segment_radius=float(self.segment_radius),
+            weight=float(self.weight),
+        )
+
+    # core -------------------------------------------------------------------
+    def _penalty_single(self, cfg, fk_solver) -> jnp.ndarray:
+        fk = fk_solver.compute_fk_from_angles(cfg)  # (N,4,4)
+        heads = fk[:, :3, 3]                        # (N,3)
+        parents = jnp.asarray(fk_solver.parent_list, jnp.int32)  # (N,)
+        seg_mask = (parents >= 0).astype(jnp.float32)            # (N,)
+        safe_parent_indices = jnp.where(parents >= 0, parents, 0)
+        p_head = heads[safe_parent_indices]
+        c_head = heads
+        v = c_head - p_head
+        dot_vv = jnp.sum(v * v, axis=1) + 1e-6
+        eff_rad = self.radius + self.min_clearance + self.segment_radius
+        vc = self.center - p_head
+        t = jnp.clip(jnp.sum(vc * v, axis=1) / dot_vv, 0.0, 1.0)
+        closest = p_head + t[:, None] * v
+        dist = jnp.linalg.norm(self.center - closest, axis=1)
+        penetration = jnp.maximum(0.0, eff_rad - dist)
+        return jnp.sum((penetration ** 2) * seg_mask)
+
+    def __call__(self, X: jnp.ndarray, fk_solver) -> jnp.ndarray:
+        if X.ndim == 1:
+            loss = self._penalty_single(X, fk_solver)
+        else:
+            loss = jnp.mean(jax.vmap(lambda c: self._penalty_single(c, fk_solver))(X))
+        return loss * jnp.float32(self.weight)

packages.txt

@@ -0,0 +1,2 @@
+xvfb
+libgl1-mesa-glx

requirements.txt

@@ -0,0 +1,8 @@
+jax-ik==0.1.6
+wandb
+pillow
+scipy
+configargparse
+requests
+uvicorn
+fastapi

static/index.html

@@ -0,0 +1,473 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<title>JAX-IK Three.js IK Demo</title>
+<style>
+  body { margin:0; font-family:Arial, sans-serif; background:#1e1e1e; color:#ddd; }
+  header { padding:10px 16px; background:#111; border-bottom:1px solid #333; }
+  h1 { margin:0; font-size:18px; }
+  #tabs { display:flex; background:#222; }
+  .tab-btn { padding:10px 16px; cursor:pointer; border:none; background:#222; color:#ccc; font-size:13px; }
+  .tab-btn.active { background:#333; color:#fff; }
+  #content { display:flex; height:calc(100vh - 82px); }
+  #viewerPane { flex: 1 1 auto; position:relative; }
+  #uiPane { width:360px; overflow-y:auto; background:#181818; border-left:1px solid #333; padding:10px 12px; box-sizing:border-box; }
+  fieldset { border:1px solid #444; margin:8px 0 14px 0; padding:8px 10px; }
+  legend { padding:0 6px; font-size:12px; color:#9ad; }
+  label { display:block; font-size:12px; margin:4px 0; }
+  input[type=number], select { width:100%; box-sizing:border-box; background:#222; border:1px solid #444; color:#ddd; padding:4px; }
+  input[type=text] { width:100%; box-sizing:border-box; background:#222; border:1px solid #444; color:#ddd; padding:4px; }
+  button.primary { background:#2d6be3; color:#fff; border:none; padding:8px 12px; cursor:pointer; font-size:12px; border-radius:3px; }
+  button.secondary { background:#444; color:#eee; border:none; padding:6px 10px; cursor:pointer; font-size:12px; border-radius:3px; margin-left:4px; }
+  .flex-row { display:flex; gap:6px; }
+  .inline { display:inline-block; }
+  #statusBar { font-size:11px; background:#111; padding:6px 10px; border-top:1px solid #333; position:fixed; bottom:0; left:0; right:0; color:#aaa; }
+  .bone-grid { columns:2 140px; column-gap:12px; }
+  .bone-grid label { break-inside:avoid; }
+  .viewer-canvas { position:absolute; top:0; left:0; width:100%; height:100%; }
+  #log { position:absolute; right:8px; top:8px; max-width:260px; max-height:50%; overflow:auto; font:11px monospace; background:rgba(0,0,0,0.55); padding:6px; border:1px solid #444; border-radius:4px; }
+  .badge { font-size:10px; background:#444; color:#ccc; padding:2px 5px; border-radius:3px; margin-left:4px; }
+  #toastContainer { position:fixed; /* moved from top-left to bottom-left */ bottom:56px; left:10px; z-index:9999; display:flex; flex-direction:column; gap:8px; pointer-events:none; }
+  .toast { min-width:220px; max-width:300px; background:rgba(30,30,30,0.95); color:#eee; font:12px/1.4 Arial, sans-serif;
+           border:1px solid #444; border-radius:4px; padding:8px 10px; box-shadow:0 4px 12px rgba(0,0,0,0.4);
+           opacity:0; transform:translateY(6px); transition:opacity .18s ease, transform .18s ease; pointer-events:auto; }
+  .toast.show { opacity:1; transform:translateY(0); }
+  .toast.success { border-color:#2e8b57; }
+  .toast.error { border-color:#b33939; }
+  .toast .toast-close { float:right; cursor:pointer; color:#888; margin-left:6px; }
+  .toast .toast-close:hover { color:#fff; }
+  .axis-pair { margin:4px 0; }
+  .axis-pair .flex-row { align-items:center; }
+  .axis-pair span { width:14px; display:inline-block; font-size:11px; color:#aaa; }
+</style>
+<!-- Added import map to resolve bare specifier 'three' -->
+<script type="importmap">
+{
+  "imports": {
+    "three": "https://unpkg.com/three@0.160.0/build/three.module.js"
+  }
+}
+</script>
+</head>
+<body>
+<header>
+  <h1>
+    <a href="https://github.com/hvoss-techfak/TF-JAX-IK" target="_blank" rel="noopener noreferrer" style="color:#fff; text-decoration:none;">
+      JAX IK Demo - Please visit our Github Page for more information
+    </a>
+    <span class="badge" id="modelBadge">Agent</span>
+  </h1>
+</header>
+<div id="tabs">
+  <button class="tab-btn active" data-model="agent">Virtual Agent</button>
+  <button class="tab-btn" data-model="pepper">URDF Robot</button>
+</div>
+<div id="content">
+  <div id="viewerPane">
+    <div id="log"></div>
+    <!-- Canvas inserted by three.js -->
+  </div>
+  <div id="uiPane">
+    <fieldset>
+      <legend>Target Position</legend>
+      <label>X
+        <div class="flex-row">
+          <input id="target_x" type="number" value="0.0" step="0.01" data-auto-solve="change">
+          <input id="target_x_slider" type="range" min="-1" max="1" step="0.01" value="0.0">
+        </div>
+      </label>
+      <label>Y
+        <div class="flex-row">
+          <input id="target_y" type="number" value="0.2" step="0.01" data-auto-solve="change">
+          <input id="target_y_slider" type="range" min="-1" max="1" step="0.01" value="0.2">
+        </div>
+      </label>
+      <label>Z <input id="target_z" type="number" value="0.35" step="0.01" data-auto-solve="change"></label>
+      <label>Trajectory Points
+        <!-- changed: removed '(static only)', removed disabled, max updated dynamically -->
+        <input id="subpoints" type="number" value="1" min="1" max="20" step="1" data-auto-solve="change">
+      </label>
+    </fieldset>
+    <fieldset>
+      <legend>Primary Objectives</legend>
+      <label><input id="distance_enabled" type="checkbox" checked> Distance Objective</label>
+      <label>Distance Weight <input id="distance_weight" type="number" value="1.0" step="0.1"></label>
+    </fieldset>
+    <fieldset id="collisionFieldset">
+      <legend>Collision Sphere</legend>
+      <label><input id="collision_enabled" type="checkbox"> Enable Collision Sphere</label>
+      <div class="axis-pair">X
+        <div class="flex-row">
+          <input id="collision_cx" type="number" value="0.1" step="0.01">
+          <input id="collision_cx_slider" type="range" min="-1" max="1" step="0.01" value="0.1">
+        </div>
+      </div>
+      <div class="axis-pair">Y
+        <div class="flex-row">
+          <input id="collision_cy" type="number" value="0.0" step="0.01">
+          <input id="collision_cy_slider" type="range" min="-1" max="1" step="0.01" value="0.0">
+        </div>
+      </div>
+      <div class="axis-pair">Z
+        <div class="flex-row">
+          <input id="collision_cz" type="number" value="0.35" step="0.01">
+          <input id="collision_cz_slider" type="range" min="-1" max="1" step="0.01" value="0.35">
+        </div>
+      </div>
+      <label>Collision Weight <input id="collision_weight" type="number" value="1.0" step="0.1"></label>
+      <label>Sphere Radius <input id="collision_radius" type="number" value="0.1" step="0.01" min="0.01" max="1.0"></label>
+      <label>Min Clearance
+        <div class="flex-row">
+          <input id="collision_min_clearance" type="number" value="0.0" step="0.005" min="0" max="0.5">
+          <input id="collision_min_clearance_slider" type="range" min="0" max="0.5" step="0.005" value="0.0">
+        </div>
+      </label>
+    </fieldset>
+    <fieldset>
+      <legend>Regularization</legend>
+      <label><input id="bone_zero_enabled" type="checkbox" checked> Bone Zero Rotation</label>
+      <label>Bone Zero Weight <input id="bone_zero_weight" type="number" value="0.1" step="0.01"></label>
+      <label><input id="derivative_enabled" type="checkbox" checked> Trajectory Smoothing</label>
+      <label>Derivative Weight <input id="derivative_weight" type="number" value="0.05" step="0.01"></label>
+    </fieldset>
+    <fieldset id="handFieldset">
+      <legend>Hand (Agent Only)</legend>
+      <label>Hand Shape
+        <select id="hand_shape"></select>
+      </label>
+      <label>Hand Position
+        <select id="hand_position"></select>
+      </label>
+    </fieldset>
+    <fieldset>
+      <legend>Configuration</legend>
+      <label>End Effector
+        <select id="end_effector"></select>
+      </label>
+      <div style="margin-top:6px; font-size:12px;">Controlled Bones:</div>
+      <div id="bonesContainer" class="bone-grid"></div>
+    </fieldset>
+    <fieldset>
+      <legend>Model / Animation</legend>
+      <!-- CHANGED: added explicit style to ensure invisibility -->
+      <label hidden style="display:none;">GLTF URL <input id="gltf_url" type="text" value="/files/smplx.glb"></label>
+      <div class="flex-row" style="margin-top:6px;">
+        <button id="reset_cam" class="secondary" type="button">Reset Camera</button>
+      </div>
+      <label style="margin-top:8px;"><input id="wireframe" type="checkbox"> Wireframe</label>
+      <label style="margin-top:4px;"><input id="show_gltf" type="checkbox" checked> Show GLTF Reference</label>
+      <label style="margin-top:4px;"><input id="show_ikmesh" type="checkbox" checked> Show IK Mesh</label>
+      <label>Playback FPS <input id="play_fps" type="number" value="24" min="1" max="120"></label>
+    </fieldset>
+    <fieldset>
+      <legend>Solver</legend>
+      <label>Steps <input id="num_steps" type="number" value="50" min="1" max="10000" step="10"></label>
+    </fieldset>
+    <div style="text-align:right; margin-top:10px;">
+      <button id="solve_btn" class="primary" type="button">Solve IK</button>
+    </div>
+  </div>
+</div>
+<div id="statusBar">Ready.</div>
+<div id="toastContainer"></div>
+<script type="module">
+import * as THREE from 'three';
+import { OrbitControls } from 'https://unpkg.com/three@0.160.0/examples/jsm/controls/OrbitControls.js';
+import { GLTFLoader } from 'https://unpkg.com/three@0.160.0/examples/jsm/loaders/GLTFLoader.js';
+
+(function(){
+  // ----- Logging -----
+  const logEl = document.getElementById('log');
+  function log(msg){
+    const t = new Date().toISOString().split('T')[1].replace('Z','');
+    logEl.textContent = `[${t}] ${msg}\n` + logEl.textContent.slice(0, 8000);
+  }
+
+  // ----- State -----
+  let currentModel = 'agent';
+  let configData = null;
+  let animationFrames = [];
+  let frameIndex = 0;
+  let ikMesh = null;
+  let usingGLTFGeometry = false;
+  let gltfRoot = null;
+  let gltfPrimaryMaterial = null;
+  let gltfPrimaryMesh = null;
+  let gltfPrimaryMaterialCaptured = false;
+  let fallbackMesh = null;
+  let lastTime = performance.now();
+  let lastSolveIdAgent = 0;
+  let lastSolveIdPepper = 0;
+
+  // ----- Auto-solve -----
+  let solving = false;
+  let solveDebounceTimer = null;
+  const SOLVE_DEBOUNCE_MS = 25;
+  let currentSolveController = null;
+  function scheduleSolve(immediate=false){
+    if (solving){ if (currentSolveController) currentSolveController.abort(); }
+    if (immediate){ triggerSolve(true); return; }
+    if (solveDebounceTimer) clearTimeout(solveDebounceTimer);
+    solveDebounceTimer = setTimeout(()=> triggerSolve(false), SOLVE_DEBOUNCE_MS);
+  }
+  async function triggerSolve(){
+    if (currentSolveController) currentSolveController.abort();
+    currentSolveController = new AbortController();
+    const controller = currentSolveController;
+    solving = true;
+    try { await doSolve(controller.signal); }
+    catch(e){ if (e.name !== 'AbortError') {} }
+    finally { if (controller === currentSolveController) solving = false; }
+  }
+
+  // Playback state
+  let playbackEnabled = false;
+  const allowLoopPlayback = false;
+
+  // Ground alignment state
+  let baseOffsetY = 0;
+  let groundAligned = false;
+  let pendingAlign = false;
+  let alignAttemptCount = 0;
+  const maxAlignAttempts = 120;
+
+  // Trajectory / spline state
+  let controlFrames = [];
+  let splineMode = false;
+  let splineU = 0;
+  let splineDuration = 2.0;
+  let initialCameraFramed = false;
+
+  function cleanupVisuals(){
+    if (fallbackMesh){
+      modelGroup.remove(fallbackMesh);
+      if (fallbackMesh.geometry) fallbackMesh.geometry.dispose();
+      if (fallbackMesh.material) fallbackMesh.material.dispose();
+      fallbackMesh = null;
+    }
+    if (gltfRoot){
+      gltfRoot.traverse(o=>{ if (o.isMesh){ if (o.geometry) o.geometry.dispose(); if (o.material){ if (Array.isArray(o.material)) o.material.forEach(m=>m.dispose()); else o.material.dispose(); } } });
+      modelGroup.remove(gltfRoot); gltfRoot = null;
+    }
+    while (modelGroup.children.length) modelGroup.remove(modelGroup.children[0]);
+    gltfPrimaryMesh = null; gltfPrimaryMaterial = null; gltfPrimaryMaterialCaptured = false; ikMesh = null; usingGLTFGeometry = false;
+    animationFrames = []; frameIndex = 0; baseOffsetY = 0; groundAligned = false; pendingAlign = false; alignAttemptCount = 0;
+    log('Visuals cleaned.');
+  }
+  function scheduleGroundAlign(force=false){ if (force){ groundAligned=false; alignAttemptCount=0; } pendingAlign=true; }
+  function performGroundAlign(){
+    if (!pendingAlign) return;
+    if (!modelGroup.children.length){ if (++alignAttemptCount > maxAlignAttempts) pendingAlign=false; return; }
+    const box = new THREE.Box3().setFromObject(modelGroup);
+    if (box.isEmpty() || !isFinite(box.min.y)){ if (++alignAttemptCount > maxAlignAttempts) pendingAlign=false; return; }
+    const currentMin = box.min.y; const delta = -currentMin;
+    if (delta > 0 || Math.abs(delta) < 1e-3){
+      modelGroup.position.y += delta; baseOffsetY = modelGroup.position.y; groundAligned = true; updateTargetSphere(); updateCollisionSphere();
+    }
+    pendingAlign=false;
+  }
+  function fitCamera(obj){
+    const targetObj = modelGroup.children.length ? modelGroup : obj; if (!targetObj) return;
+    const box = new THREE.Box3().setFromObject(targetObj); if (box.isEmpty()) return;
+    const size = box.getSize(new THREE.Vector3()); const center = box.getCenter(new THREE.Vector3());
+    controls.target.copy(center); const maxDim = Math.max(size.x,size.y,size.z);
+    const dist = maxDim * 3; const dir = new THREE.Vector3(0.0,0.5,1).normalize();
+    camera.position.copy(center).addScaledVector(dir, dist);
+    camera.near = maxDim/100; camera.far = maxDim*100; camera.updateProjectionMatrix(); controls.update();
+  }
+
+  // ----- DOM refs -----
+  const statusBar = document.getElementById('statusBar');
+  const bonesContainer = document.getElementById('bonesContainer');
+  const endEffectorSel = document.getElementById('end_effector');
+  const handShapeSel = document.getElementById('hand_shape');
+  const handPosSel = document.getElementById('hand_position');
+  const handFieldset = document.getElementById('handFieldset');
+  const modelBadge = document.getElementById('modelBadge');
+  const subpointsInput = document.getElementById('subpoints');
+  const numStepsInput = document.getElementById('num_steps');
+  // Collision inputs
+  const collisionEnabledEl = document.getElementById('collision_enabled');
+  const collisionWeightEl = document.getElementById('collision_weight');
+  const collCx = document.getElementById('collision_cx');
+  const collCy = document.getElementById('collision_cy');
+  const collCz = document.getElementById('collision_cz');
+  const collCxSlider = document.getElementById('collision_cx_slider');
+  const collCySlider = document.getElementById('collision_cy_slider');
+  const collCzSlider = document.getElementById('collision_cz_slider');
+  const collRadiusEl = document.getElementById('collision_radius');
+  const collMinClearEl = document.getElementById('collision_min_clearance');
+  const collMinClearSlider = document.getElementById('collision_min_clearance_slider');
+
+  function val(id){ return document.getElementById(id).value; }
+  function num(id){ return parseFloat(val(id)); }
+  function bool(id){ return document.getElementById(id).checked; }
+
+  // ----- Three.js scene -----
+  const renderer = new THREE.WebGLRenderer({ antialias:true });
+  renderer.setPixelRatio(window.devicePixelRatio);
+  renderer.setSize(document.getElementById('viewerPane').clientWidth, document.getElementById('viewerPane').clientHeight);
+  renderer.domElement.className = 'viewer-canvas';
+  document.getElementById('viewerPane').appendChild(renderer.domElement);
+  const scene = new THREE.Scene(); scene.background = new THREE.Color(0x222222);
+  const camera = new THREE.PerspectiveCamera(45, renderer.domElement.clientWidth / renderer.domElement.clientHeight, 0.01, 1000);
+  camera.position.set(0,1,3);
+  const controls = new OrbitControls(camera, renderer.domElement); controls.target.set(0,0.8,0);
+  scene.add(new THREE.HemisphereLight(0xffffff,0x444444,1.0));
+  const d = new THREE.DirectionalLight(0xffffff,0.8); d.position.set(3,10,10); scene.add(d);
+  const ground = new THREE.Mesh(new THREE.CircleGeometry(5,48), new THREE.MeshStandardMaterial({color:0x303030, metalness:0.1, roughness:0.9}));
+  ground.rotation.x = -Math.PI/2; ground.receiveShadow = true; scene.add(ground); ground.visible = false;
+  const modelGroup = new THREE.Group(); scene.add(modelGroup);
+
+  // Target sphere
+  const targetSphereGeom = new THREE.SphereGeometry(0.01, 24, 24);
+  const targetSphereMat = new THREE.MeshStandardMaterial({color:0x00ff55, emissive:0x008833});
+  const targetSphere = new THREE.Mesh(targetSphereGeom, targetSphereMat); scene.add(targetSphere);
+  // Collision sphere (unit scaled later)
+  const collisionSphereGeom = new THREE.SphereGeometry(1, 32, 32);
+  const collisionSphereMat = new THREE.MeshStandardMaterial({color:0xff4444, emissive:0x660000, transparent:true, opacity:0.18, wireframe:false});
+  const collisionSphere = new THREE.Mesh(collisionSphereGeom, collisionSphereMat); scene.add(collisionSphere); collisionSphere.visible = false;
+
+  function updateTargetSphere(){
+    const xRaw = parseFloat(document.getElementById('target_x').value) || 0;
+    const yRaw = parseFloat(document.getElementById('target_y').value) || 0;
+    const zRaw = parseFloat(document.getElementById('target_z').value) || 0;
+    const sx = modelGroup?.scale?.x ?? 1; const sy = modelGroup?.scale?.y ?? 1; const sz = modelGroup?.scale?.z ?? 1;
+    const tx = modelGroup?.position?.x ?? 0; const ty = modelGroup?.position?.y ?? 0; const tz = modelGroup?.position?.z ?? 0;
+    targetSphere.position.set(xRaw * sx + tx, yRaw * sy + ty, zRaw * sz + tz);
+  }
+  function updateCollisionSphere(){
+    const cx = parseFloat(collCx.value) || 0; const cy = parseFloat(collCy.value) || 0; const cz = parseFloat(collCz.value) || 0;
+    const r = parseFloat(collRadiusEl.value) || 0.1; const mc = parseFloat(collMinClearEl.value) || 0.0;
+    const sx = modelGroup?.scale?.x ?? 1; const sy = modelGroup?.scale?.y ?? 1; const sz = modelGroup?.scale?.z ?? 1; const tx = modelGroup?.position?.x ?? 0; const ty = modelGroup?.position?.y ?? 0; const tz = modelGroup?.position?.z ?? 0;
+    collisionSphere.position.set(cx * sx + tx, cy * sy + ty, cz * sz + tz);
+    const uniform = (sx+sy+sz)/3; const effective = r + mc; // visualize base radius + clearance
+    collisionSphere.scale.set(effective*uniform, effective*uniform, effective*uniform);
+    collisionSphere.visible = collisionEnabledEl.checked;
+  }
+  ['target_x','target_y','target_z'].forEach(id=>{ document.getElementById(id).addEventListener('input', updateTargetSphere); document.getElementById(id).addEventListener('change', updateTargetSphere); });
+  updateTargetSphere(); updateCollisionSphere();
+
+  window.addEventListener('resize', () => { renderer.setSize(document.getElementById('viewerPane').clientWidth, document.getElementById('viewerPane').clientHeight); camera.aspect = renderer.domElement.clientWidth / renderer.domElement.clientHeight; camera.updateProjectionMatrix(); });
+  function resetCamera(){ camera.position.set(0,1,3); controls.target.set(0,0.8,0); controls.update(); }
+
+  // ----- Config fetch -----
+  async function loadConfig(){ const res = await fetch(`/config?model=${currentModel}`); configData = await res.json(); populateUIFromConfig(); log(`Config loaded for ${currentModel}`); }
+
+  function populateUIFromConfig(){
+    endEffectorSel.innerHTML = ""; configData.end_effector_choices.forEach(b=>{ const opt=document.createElement('option'); opt.value=b; opt.textContent=b; if (b===configData.default_end_effector) opt.selected=true; endEffectorSel.appendChild(opt); });
+    bonesContainer.innerHTML = ""; configData.selectable_bones.forEach(b=>{ const id=`bone_${b}`; const label=document.createElement('label'); label.innerHTML = `<input type="checkbox" id="${id}" ${configData.default_controlled_bones.includes(b)?'checked':''}> ${b}`; bonesContainer.appendChild(label); setTimeout(()=>{ const cb=document.getElementById(id); if (cb) cb.addEventListener('change', ()=> scheduleSolve()); },0); });
+    if (currentModel === 'agent'){ handFieldset.style.display=''; handShapeSel.innerHTML=""; configData.hand_shapes.forEach(s=>{ const o=document.createElement('option'); o.value=s; o.textContent=s; handShapeSel.appendChild(o); }); handPosSel.innerHTML=""; configData.hand_positions.forEach(s=>{ const o=document.createElement('option'); o.value=s; o.textContent=s; handPosSel.appendChild(o); }); } else { handFieldset.style.display='none'; }
+    if (configData && typeof configData.max_subpoints !== 'undefined') subpointsInput.max = configData.max_subpoints;
+    if (configData && typeof configData.default_num_steps !== 'undefined') numStepsInput.value = configData.default_num_steps;
+    if (configData && configData.collision_default_center){ const c=configData.collision_default_center; collCx.value=c[0]; collCy.value=c[1]; collCz.value=c[2]; collCxSlider.value=c[0]; collCySlider.value=c[1]; collCzSlider.value=c[2]; }
+    if (configData && typeof configData.collision_default_radius !== 'undefined'){ collRadiusEl.value = configData.collision_default_radius; }
+    if (configData && typeof configData.collision_default_min_clearance !== 'undefined'){ collMinClearEl.value = configData.collision_default_min_clearance; collMinClearSlider.value = configData.collision_default_min_clearance; }
+    updateTargetSphere(); updateCollisionSphere();
+  }
+
+  subpointsInput.addEventListener('change', ()=>{ const v=parseInt(subpointsInput.value,10); if (v<=1){ document.getElementById('derivative_enabled').checked=false; } scheduleSolve(); });
+
+  function applyModelSpecificGLTFPolicy(){ const urlInput=document.getElementById('gltf_url'); const showGltfChk=document.getElementById('show_gltf'); if (currentModel==='pepper'){ showGltfChk.disabled=true; if (gltfRoot) gltfRoot.visible=false; } else { if (!urlInput.value) urlInput.value="/files/smplx.glb"; showGltfChk.disabled=false; } }
+
+  const gltfLoader = new GLTFLoader();
+  function loadGLTF(url){ if (!url){ log('No GLTF URL (possibly Pepper) - skipping load.'); return; } const u=url.startsWith('http')?url:url; statusBar.textContent=`Loading GLTF: ${u}`; log(`Loading GLTF ${u}`); gltfLoader.load(u, gltf=>{ if (gltfRoot) modelGroup.remove(gltfRoot); gltfRoot=gltf.scene; gltfPrimaryMaterial=null; gltfPrimaryMesh=null; gltfPrimaryMaterialCaptured=false; gltfRoot.traverse(o=>{ if (o.isMesh && o.geometry?.attributes?.position){ if (!gltfPrimaryMesh || o.geometry.attributes.position.count > gltfPrimaryMesh.geometry.attributes.position.count){ gltfPrimaryMesh=o; } } }); if (gltfPrimaryMesh){ if (Array.isArray(gltfPrimaryMesh.material)){ const mm=gltfPrimaryMesh.material.find(m=>m.map) || gltfPrimaryMesh.material[0]; gltfPrimaryMaterial=mm.clone(); } else { gltfPrimaryMaterial=gltfPrimaryMesh.material.clone(); } gltfPrimaryMaterialCaptured=true; log(`Captured GLTF primary mesh (verts=${gltfPrimaryMesh.geometry.attributes.position.count})`); } else { log('No primary mesh found in GLTF.'); }
+      modelGroup.add(gltfRoot); gltfRoot.visible=document.getElementById('show_gltf').checked; if (animationFrames.length){ ensureActiveMeshBound(animationFrames[0]); applyFrame(animationFrames[Math.min(frameIndex, animationFrames.length-1)]); } fitCamera(gltfRoot); statusBar.textContent='GLTF loaded.'; }, undefined, err=>{ statusBar.textContent='GLTF error: '+err.message; log('GLTF error: '+err.message); }); }
+
+  document.getElementById('solve_btn').onclick = ()=> triggerSolve(true);
+  function collectBones(){ const bones=[]; if (!configData) return bones; configData.selectable_bones.forEach(b=>{ const cb=document.getElementById(`bone_${b}`); if (cb && cb.checked) bones.push(b); }); return bones; }
+
+  async function doSolve(abortSignal){
+    statusBar.textContent='Solving...'; log('Solve request started');
+    const subpointsVal=parseInt(val('subpoints'),10);
+    const payload={
+      model: currentModel,
+      target: [num('target_x'), num('target_y'), num('target_z')],
+      subpoints: subpointsVal,
+      num_steps: parseInt(numStepsInput.value,10) || 100,
+      distance_enabled: bool('distance_enabled'),
+      distance_weight: num('distance_weight'),
+      collision_enabled: collisionEnabledEl.checked,
+      collision_weight: parseFloat(collisionWeightEl.value)||1.0,
+      collision_center: [parseFloat(collCx.value)||0, parseFloat(collCy.value)||0, parseFloat(collCz.value)||0],
+      collision_radius: parseFloat(collRadiusEl.value)||0.1,
+      bone_zero_enabled: bool('bone_zero_enabled'),
+      bone_zero_weight: num('bone_zero_weight'),
+      derivative_enabled: bool('derivative_enabled'),
+      derivative_weight: num('derivative_weight'),
+      controlled_bones: collectBones(),
+      end_effector: endEffectorSel.value,
+      hand_shape: currentModel==='agent'? handShapeSel.value : 'None',
+      hand_position: currentModel==='agent'? handPosSel.value : 'None',
+      frames_mode: subpointsVal > 1 ? 'auto' : 'last',
+      collision_min_clearance: parseFloat(collMinClearEl.value)||0.0,
+    };
+    try { const t0=performance.now(); const res=await fetch('/solve',{method:'POST', headers:{'Content-Type':'application/json'}, body:JSON.stringify(payload), signal:abortSignal}); if (!res.ok) throw new Error(res.status+' '+res.statusText); const json=await res.json(); if (json.status!=='ok') throw new Error(json.message || 'Solve failed'); const sid=json.result.solve_id||0; if (payload.model==='agent'){ if (sid <= lastSolveIdAgent){ log(`Stale agent solve ignored (sid=${sid} <= ${lastSolveIdAgent})`); return; } lastSolveIdAgent=sid; } else { if (sid <= lastSolveIdPepper){ log(`Stale pepper solve ignored (sid=${sid} <= ${lastSolveIdPepper})`); return; } lastSolveIdPepper=sid; }
+      const server=json.result.solve_time; const total=(performance.now()-t0)/1000; statusBar.textContent=`Solved: server=${server.toFixed(2)}s total=${total.toFixed(2)}s it=${json.result.iterations} obj=${json.result.objective.toFixed(6)} frames=${json.result.frames}`; log(`Solve completed (frames received=${json.result.frames})`); if (json.result.frames_data && json.result.frames_data.length){ animationFrames=json.result.frames_data; ensureActiveMeshBound(animationFrames[0]); controlFrames=[]; splineMode=false; playbackEnabled=false; if (animationFrames.length>1 && subpointsVal>1){ setupSplinePlayback(animationFrames); applyFrame(animationFrames[0]); } else { frameIndex=animationFrames.length-1; applyFrame(animationFrames[frameIndex]); } scheduleGroundAlign(); }
+      updateTargetSphere(); updateCollisionSphere(); showToast(`Solve OK • it=${json.result.iterations} • t=${json.result.solve_time.toFixed(2)}s • err=${json.result.objective.toExponential(2)}`,'success',4000); }
+    catch(e){ if (e.name==='AbortError'){ log('Solve aborted (superseded)'); return; } statusBar.textContent='Solve error: '+e.message; log('Solve error: '+e.message); showToast(`Solve ERROR: ${e.message}`,'error',6000); }
+  }
+
+  const toastContainer=document.getElementById('toastContainer');
+  function showToast(message, type='success', ttl=4000){ const el=document.createElement('div'); el.className=`toast ${type}`; const close=document.createElement('span'); close.className='toast-close'; close.textContent='✕'; close.onclick=e=>{ e.stopPropagation(); remove(); }; const content=document.createElement('div'); content.textContent=message; el.appendChild(close); el.appendChild(content); toastContainer.appendChild(el); requestAnimationFrame(()=> el.classList.add('show')); function remove(){ el.classList.remove('show'); setTimeout(()=> el.remove(), 180); } setTimeout(remove, ttl); }
+
+  const xNum=document.getElementById('target_x'); const yNum=document.getElementById('target_y'); const zNum=document.getElementById('target_z'); const xSlider=document.getElementById('target_x_slider'); const ySlider=document.getElementById('target_y_slider');
+  function syncSliderToNum(axis){ if (axis==='x') xSlider.value=xNum.value; else if (axis==='y') ySlider.value=yNum.value; }
+  function syncNumToSlider(axis){ if (axis==='x') xNum.value=xSlider.value; else if (axis==='y') yNum.value=ySlider.value; }
+  xSlider.addEventListener('input', ()=>{ syncNumToSlider('x'); updateTargetSphere(); }); ySlider.addEventListener('input', ()=>{ syncNumToSlider('y'); updateTargetSphere(); });
+  xSlider.addEventListener('change', ()=>{ syncNumToSlider('x'); updateTargetSphere(); scheduleSolve(); }); ySlider.addEventListener('change', ()=>{ syncNumToSlider('y'); updateTargetSphere(); scheduleSolve(); });
+  xNum.addEventListener('change', ()=>{ syncSliderToNum('x'); updateTargetSphere(); scheduleSolve(); }); yNum.addEventListener('change', ()=>{ syncSliderToNum('y'); updateTargetSphere(); scheduleSolve(); }); zNum.addEventListener('change', ()=>{ updateTargetSphere(); scheduleSolve(); });
+
+  // Collision sliders
+  function syncCollSliderToNum(axis){ if (axis==='x') collCxSlider.value=collCx.value; else if (axis==='y') collCySlider.value=collCy.value; else if (axis==='z') collCzSlider.value=collCz.value; else if (axis==='mc') collMinClearSlider.value=collMinClearEl.value; }
+  function syncCollNumToSlider(axis){ if (axis==='x') collCx.value=collCxSlider.value; else if (axis==='y') collCy.value=collCySlider.value; else if (axis==='z') collCz.value=collCzSlider.value; else if (axis==='mc') collMinClearEl.value=collMinClearSlider.value; }
+  ['x','y','z'].forEach(a=>{ const slider = a==='x'?collCxSlider: a==='y'?collCySlider:collCzSlider; slider.addEventListener('input', ()=>{ syncCollNumToSlider(a); updateCollisionSphere(); }); slider.addEventListener('change', ()=>{ syncCollNumToSlider(a); updateCollisionSphere(); scheduleSolve(); }); });
+  [collCx, collCy, collCz].forEach((el,i)=> el.addEventListener('change', ()=>{ syncCollSliderToNum(i===0?'x':i===1?'y':'z'); updateCollisionSphere(); scheduleSolve(); }));
+  collRadiusEl.addEventListener('change', ()=>{ updateCollisionSphere(); scheduleSolve(); });
+  collisionEnabledEl.addEventListener('change', ()=>{ updateCollisionSphere(); scheduleSolve(); });
+  collMinClearSlider.addEventListener('input', ()=>{ syncCollNumToSlider('mc'); updateCollisionSphere(); });
+  collMinClearSlider.addEventListener('change', ()=>{ syncCollNumToSlider('mc'); updateCollisionSphere(); scheduleSolve(); });
+  collMinClearEl.addEventListener('change', ()=>{ syncCollSliderToNum('mc'); updateCollisionSphere(); scheduleSolve(); });
+
+  const autoSolveSelectors=[
+    '#distance_enabled','#distance_weight',
+    '#collision_enabled','#collision_weight', '#collision_radius', '#collision_cx', '#collision_cy', '#collision_cz', '#collision_min_clearance',
+    '#bone_zero_enabled','#bone_zero_weight',
+    '#derivative_enabled','#derivative_weight',
+    '#hand_shape','#hand_position',
+    '#end_effector','#wireframe','#show_gltf','#show_ikmesh',
+    '#play_fps','#num_steps'
+  ];
+  autoSolveSelectors.forEach(sel=>{ const el=document.querySelector(sel); if (el){ const evt=(el.type==='checkbox'||el.tagName==='SELECT')?'change':'input'; el.addEventListener(evt, ()=> scheduleSolve()); }});
+
+  document.getElementById('wireframe').addEventListener('change', ()=>{ if (ikMesh && ikMesh.material){ ikMesh.material.wireframe=document.getElementById('wireframe').checked; ikMesh.material.needsUpdate=true; } if (gltfPrimaryMesh && gltfPrimaryMesh.material){ if (Array.isArray(gltfPrimaryMesh.material)) gltfPrimaryMesh.material.forEach(m=>{m.wireframe=document.getElementById('wireframe').checked; m.needsUpdate=true;}); else { gltfPrimaryMesh.material.wireframe=document.getElementById('wireframe').checked; gltfPrimaryMesh.material.needsUpdate=true; } } });
+  document.getElementById('show_gltf').addEventListener('change', ()=>{ if (gltfRoot) gltfRoot.visible=document.getElementById('show_gltf').checked; });
+  document.getElementById('show_ikmesh').addEventListener('change', ()=>{ if (ikMesh) ikMesh.visible=document.getElementById('show_ikmesh').checked; });
+
+  function ensureActiveMeshBound(firstFrame){ if (!firstFrame) return; const verts=firstFrame.vertices; let bound=false; if (gltfPrimaryMesh && gltfPrimaryMesh.geometry?.attributes?.position && gltfPrimaryMesh.geometry.attributes.position.count === verts.length){ if (fallbackMesh){ modelGroup.remove(fallbackMesh); if (fallbackMesh.geometry) fallbackMesh.geometry.dispose(); if (fallbackMesh.material && !Array.isArray(fallbackMesh.material)) fallbackMesh.material.dispose(); fallbackMesh=null; } ikMesh=gltfPrimaryMesh; usingGLTFGeometry=true; if (gltfPrimaryMaterial) ikMesh.material=gltfPrimaryMaterial; bound=true; log('ensureActiveMeshBound: using GLTF primary mesh'); }
+    if (!bound){ if (!fallbackMesh || !fallbackMesh.geometry?.getAttribute('position') || fallbackMesh.geometry.getAttribute('position').count !== verts.length){ if (fallbackMesh){ modelGroup.remove(fallbackMesh); if (fallbackMesh.geometry) fallbackMesh.geometry.dispose(); if (fallbackMesh.material && !Array.isArray(fallbackMesh.material)) fallbackMesh.material.dispose(); }
+        const geom=new THREE.BufferGeometry(); const posArr=new Float32Array(verts.length*3); for (let i=0;i<verts.length;i++){ const v=verts[i]; posArr[i*3]=v[0]; posArr[i*3+1]=v[1]; posArr[i*3+2]=v[2]; } geom.setAttribute('position', new THREE.BufferAttribute(posArr,3)); geom.getAttribute('position').setUsage(THREE.DynamicDrawUsage); const faces=firstFrame.faces; const idx=new Uint32Array(faces.length*3); for (let i=0;i<faces.length;i++){ const f=faces[i]; idx[i*3]=f[0]; idx[i*3+1]=f[1]; idx[i*3+2]=f[2]; } geom.setIndex(new THREE.BufferAttribute(idx,1)); geom.computeVertexNormals(); const mat=gltfPrimaryMaterial?gltfPrimaryMaterial.clone(): new THREE.MeshStandardMaterial({color:0x6699ff, metalness:0.2, roughness:0.6}); fallbackMesh=new THREE.Mesh(geom, mat); fallbackMesh.visible=document.getElementById('show_ikmesh').checked; modelGroup.add(fallbackMesh); ikMesh=fallbackMesh; usingGLTFGeometry=false; log('ensureActiveMeshBound: created fallback mesh'); } else { ikMesh=fallbackMesh; usingGLTFGeometry=false; log('ensureActiveMeshBound: reused fallback mesh'); } }
+    if (currentModel==='pepper' && ikMesh){ const box=new THREE.Box3().setFromObject(modelGroup); const h=box.max.y - box.min.y; const targetH=1.2; if (h>0 && (h<0.6 || h>2.0)){ const s=targetH / h; modelGroup.scale.set(s,s,s); log(`Pepper scaled: origH=${h.toFixed(3)} scale=${s.toFixed(3)}`); scheduleGroundAlign(true); } }
+    if (gltfRoot) gltfRoot.visible=document.getElementById('show_gltf').checked; if (ikMesh) ikMesh.visible=document.getElementById('show_ikmesh').checked; updateTargetSphere(); updateCollisionSphere(); }
+
+  function applyFrame(frame){ if (!ikMesh || !frame) return; const posAttr=ikMesh.geometry.getAttribute('position'); if (!posAttr || posAttr.count !== frame.vertices.length){ log('applyFrame: vertex count mismatch'); return; } const arr=posAttr.array; const verts=frame.vertices; for (let i=0;i<verts.length;i++){ const v=verts[i]; arr[i*3]=v[0]; arr[i*3+1]=v[1]; arr[i*3+2]=v[2]; } posAttr.needsUpdate=true; if (!groundAligned) scheduleGroundAlign(); }
+  function bsplineBasis(t){ const t2=t*t, t3=t2*t; return [(1 - 3*t + 3*t2 - t3)/6,(4 - 6*t2 + 3*t3)/6,(1 + 3*t + 3*t2 - 3*t3)/6,t3/6]; }
+  function getControlFrame(i){ if (i<0) return controlFrames[0]; if (i>=controlFrames.length) return controlFrames[controlFrames.length-1]; return controlFrames[i]; }
+  function evalSplineVertices(u){ if (!ikMesh || controlFrames.length<2) return; const n=controlFrames.length; const seg=Math.min(Math.floor(u), n-2); const t=u - seg; const [w0,w1,w2,w3]=bsplineBasis(t); const f0=getControlFrame(seg-1); const f1=getControlFrame(seg); const f2=getControlFrame(seg+1); const f3=getControlFrame(seg+2); const posAttr=ikMesh.geometry.getAttribute('position'); if (!posAttr) return; const arr=posAttr.array; const v0=f0.vertices, v1=f1.vertices, v2=f2.vertices, v3=f3.vertices; const count=posAttr.count; for (let i=0;i<count;i++){ const a0=v0[i], a1=v1[i], a2=v2[i], a3=v3[i]; arr[i*3]=w0*a0[0]+w1*a1[0]+w2*a2[0]+w3*a3[0]; arr[i*3+1]=w0*a0[1]+w1*a1[1]+w2*a2[1]+w3*a3[1]; arr[i*3+2]=w0*a0[2]+w1*a1[2]+w2*a2[2]+w3*a3[2]; } posAttr.needsUpdate=true; if (!groundAligned) scheduleGroundAlign(); }
+  function setupSplinePlayback(frames){ controlFrames=frames; splineMode=true; splineU=0; const segments=frames.length - 1; splineDuration=Math.min(segments * 0.6, 8.0); playbackEnabled=true; }
+  function updateFramePlayback(){ if (!animationFrames.length) return; const idx=Math.min(Math.floor(frameIndex), animationFrames.length - 1); applyFrame(animationFrames[idx]); }
+
+  document.querySelectorAll('.tab-btn').forEach(btn=>{ btn.onclick=()=>{ if (btn.classList.contains('active')) return; document.querySelectorAll('.tab-btn').forEach(b=>b.classList.remove('active')); btn.classList.add('active'); currentModel=btn.getAttribute('data-model'); modelBadge.textContent=currentModel==='pepper'? 'Pepper Robot':'Agent'; cleanupVisuals(); initialCameraFramed=false; applyModelSpecificGLTFPolicy(); loadConfig().then(()=>{ if (currentModel==='agent'){ const url=document.getElementById('gltf_url').value; if (url) loadGLTF(url); } scheduleSolve(true); updateTargetSphere(); updateCollisionSphere(); }); }; });
+
+  function animate(now){ requestAnimationFrame(animate); const dt=(now - lastTime)/1000; lastTime=now; if (splineMode && playbackEnabled){ const n=controlFrames.length; if (n>1){ splineU += (dt / splineDuration) * (n - 1); if (splineU >= (n - 1)){ splineU = n - 1; playbackEnabled=false; } evalSplineVertices(splineU); } } else if (animationFrames.length>1 && playbackEnabled){ const fps=parseInt(document.getElementById('play_fps').value,10) || 24; frameIndex += dt * fps; if (frameIndex >= animationFrames.length){ if (allowLoopPlayback){ frameIndex=0; } else { frameIndex=animationFrames.length - 1; playbackEnabled=false; } } updateFramePlayback(); } if (pendingAlign) performGroundAlign(); if (!initialCameraFramed && modelGroup.children.length){ fitCamera(modelGroup); initialCameraFramed=true; } renderer.render(scene, camera); }
+  requestAnimationFrame(animate);
+
+  document.getElementById('reset_cam').addEventListener('click', ()=>{ fitCamera(modelGroup); });
+
+  applyModelSpecificGLTFPolicy();
+  loadConfig().then(()=>{ const url=document.getElementById('gltf_url').value; if (url) loadGLTF(url); scheduleGroundAlign(true); scheduleSolve(true); updateTargetSphere(); updateCollisionSphere(); });
+})();
+</script>
+</body>
+</html>