@wandelbots/wandelbots-js-react-components 4.6.0 → 4.7.0

package/dist/MotionGroupVisualizer-D8_sA8PA.js

@@ -0,0 +1,1347 @@
+import { j as e, d as Me, v as Te, o as Se, e as C } from "./externalizeComponent-BOqKMZMc.js";
+import * as g from "three";
+import { Matrix4 as b, Vector3 as G, Quaternion as B } from "three";
+import { ConvexGeometry as oe, RoundedBoxGeometry as ke } from "three-stdlib";
+import Ge, { useEffect as M, useMemo as U, useRef as _, useCallback as k, useState as A, Suspense as ie } from "react";
+import { useThree as ae, useFrame as ce, Canvas as Q } from "@react-three/fiber";
+import { Environment as Ae, Lightformer as L, Line as W, useGLTF as Le, Bounds as Z } from "@react-three/drei";
+import { useTheme as Pe, Card as Fe, Box as v, Typography as z, Divider as ee, Button as te } from "@mui/material";
+import { observer as Ie } from "mobx-react-lite";
+import { useTranslation as Ve } from "react-i18next";
+import { N as De, V as le, c as ue, b as re, M as T, J as O } from "./interpolation-B8AcxfdD.js";
+import { ErrorBoundary as pe } from "react-error-boundary";
+function Oe(t) {
+  switch (t.shape_type) {
+    case "convex_hull":
+      return new oe(
+        t.vertices.map(
+          (r) => new g.Vector3(
+            r[0] / 1e3,
+            r[1] / 1e3,
+            r[2] / 1e3
+          )
+        )
+      );
+    case "box":
+      return new g.BoxGeometry(
+        t.size_x / 1e3,
+        t.size_y / 1e3,
+        t.size_z / 1e3
+      );
+    case "sphere":
+      return new g.SphereGeometry(t.radius / 1e3);
+    case "capsule":
+      return new g.CapsuleGeometry(
+        t.radius / 1e3,
+        t.cylinder_height / 1e3
+      );
+    case "cylinder":
+      return new g.CylinderGeometry(
+        t.radius / 1e3,
+        t.radius / 1e3,
+        t.height / 1e3
+      );
+    case "rectangle":
+      return new g.BoxGeometry(t.size_x / 1e3, t.size_y / 1e3, 0);
+    default:
+      return console.warn(`${t.shape_type} is not supported`), new g.BufferGeometry();
+  }
+}
+function Ue({
+  name: t,
+  collider: n,
+  children: r
+}) {
+  var d, u;
+  const c = ((d = n.pose) == null ? void 0 : d.position) ?? [0, 0, 0], s = ((u = n.pose) == null ? void 0 : u.orientation) ?? [0, 0, 0];
+  return n.margin && console.warn(`${t} margin is not supported`), /* @__PURE__ */ e.jsx(
+    "mesh",
+    {
+      name: t,
+      position: new g.Vector3(
+        c[0],
+        c[1],
+        c[2]
+      ).divideScalar(1e3),
+      rotation: new g.Euler(s[0], s[1], s[2], "XYZ"),
+      geometry: Oe(n.shape),
+      children: r
+    }
+  );
+}
+function Ce({
+  name: t,
+  colliders: n,
+  meshChildrenProvider: r,
+  ...c
+}) {
+  return /* @__PURE__ */ e.jsx("group", { name: t, ...c, children: Object.entries(n).map(([s, d]) => /* @__PURE__ */ e.jsx(
+    Ue,
+    {
+      name: s,
+      collider: d,
+      children: r(s, d)
+    },
+    s
+  )) });
+}
+function at({
+  scene: t,
+  meshChildrenProvider: n
+}) {
+  const r = t.colliders;
+  return /* @__PURE__ */ e.jsx("group", { children: r && /* @__PURE__ */ e.jsx(
+    Ce,
+    {
+      meshChildrenProvider: n,
+      colliders: r
+    }
+  ) });
+}
+function ne() {
+  return /* @__PURE__ */ e.jsx(Ae, { children: /* @__PURE__ */ e.jsx(Ee, {}) });
+}
+function Ee({ positions: t = [2, 0, 2, 0, 2, 0, 2, 0] }) {
+  return /* @__PURE__ */ e.jsxs(e.Fragment, { children: [
+    /* @__PURE__ */ e.jsx(
+      L,
+      {
+        intensity: 5,
+        "rotation-x": Math.PI / 2,
+        position: [0, 5, -9],
+        scale: [10, 10, 1]
+      }
+    ),
+    /* @__PURE__ */ e.jsx("group", { rotation: [0, 0.5, 0], children: /* @__PURE__ */ e.jsx("group", { children: t.map((n, r) => /* @__PURE__ */ e.jsx(
+      L,
+      {
+        form: "circle",
+        intensity: 5,
+        rotation: [Math.PI / 2, 0, 0],
+        position: [n, 4, r * 4],
+        scale: [3, 1, 1]
+      },
+      r
+    )) }) }),
+    /* @__PURE__ */ e.jsx(
+      L,
+      {
+        intensity: 40,
+        "rotation-y": Math.PI / 2,
+        position: [-5, 1, -1],
+        scale: [20, 0.1, 1]
+      }
+    ),
+    /* @__PURE__ */ e.jsx(
+      L,
+      {
+        intensity: 20,
+        "rotation-y": -Math.PI,
+        position: [-5, -2, -1],
+        scale: [20, 0.1, 1]
+      }
+    ),
+    /* @__PURE__ */ e.jsx(
+      L,
+      {
+        "rotation-y": Math.PI / 2,
+        position: [-5, -1, -1],
+        scale: [20, 0.5, 1],
+        intensity: 5
+      }
+    ),
+    /* @__PURE__ */ e.jsx(
+      L,
+      {
+        "rotation-y": -Math.PI / 2,
+        position: [10, 1, 0],
+        scale: [20, 1, 1],
+        intensity: 10
+      }
+    ),
+    /* @__PURE__ */ e.jsx(
+      L,
+      {
+        form: "ring",
+        color: "white",
+        intensity: 5,
+        scale: 10,
+        position: [-15, 4, -18],
+        target: [0, 0, 0]
+      }
+    )
+  ] });
+}
+function ct({
+  safetyZones: t,
+  dhParameters: n,
+  ...r
+}) {
+  const c = {
+    attach: "material",
+    color: "#009f4d",
+    opacity: 0.2,
+    depthTest: !1,
+    depthWrite: !1,
+    transparent: !0,
+    polygonOffset: !0
+  }, s = Me(n ?? []);
+  M(() => {
+    Array.isArray(t) && console.warn("SafetyZonesRenderer: The support of V1 safety zones is deprecated. Please migrate to V2 safety zones.");
+  }, [t]);
+  const d = (p, i) => {
+    var m, j;
+    if (!((m = i == null ? void 0 : i.pose) != null && m.position) || !((j = i == null ? void 0 : i.pose) != null && j.orientation))
+      return null;
+    const o = new g.Vector3(i.pose.position[0] / 1e3, i.pose.position[1] / 1e3, i.pose.position[2] / 1e3), a = new g.Vector3(i.pose.orientation[0], i.pose.orientation[1], i.pose.orientation[2]);
+    let l;
+    const x = i.shape.shape_type === "plane" ? { ...c, side: g.DoubleSide } : { ...c, side: g.FrontSide };
+    switch (i.shape.shape_type) {
+      /**
+       * Plane shape, uses DH parameters to calculate the size of the plane (reach distance of a robot)
+       */
+      case "plane":
+        l = /* @__PURE__ */ e.jsx("planeGeometry", { args: [s, s] });
+        break;
+      /**
+       * Sphere shape
+       */
+      case "sphere": {
+        const y = (i == null ? void 0 : i.shape).radius / 1e3;
+        l = /* @__PURE__ */ e.jsx("sphereGeometry", { args: [y] });
+        break;
+      }
+      /**
+       * Capsule shape
+       */
+      case "capsule": {
+        const y = (i == null ? void 0 : i.shape).radius / 1e3, R = (i == null ? void 0 : i.shape).cylinder_height / 1e3;
+        l = /* @__PURE__ */ e.jsx("capsuleGeometry", { args: [y, R] });
+        break;
+      }
+      /**
+       * Convex hull, checks at first if the vertices are coplanar - if yes, adds a small offset for
+       * renderer to be able to visualize the convex hull.
+       */
+      case "convex_hull": {
+        const y = (i == null ? void 0 : i.shape).vertices.map(
+          (w) => new g.Vector3(w[0] / 1e3, w[1] / 1e3, w[2] / 1e3)
+        ), R = Te(y);
+        if (R.isCoplanar && R.normal) {
+          const P = new g.Vector3().addVectors(
+            y[0],
+            R.normal.multiplyScalar(1e-4)
+          );
+          y.push(P);
+        }
+        try {
+          l = /* @__PURE__ */ e.jsx("primitive", { object: new oe(y), attach: "geometry" });
+        } catch (w) {
+          return console.log("Error creating ConvexGeometry:", w), null;
+        }
+        break;
+      }
+      /**
+       * Convex hull around four spheres. Sphere center points in x/y-plane,
+       * offset by either combination "+/- sizeX" or "+/- sizeY".
+       * Alternative description: Rectangle in x/y-plane with a 3D padding (source: nova-api docs)
+       *
+       * Basically a rounded box with a rectangular cross-section.
+       */
+      case "rectangular_capsule": {
+        const y = i.shape, R = y.radius / 1e3, w = y.sphere_center_distance_x / 1e3, P = y.sphere_center_distance_y / 1e3, $ = R * 2;
+        l = /* @__PURE__ */ e.jsx("primitive", { object: new ke(w, P, $, 2, R), attach: "geometry" });
+        break;
+      }
+      default:
+        console.warn("Unsupported safety zone shape type:", i.shape.shape_type), l = null;
+    }
+    return /* @__PURE__ */ e.jsxs(
+      "mesh",
+      {
+        renderOrder: p,
+        position: o,
+        quaternion: Se(a),
+        children: [
+          l,
+          /* @__PURE__ */ e.jsx(
+            "meshStandardMaterial",
+            {
+              ...x,
+              polygonOffsetFactor: -p
+            }
+          )
+        ]
+      },
+      `safety-zone-${i.shape.shape_type}-${p}`
+    );
+  }, u = () => Object.values(t ?? {}).map((p, i) => d(i, p)), h = () => Array.isArray(t) ? t.map((p, i) => {
+    let o = [];
+    return p.geometry && (p.geometry.compound ? o = p.geometry.compound.child_geometries : p.geometry.convex_hull && (o = [p.geometry])), o.map((a, l) => {
+      if (!a.convex_hull) return null;
+      const x = i * 1e3 + l, m = {
+        pose: {
+          position: [0, 0, 0],
+          orientation: [0, 0, 0]
+        },
+        shape: {
+          shape_type: "convex_hull",
+          vertices: a.convex_hull.vertices.map((j) => [j.x, j.y, j.z])
+        }
+      };
+      return d(x, m);
+    });
+  }) : null, f = U(() => Array.isArray(t) ? h() : u(), [t, h, u]);
+  return /* @__PURE__ */ e.jsx("group", { ...r, children: f });
+}
+function lt({
+  trajectory: t,
+  ...n
+}) {
+  var c;
+  const r = ((c = t.trajectory) == null ? void 0 : c.map((s) => s.tcp_pose ? new g.Vector3(
+    s.tcp_pose.position.x / 1e3,
+    s.tcp_pose.position.z / 1e3,
+    -s.tcp_pose.position.y / 1e3
+  ) : null).filter((s) => s !== null)) || [];
+  return /* @__PURE__ */ e.jsx("group", { ...n, children: r.length > 0 && /* @__PURE__ */ e.jsx(
+    W,
+    {
+      points: r,
+      lineWidth: 3,
+      polygonOffset: !0,
+      polygonOffsetFactor: 10,
+      polygonOffsetUnits: 10
+    }
+  ) });
+}
+const J = /* @__PURE__ */ new Map();
+async function E(t, n) {
+  if (J.has(t))
+    return J.get(t);
+  const r = (async () => {
+    var u;
+    const c = n || "", s = new De({ instanceUrl: c }), d = s.api.motionGroupModels;
+    (u = d.axios) != null && u.interceptors && d.axios.interceptors.request.use((h) => {
+      var f;
+      return (f = h.url) != null && f.includes("/glb") && (h.responseType = "blob"), h;
+    });
+    try {
+      const h = await s.api.motionGroupModels.getMotionGroupGlbModel(t);
+      return URL.createObjectURL(h);
+    } catch (h) {
+      throw console.error("Failed to fetch model:", h), h;
+    }
+  })();
+  return J.set(t, r), r;
+}
+function de(t) {
+  function n(r) {
+    return r.children.length === 0 ? [r] : [r, ...r.children.flatMap((c) => n(c))];
+  }
+  return n(t).filter((r) => he(r));
+}
+function fe(t) {
+  return t.name.endsWith("_FLG");
+}
+function he(t) {
+  return /_J[0-9]+$/.test(t.name);
+}
+function Je(t, n) {
+  let r;
+  function c(s) {
+    if (fe(s)) {
+      if (r)
+        throw Error(
+          `Found multiple flange groups in robot model ${n}; first ${r.name} then ${s.name}. Only one _FLG group is allowed.`
+        );
+      r = s;
+    }
+    he(s), s.children.map(c);
+  }
+  if (c(t.scene), !r)
+    throw Error(
+      `No flange group found in robot model ${n}. Flange must be identified with a name ending in _FLG.`
+    );
+  return { gltf: t };
+}
+function me({
+  rapidlyChangingMotionState: t,
+  dhParameters: n,
+  onRotationChanged: r,
+  children: c
+}) {
+  const s = _([]), d = _([]), u = _(null), { invalidate: h } = ae();
+  M(() => {
+    const o = t.joint_position.filter(
+      (a) => a !== void 0
+    );
+    return u.current = new le(o, {
+      tension: 120,
+      // Controls spring stiffness - higher values create faster, more responsive motion
+      friction: 20,
+      // Controls damping - higher values reduce oscillation and create smoother settling
+      threshold: 1e-3
+    }), () => {
+      var a;
+      (a = u.current) == null || a.destroy();
+    };
+  }, []), ce((o, a) => {
+    if (u.current) {
+      const l = u.current.update(a);
+      p(), l || h();
+    }
+  });
+  function f(o) {
+    o && (d.current = de(o), p(), h());
+  }
+  function p() {
+    var a;
+    const o = ((a = u.current) == null ? void 0 : a.getCurrentValues()) || [];
+    if (r)
+      r(d.current, o);
+    else
+      for (const [l, x] of d.current.entries()) {
+        const m = n[l], j = m.theta || 0, y = m.reverse_rotation_direction ? -1 : 1;
+        x.rotation.y = y * (o[l] || 0) + j;
+      }
+  }
+  const i = k(() => {
+    const o = t.joint_position.filter(
+      (a) => a !== void 0
+    );
+    requestAnimationFrame(() => {
+      var a;
+      s.current = o, (a = u.current) == null || a.setTarget(o);
+    });
+  }, [t]);
+  return M(() => {
+    i();
+  }, [t, i]), ue(() => {
+    i();
+  }), /* @__PURE__ */ e.jsx("group", { ref: f, children: c });
+}
+const Be = "line", We = "mesh";
+function $e({
+  rapidlyChangingMotionState: t,
+  dhParameters: n,
+  ...r
+}) {
+  const c = new b(), s = _([]), d = _([]);
+  Ge.useEffect(() => {
+    s.current = new Array(n.length).fill(null), d.current = new Array(n.length).fill(null);
+  }, [n.length]);
+  function u(p, i) {
+    const o = new G(), a = new B(), l = new G();
+    c.decompose(o, a, l);
+    const x = o.clone(), m = new b().makeRotationY(
+      p.theta + i * (p.reverse_rotation_direction ? -1 : 1)
+    ).multiply(new b().makeTranslation(0, p.d / 1e3, 0)).multiply(new b().makeTranslation(p.a / 1e3, 0, 0)).multiply(new b().makeRotationX(p.alpha));
+    return c.multiply(m), c.decompose(o, a, l), { a: x, b: o };
+  }
+  function h(p, i, o, a) {
+    if (!n)
+      return;
+    const l = n[p];
+    if (!l)
+      return;
+    const { a: x, b: m } = u(l, a);
+    i.geometry.setPositions([x.toArray(), m.toArray()].flat()), o.position.set(m.x, m.y, m.z);
+  }
+  function f(p, i) {
+    c.identity();
+    for (let o = 0; o < Math.min(p.length, i.length); o++) {
+      const a = s.current[o], l = d.current[o];
+      a && l && h(o, a, l, i[o]);
+    }
+  }
+  return /* @__PURE__ */ e.jsx(e.Fragment, { children: /* @__PURE__ */ e.jsx(
+    me,
+    {
+      rapidlyChangingMotionState: t,
+      dhParameters: n,
+      onRotationChanged: f,
+      children: /* @__PURE__ */ e.jsxs("group", { ...r, name: "Scene", children: [
+        /* @__PURE__ */ e.jsxs("mesh", { children: [
+          /* @__PURE__ */ e.jsx("sphereGeometry", { args: [0.01, 32, 32] }),
+          /* @__PURE__ */ e.jsx("meshStandardMaterial", { color: "black", depthTest: !0 })
+        ] }),
+        n.map((p, i) => {
+          const { a: o, b: a } = u(
+            p,
+            t.joint_position[i] ?? 0
+          ), l = `dhrobot_J0${i}`;
+          return /* @__PURE__ */ e.jsxs("group", { name: l, children: [
+            /* @__PURE__ */ e.jsx(
+              W,
+              {
+                ref: (x) => {
+                  s.current[i] = x;
+                },
+                name: Be,
+                points: [o, a],
+                color: "white",
+                lineWidth: 5
+              }
+            ),
+            /* @__PURE__ */ e.jsxs(
+              "mesh",
+              {
+                ref: (x) => {
+                  d.current[i] = x;
+                },
+                name: We,
+                position: a,
+                children: [
+                  /* @__PURE__ */ e.jsx("sphereGeometry", { args: [0.01, 32, 32] }),
+                  /* @__PURE__ */ e.jsx("meshStandardMaterial", { color: "black", depthTest: !0 })
+                ]
+              },
+              "mesh_" + i
+            )
+          ] }, l);
+        })
+      ] })
+    }
+  ) });
+}
+const He = console.warn;
+function xe() {
+  return M(() => {
+    console.warn = (t) => {
+      t !== "Cannot call the manual advancement of rafz whilst frameLoop is not set as demand" && He(t);
+    };
+  }, []), /* @__PURE__ */ e.jsx(e.Fragment, {});
+}
+function Ne(t) {
+  return t.type === "Mesh";
+}
+function qe({
+  url: t,
+  flangeRef: n,
+  postModelRender: r,
+  ...c
+}) {
+  const s = Le(t);
+  let d;
+  try {
+    d = Je(s, "robot.glb").gltf;
+  } catch (f) {
+    throw f;
+  }
+  const u = k(
+    (f) => {
+      f && r && r();
+    },
+    [r]
+  );
+  function h(f) {
+    try {
+      return Ne(f) ? f.geometry ? /* @__PURE__ */ e.jsx(
+        "mesh",
+        {
+          name: f.name,
+          geometry: f.geometry,
+          material: f.material,
+          position: f.position,
+          rotation: f.rotation
+        },
+        f.uuid
+      ) : /* @__PURE__ */ e.jsx("group", { name: f.name, position: f.position, rotation: f.rotation }, f.uuid) : /* @__PURE__ */ e.jsx(
+        "group",
+        {
+          name: f.name,
+          position: f.position,
+          rotation: f.rotation,
+          ref: fe(f) ? n : void 0,
+          children: f.children.map(h)
+        },
+        f.uuid
+      );
+    } catch (p) {
+      return console.warn("Error rendering node", f.name, p), null;
+    }
+  }
+  return /* @__PURE__ */ e.jsx("group", { ...c, dispose: null, ref: u, children: h(d.scene) });
+}
+function ye({
+  modelURL: t,
+  flangeRef: n,
+  postModelRender: r,
+  ...c
+}) {
+  const [s, d] = A(null);
+  return M(() => {
+    (async () => {
+      try {
+        if (typeof t == "string")
+          d(t);
+        else {
+          const h = await t;
+          d(h);
+        }
+      } catch (h) {
+        console.error("Failed to resolve model URL:", h);
+      }
+    })();
+  }, [t]), s ? /* @__PURE__ */ e.jsx(
+    qe,
+    {
+      url: s,
+      flangeRef: n,
+      postModelRender: r,
+      ...c
+    }
+  ) : null;
+}
+const ge = (t, n) => {
+  t.userData.isGhost || (t.traverse((r) => {
+    if (r instanceof g.Mesh) {
+      r.material instanceof g.Material && (r.material.colorWrite = !1);
+      const c = r.clone(), s = r.clone();
+      c.material = new g.MeshStandardMaterial({
+        depthTest: !0,
+        depthWrite: !0,
+        colorWrite: !1,
+        polygonOffset: !0,
+        polygonOffsetFactor: -1,
+        side: g.DoubleSide
+      }), c.userData.isGhost = !0, s.material = new g.MeshStandardMaterial({
+        color: n,
+        opacity: 0.3,
+        depthTest: !0,
+        depthWrite: !1,
+        transparent: !0,
+        polygonOffset: !0,
+        polygonOffsetFactor: -2,
+        side: g.DoubleSide
+      }), s.userData.isGhost = !0, r.parent && (r.parent.add(c), r.parent.add(s));
+    }
+  }), t.userData.isGhost = !0);
+}, je = (t) => {
+  if (!t.userData.isGhost) return;
+  const n = [];
+  t.traverse((r) => {
+    var c;
+    r instanceof g.Mesh && ((c = r.userData) != null && c.isGhost ? n.push(r) : r.material instanceof g.Material && (r.material.colorWrite = !0));
+  }), n.forEach((r) => {
+    r.parent && r.parent.remove(r);
+  }), t.userData.isGhost = !1;
+}, we = C(
+  ({
+    rapidlyChangingMotionState: t,
+    modelFromController: n,
+    dhParameters: r,
+    getModel: c = E,
+    flangeRef: s,
+    postModelRender: d,
+    transparentColor: u,
+    instanceUrl: h,
+    ...f
+  }) => {
+    const [p, i] = A(null), o = k((l) => {
+      i(l);
+    }, []);
+    M(() => {
+      p && (u ? ge(p, u) : je(p));
+    }, [p, u]);
+    const a = /* @__PURE__ */ e.jsx(
+      $e,
+      {
+        rapidlyChangingMotionState: t,
+        dhParameters: r,
+        ...f
+      }
+    );
+    return /* @__PURE__ */ e.jsxs(
+      pe,
+      {
+        fallback: a,
+        onError: (l) => {
+          console.warn(l);
+        },
+        children: [
+          /* @__PURE__ */ e.jsx(ie, { fallback: a, children: /* @__PURE__ */ e.jsx("group", { ref: o, children: /* @__PURE__ */ e.jsx(
+            me,
+            {
+              rapidlyChangingMotionState: t,
+              dhParameters: r,
+              children: /* @__PURE__ */ e.jsx(
+                ye,
+                {
+                  modelURL: (() => {
+                    const l = c(n, h);
+                    if (!l) {
+                      const x = new Blob([], { type: "model/gltf-binary" }), m = new File([x], `${n}.glb`, { type: "model/gltf-binary" });
+                      return Promise.resolve(URL.createObjectURL(m));
+                    }
+                    return l;
+                  })(),
+                  postModelRender: d,
+                  flangeRef: s,
+                  ...f
+                }
+              )
+            }
+          ) }) }),
+          /* @__PURE__ */ e.jsx(xe, {})
+        ]
+      }
+    );
+  }
+);
+function Ye({
+  connectedMotionGroup: t,
+  getModel: n = E,
+  flangeRef: r,
+  transparentColor: c,
+  postModelRender: s,
+  ...d
+}) {
+  return t.dhParameters ? /* @__PURE__ */ e.jsx(
+    we,
+    {
+      rapidlyChangingMotionState: t.rapidlyChangingMotionState,
+      modelFromController: t.modelFromController || "",
+      dhParameters: t.dhParameters,
+      getModel: n,
+      flangeRef: r,
+      transparentColor: c,
+      postModelRender: s,
+      ...d
+    }
+  ) : null;
+}
+const ut = C(
+  Ie(
+    ({
+      robotName: t,
+      programState: n,
+      safetyState: r,
+      operationMode: c,
+      driveToHomeEnabled: s = !1,
+      onDriveToHomePress: d,
+      onDriveToHomeRelease: u,
+      connectedMotionGroup: h,
+      robotComponent: f = Ye,
+      customContentComponent: p,
+      className: i
+    }) => {
+      var q;
+      const o = Pe(), { t: a } = Ve(), [l, x] = A(!1), m = _(null), j = _(null), [y, R] = A(!1), [w, P] = A({ width: 400, height: 600 }), [$, _e] = A(0);
+      M(() => {
+        const D = () => {
+          if (j.current) {
+            const { offsetWidth: X, offsetHeight: K } = j.current;
+            R(X > K), P({ width: X, height: K });
+          }
+        };
+        D();
+        const Y = new ResizeObserver(D);
+        return j.current && Y.observe(j.current), () => {
+          Y.disconnect();
+        };
+      }, []);
+      const H = k(() => {
+        _e((D) => D + 1);
+      }, []), F = k(() => {
+        !s || !d || (x(!0), d());
+      }, [s, d]), I = k(() => {
+        !s || !u || (x(!1), u());
+      }, [s, u]), N = k(() => {
+        l && u && (x(!1), u());
+      }, [l, u]), S = y ? w.width < 350 : w.height < 200, V = y ? w.height < 310 : w.height < 450;
+      return /* @__PURE__ */ e.jsx(
+        Fe,
+        {
+          ref: j,
+          className: i,
+          sx: {
+            width: "100%",
+            height: "100%",
+            display: "flex",
+            flexDirection: y ? "row" : "column",
+            position: "relative",
+            overflow: "hidden",
+            minWidth: { xs: 180, sm: 220, md: 250 },
+            minHeight: y ? { xs: 200, sm: 240, md: 260 } : { xs: 150, sm: 180, md: 220 },
+            // Allow progressive hiding in portrait mode
+            border: `1px solid ${o.palette.divider}`,
+            borderRadius: "18px",
+            boxShadow: "none",
+            backgroundColor: ((q = o.palette.backgroundPaperElevation) == null ? void 0 : q[8]) || "#2A2A3F",
+            backgroundImage: "none"
+            // Override any gradient from elevation
+          },
+          children: y ? /* @__PURE__ */ e.jsxs(e.Fragment, { children: [
+            /* @__PURE__ */ e.jsx(
+              v,
+              {
+                sx: {
+                  flex: "0 0 50%",
+                  position: "relative",
+                  height: "100%",
+                  minHeight: "100%",
+                  maxHeight: "100%",
+                  borderRadius: 1,
+                  m: { xs: 1.5, sm: 2, md: 3 },
+                  mr: { xs: 0.75, sm: 1, md: 1.5 },
+                  overflow: "hidden",
+                  // Prevent content from affecting container size
+                  display: S ? "none" : "block"
+                },
+                children: !S && /* @__PURE__ */ e.jsxs(
+                  Q,
+                  {
+                    orthographic: !0,
+                    camera: {
+                      position: [3, 2, 3],
+                      zoom: 1
+                    },
+                    shadows: !0,
+                    frameloop: "demand",
+                    style: {
+                      borderRadius: o.shape.borderRadius,
+                      width: "100%",
+                      height: "100%",
+                      background: "transparent",
+                      position: "absolute",
+                      top: 0,
+                      left: 0
+                    },
+                    dpr: [1, 2],
+                    gl: { alpha: !0, antialias: !0 },
+                    children: [
+                      /* @__PURE__ */ e.jsx(ne, {}),
+                      /* @__PURE__ */ e.jsx(Z, { fit: !0, observe: !0, margin: 1, maxDuration: 1, children: /* @__PURE__ */ e.jsx(
+                        f,
+                        {
+                          connectedMotionGroup: h,
+                          postModelRender: H
+                        }
+                      ) })
+                    ]
+                  }
+                )
+              }
+            ),
+            /* @__PURE__ */ e.jsxs(
+              v,
+              {
+                sx: {
+                  flex: "1",
+                  display: "flex",
+                  flexDirection: "column",
+                  justifyContent: "flex-start",
+                  width: S ? "100%" : "50%"
+                },
+                children: [
+                  /* @__PURE__ */ e.jsxs(
+                    v,
+                    {
+                      sx: {
+                        p: { xs: 1.5, sm: 2, md: 3 },
+                        pb: { xs: 1, sm: 1.5, md: 2 },
+                        textAlign: "left"
+                      },
+                      children: [
+                        /* @__PURE__ */ e.jsx(z, { variant: "h6", component: "h2", sx: { mb: 1 }, children: t }),
+                        /* @__PURE__ */ e.jsx(
+                          re,
+                          {
+                            programState: n,
+                            safetyState: r,
+                            operationMode: c
+                          }
+                        )
+                      ]
+                    }
+                  ),
+                  /* @__PURE__ */ e.jsxs(
+                    v,
+                    {
+                      sx: {
+                        p: { xs: 1.5, sm: 2, md: 3 },
+                        pt: 0,
+                        flex: "1",
+                        display: "flex",
+                        flexDirection: "column",
+                        justifyContent: "space-between"
+                      },
+                      children: [
+                        !V && p && /* @__PURE__ */ e.jsxs(v, { children: [
+                          /* @__PURE__ */ e.jsx(p, {}),
+                          /* @__PURE__ */ e.jsx(
+                            ee,
+                            {
+                              sx: {
+                                mt: 1,
+                                mb: 0,
+                                borderColor: o.palette.divider,
+                                opacity: 0.5
+                              }
+                            }
+                          )
+                        ] }),
+                        /* @__PURE__ */ e.jsx(
+                          v,
+                          {
+                            sx: {
+                              mt: !V && p ? "auto" : 0
+                            },
+                            children: /* @__PURE__ */ e.jsx(
+                              v,
+                              {
+                                sx: {
+                                  display: "flex",
+                                  justifyContent: "flex-start",
+                                  mt: { xs: 1, sm: 1.5, md: 2 },
+                                  mb: { xs: 0.5, sm: 0.75, md: 1 }
+                                },
+                                children: /* @__PURE__ */ e.jsx(
+                                  te,
+                                  {
+                                    ref: m,
+                                    variant: "contained",
+                                    color: "secondary",
+                                    size: "small",
+                                    disabled: !s,
+                                    onMouseDown: F,
+                                    onMouseUp: I,
+                                    onMouseLeave: N,
+                                    onTouchStart: F,
+                                    onTouchEnd: I,
+                                    sx: {
+                                      textTransform: "none",
+                                      px: 1.5,
+                                      py: 0.5
+                                    },
+                                    children: a("RobotCard.DriveToHome.bt")
+                                  }
+                                )
+                              }
+                            )
+                          }
+                        )
+                      ]
+                    }
+                  )
+                ]
+              }
+            )
+          ] }) : /* @__PURE__ */ e.jsx(e.Fragment, { children: /* @__PURE__ */ e.jsxs(
+            v,
+            {
+              sx: {
+                p: 3,
+                height: "100%",
+                display: "flex",
+                flexDirection: "column"
+              },
+              children: [
+                /* @__PURE__ */ e.jsxs(v, { children: [
+                  /* @__PURE__ */ e.jsx(z, { variant: "h6", component: "h2", sx: { mb: 1 }, children: t }),
+                  /* @__PURE__ */ e.jsx(
+                    re,
+                    {
+                      programState: n,
+                      safetyState: r,
+                      operationMode: c
+                    }
+                  )
+                ] }),
+                /* @__PURE__ */ e.jsx(
+                  v,
+                  {
+                    sx: {
+                      flex: S ? 0 : 1,
+                      position: "relative",
+                      minHeight: S ? 0 : { xs: 120, sm: 150, md: 200 },
+                      height: S ? 0 : "auto",
+                      borderRadius: 1,
+                      overflow: "hidden",
+                      display: S ? "none" : "block"
+                    },
+                    children: !S && /* @__PURE__ */ e.jsxs(
+                      Q,
+                      {
+                        orthographic: !0,
+                        camera: {
+                          position: [3, 2, 3],
+                          zoom: 1
+                        },
+                        shadows: !0,
+                        frameloop: "demand",
+                        style: {
+                          borderRadius: o.shape.borderRadius,
+                          width: "100%",
+                          height: "100%",
+                          background: "transparent",
+                          position: "absolute"
+                        },
+                        dpr: [1, 2],
+                        gl: { alpha: !0, antialias: !0 },
+                        children: [
+                          /* @__PURE__ */ e.jsx(ne, {}),
+                          /* @__PURE__ */ e.jsx(Z, { fit: !0, clip: !0, observe: !0, margin: 1, maxDuration: 1, children: /* @__PURE__ */ e.jsx(
+                            f,
+                            {
+                              connectedMotionGroup: h,
+                              postModelRender: H
+                            }
+                          ) })
+                        ]
+                      }
+                    )
+                  }
+                ),
+                /* @__PURE__ */ e.jsxs(v, { children: [
+                  !V && p && /* @__PURE__ */ e.jsxs(e.Fragment, { children: [
+                    /* @__PURE__ */ e.jsx(p, {}),
+                    /* @__PURE__ */ e.jsx(
+                      ee,
+                      {
+                        sx: {
+                          mt: 1,
+                          mb: 0,
+                          borderColor: o.palette.divider,
+                          opacity: 0.5
+                        }
+                      }
+                    )
+                  ] }),
+                  /* @__PURE__ */ e.jsx(
+                    v,
+                    {
+                      sx: {
+                        display: "flex",
+                        justifyContent: "flex-start",
+                        mt: !V && p ? { xs: 1, sm: 2, md: 5 } : { xs: 0.5, sm: 1, md: 2 },
+                        mb: { xs: 0.5, sm: 0.75, md: 1 }
+                      },
+                      children: /* @__PURE__ */ e.jsx(
+                        te,
+                        {
+                          ref: m,
+                          variant: "contained",
+                          color: "secondary",
+                          size: "small",
+                          disabled: !s,
+                          onMouseDown: F,
+                          onMouseUp: I,
+                          onMouseLeave: N,
+                          onTouchStart: F,
+                          onTouchEnd: I,
+                          sx: {
+                            textTransform: "none",
+                            px: 1.5,
+                            py: 0.5
+                          },
+                          children: a("RobotCard.DriveToHome.bt")
+                        }
+                      )
+                    }
+                  )
+                ] })
+              ]
+            }
+          ) })
+        }
+      );
+    }
+  )
+), pt = Array(6).fill(2 * Math.PI);
+function be({
+  rapidlyChangingMotionState: t,
+  dhParameters: n,
+  onTranslationChanged: r,
+  children: c
+}) {
+  const s = _([]), d = _([]), u = _(null), { invalidate: h } = ae();
+  M(() => {
+    const o = t.joint_position.filter(
+      (a) => a !== void 0
+    );
+    return u.current = new le(o, {
+      tension: 120,
+      // Controls spring stiffness - higher values create faster, more responsive motion
+      friction: 20,
+      // Controls damping - higher values reduce oscillation and create smoother settling
+      threshold: 1e-3
+    }), () => {
+      var a;
+      (a = u.current) == null || a.destroy();
+    };
+  }, []), ce((o, a) => {
+    if (u.current) {
+      const l = u.current.update(a);
+      p(), l || h();
+    }
+  });
+  function f(o) {
+    o && (d.current = de(o), p(), h());
+  }
+  function p() {
+    var a;
+    const o = ((a = u.current) == null ? void 0 : a.getCurrentValues()) || [];
+    if (r)
+      r(d.current, o);
+    else
+      for (const [l, x] of d.current.entries()) {
+        const j = n[l].reverse_rotation_direction ? -1 : 1;
+        x.position.y = j * (o[l] || 0) / 1e3;
+      }
+  }
+  const i = k(() => {
+    const o = t.joint_position.filter(
+      (a) => a !== void 0
+    );
+    requestAnimationFrame(() => {
+      var a;
+      s.current = o, (a = u.current) == null || a.setTarget(o);
+    });
+  }, [t]);
+  return M(() => {
+    i();
+  }, [t, i]), ue(() => {
+    i();
+  }), /* @__PURE__ */ e.jsx("group", { ref: f, children: c });
+}
+function Re({
+  rapidlyChangingMotionState: t,
+  dhParameters: n,
+  ...r
+}) {
+  const c = new b(), s = _(null), d = _(null);
+  function u(p) {
+    const i = new b();
+    for (let x = 0; x < n.length; x++) {
+      const m = n[x], j = p[x] ?? 0, y = new b().makeRotationY(m.theta).multiply(
+        new b().makeTranslation(
+          m.a / 1e3,
+          (m.d + j * (m.reverse_rotation_direction ? -1 : 1)) / 1e3,
+          0
+        )
+      ).multiply(new b().makeRotationX(m.alpha));
+      i.multiply(y);
+    }
+    const o = new G(), a = new B(), l = new G();
+    return i.decompose(o, a, l), o;
+  }
+  const h = u(t.joint_position);
+  function f(p, i) {
+    c.identity();
+    let o = new G();
+    for (let m = 0; m < n.length; m++) {
+      const j = i[m] ?? 0, y = n[m], R = new b().makeRotationY(y.theta).multiply(
+        new b().makeTranslation(
+          y.a / 1e3,
+          (y.d + j * (y.reverse_rotation_direction ? -1 : 1)) / 1e3,
+          0
+        )
+      ).multiply(new b().makeRotationX(y.alpha));
+      c.multiply(R);
+    }
+    const a = new G(), l = new B(), x = new G();
+    if (c.decompose(a, l, x), o = a, s.current && s.current.position.set(o.x, o.y, o.z), d.current) {
+      const m = d.current.geometry;
+      m && m.setPositions && m.setPositions([0, 0, 0, o.x, o.y, o.z]);
+    }
+  }
+  return /* @__PURE__ */ e.jsx(e.Fragment, { children: /* @__PURE__ */ e.jsx(
+    be,
+    {
+      rapidlyChangingMotionState: t,
+      dhParameters: n,
+      onTranslationChanged: f,
+      children: /* @__PURE__ */ e.jsxs("group", { ...r, name: "Scene", children: [
+        /* @__PURE__ */ e.jsxs("mesh", { name: "Base", position: [0, 0, 0], children: [
+          /* @__PURE__ */ e.jsx("sphereGeometry", { args: [0.02, 32, 32] }),
+          /* @__PURE__ */ e.jsx("meshStandardMaterial", { color: "green", depthTest: !0 })
+        ] }),
+        /* @__PURE__ */ e.jsx(
+          W,
+          {
+            ref: d,
+            points: [new G(0, 0, 0), h],
+            color: "White",
+            lineWidth: 5
+          }
+        ),
+        /* @__PURE__ */ e.jsxs("mesh", { ref: s, name: "TCP", position: h, children: [
+          /* @__PURE__ */ e.jsx("sphereGeometry", { args: [0.025, 32, 32] }),
+          /* @__PURE__ */ e.jsx("meshStandardMaterial", { color: "red", depthTest: !0 })
+        ] })
+      ] })
+    }
+  ) });
+}
+const ve = C(
+  ({
+    rapidlyChangingMotionState: t,
+    modelFromController: n,
+    dhParameters: r,
+    getModel: c = E,
+    flangeRef: s,
+    postModelRender: d,
+    transparentColor: u,
+    instanceUrl: h,
+    ...f
+  }) => {
+    const [p, i] = A(null), o = k((l) => {
+      i(l);
+    }, []);
+    M(() => {
+      p && (u ? ge(p, u) : je(p));
+    }, [p, u]);
+    const a = /* @__PURE__ */ e.jsx(
+      Re,
+      {
+        rapidlyChangingMotionState: t,
+        dhParameters: r,
+        ...f
+      }
+    );
+    return /* @__PURE__ */ e.jsxs(
+      pe,
+      {
+        fallback: a,
+        onError: (l) => {
+          console.warn(l);
+        },
+        children: [
+          /* @__PURE__ */ e.jsx(ie, { fallback: a, children: /* @__PURE__ */ e.jsx("group", { ref: o, children: /* @__PURE__ */ e.jsx(
+            be,
+            {
+              rapidlyChangingMotionState: t,
+              dhParameters: r,
+              children: /* @__PURE__ */ e.jsx(
+                ye,
+                {
+                  modelURL: (() => {
+                    const l = c(n, h);
+                    if (!l) {
+                      const x = new Blob([], { type: "model/gltf-binary" }), m = new File([x], `${n}.glb`, { type: "model/gltf-binary" });
+                      return Promise.resolve(URL.createObjectURL(m));
+                    }
+                    return l;
+                  })(),
+                  postModelRender: d,
+                  flangeRef: s,
+                  ...f
+                }
+              )
+            }
+          ) }) }),
+          /* @__PURE__ */ e.jsx(xe, {})
+        ]
+      }
+    );
+  }
+);
+function dt({
+  connectedMotionGroup: t,
+  getModel: n = E,
+  flangeRef: r,
+  transparentColor: c,
+  postModelRender: s,
+  ...d
+}) {
+  if (!t.dhParameters)
+    return null;
+  const u = t.modelFromController || "";
+  return u && n(u) ? /* @__PURE__ */ e.jsx(
+    ve,
+    {
+      rapidlyChangingMotionState: t.rapidlyChangingMotionState,
+      modelFromController: u,
+      dhParameters: t.dhParameters,
+      getModel: n,
+      flangeRef: r,
+      transparentColor: c,
+      postModelRender: s,
+      ...d
+    }
+  ) : /* @__PURE__ */ e.jsx(
+    Re,
+    {
+      rapidlyChangingMotionState: t.rapidlyChangingMotionState,
+      dhParameters: t.dhParameters,
+      ...d
+    }
+  );
+}
+const se = {
+  [T.Abb]: [0, 0, 0, 0, Math.PI / 2, 0, 0],
+  [T.Fanuc]: [0, 0, 0, 0, -Math.PI / 2, 0, 0],
+  [T.Yaskawa]: [0, 0, 0, 0, -Math.PI / 2, 0, 0],
+  [T.Kuka]: [
+    0,
+    -Math.PI / 2,
+    Math.PI / 2,
+    0,
+    Math.PI / 2,
+    0,
+    0
+  ],
+  [T.Universalrobots]: [
+    0,
+    -Math.PI / 2,
+    -Math.PI / 2,
+    -Math.PI / 2,
+    Math.PI / 2,
+    -Math.PI / 2,
+    0
+  ]
+};
+function Xe(t) {
+  const [n] = t.split("_");
+  switch (n) {
+    case "ABB":
+      return T.Abb;
+    case "FANUC":
+      return T.Fanuc;
+    case "YASKAWA":
+      return T.Yaskawa;
+    case "KUKA":
+      return T.Kuka;
+    case "UniversalRobots":
+      return T.Universalrobots;
+    default:
+      return null;
+  }
+}
+function ft(t, n) {
+  const r = Xe(t);
+  return r && r in se ? se[r] : n || null;
+}
+const ht = C((t) => {
+  const {
+    inverseSolver: n,
+    dhParameters: r,
+    ...c
+  } = t, [s, d] = A(O.RevoluteJoint);
+  M(() => {
+    r.length && d(r[0].type ?? O.RevoluteJoint);
+  }, [r]);
+  const u = U(() => n === null && s === O.RevoluteJoint, [n, s]), h = U(() => n === null && s === O.PrismaticJoint, [n, s]);
+  return U(() => !!n, [n]) || u ? /* @__PURE__ */ e.jsx(we, { dhParameters: r, ...c }) : h ? /* @__PURE__ */ e.jsx(ve, { dhParameters: r, ...c }) : /* @__PURE__ */ e.jsx(e.Fragment, {});
+});
+export {
+  at as C,
+  dt as L,
+  se as M,
+  ne as P,
+  Ye as R,
+  ct as S,
+  lt as T,
+  ht as a,
+  ut as b,
+  ve as c,
+  we as d,
+  pt as e,
+  E as f,
+  Xe as g,
+  ft as h
+};
+//# sourceMappingURL=MotionGroupVisualizer-D8_sA8PA.js.map