@vitessce/all 3.9.6 → 4.0.0-test.0

package/dist/GeometryAndMeshXR-Bewsp5O-.js

@@ -0,0 +1,247 @@
+import { jsxs, jsx } from "react/jsx-runtime";
+import { useRef, useEffect, useState } from "react";
+import { useThree, useFrame } from "@react-three/fiber";
+import { Bvh } from "@react-three/drei";
+import { useXR, useXRInputSourceState } from "@react-three/xr";
+import { Matrix4, Vector3, Box3, FrontSide } from "three";
+import { i as isValidGeometrySize, M as MeasureLine, s as stringifyLineData } from "./index-DxpZAn2M.js";
+function getHandJoint(hand, jointName) {
+  return hand.get(jointName);
+}
+function getJointPosition(hand, jointName, frame, refSpace) {
+  if (!hand?.inputSource?.hand)
+    return null;
+  const jointSpace = getHandJoint(hand.inputSource.hand, jointName);
+  if (!jointSpace)
+    return null;
+  const pose = frame.getJointPose?.(jointSpace, refSpace);
+  if (!pose)
+    return null;
+  return new Vector3(pose.transform.position.x, pose.transform.position.y, pose.transform.position.z);
+}
+function isPinching(hand, frame, refSpace, threshold = 0.02) {
+  const thumbPos = getJointPosition(hand, "thumb-tip", frame, refSpace);
+  const indexPos = getJointPosition(hand, "index-finger-tip", frame, refSpace);
+  if (!thumbPos || !indexPos)
+    return false;
+  return thumbPos.distanceTo(indexPos) < threshold;
+}
+function GeometryAndMeshXR(props) {
+  const { segmentationGroup, segmentationSettings, segmentationSceneScale, renderingSettings, materialRef, highlightEntity, setObsHighlight } = props;
+  const model = useRef(null);
+  const distanceRef = useRef(null);
+  const rayGrabGroup = useRef(null);
+  const grabControllerRef = useRef(null);
+  useRef(new Matrix4());
+  const initialScale = useRef(null);
+  const secondPointerId = useRef(null);
+  const initialDistance = useRef(0);
+  const lastPointerPositions = useRef(/* @__PURE__ */ new Map());
+  const session = useXR((state) => state.session);
+  const isPresenting = session != null;
+  useEffect(() => {
+    if (materialRef?.current?.material?.uniforms?.u_physical_Pixel) {
+      materialRef.current.material.uniforms.u_physical_Pixel.value = isPresenting ? 0.2 : 2.5;
+    }
+  }, [isPresenting, materialRef]);
+  const { scene, gl } = useThree();
+  const rightHand = useXRInputSourceState("hand", "right");
+  const leftHand = useXRInputSourceState("hand", "left");
+  const [measureState, setMeasureState] = useState(false);
+  const [highlighted, setHighlighted] = useState(false);
+  const [showLine, setShowLine] = useState(false);
+  const [currentLine, setCurrentLine] = useState({
+    startPoint: new Vector3(),
+    midPoint: new Vector3(),
+    endPoint: new Vector3(),
+    setStartPoint: false,
+    setEndPoint: false
+  });
+  const [lines, setLines] = useState([]);
+  const [debounce, setDebounce] = useState(0);
+  const measureStateRef = useRef(measureState);
+  measureStateRef.current = measureState;
+  const highlightedRef = useRef(highlighted);
+  highlightedRef.current = highlighted;
+  const currentLineRef = useRef(currentLine);
+  currentLineRef.current = currentLine;
+  const linesRef = useRef(lines);
+  linesRef.current = lines;
+  const debounceRef = useRef(debounce);
+  debounceRef.current = debounce;
+  useFrame((_state, _delta, frame) => {
+    if (!isPresenting || !frame)
+      return;
+    const refSpace = gl.xr.getReferenceSpace();
+    if (!refSpace)
+      return;
+    const rightTipBbox = scene.getObjectByName("rightTipBbox");
+    const leftTipBbox = scene.getObjectByName("leftTipBbox");
+    if (!rightTipBbox || !leftTipBbox)
+      return;
+    const leftTipBB = new Box3().setFromObject(leftTipBbox);
+    const rightTipBB = new Box3().setFromObject(rightTipBbox);
+    let intersected = false;
+    setDebounce((prev) => prev - 1);
+    if (leftTipBB.intersectsBox(rightTipBB) && leftTipBB.max.x !== -rightTipBB.min.x) {
+      setMeasureState(true);
+      setShowLine(true);
+      setCurrentLine({
+        startPoint: new Vector3(),
+        midPoint: new Vector3(),
+        endPoint: new Vector3(),
+        setStartPoint: false,
+        setEndPoint: false
+      });
+    }
+    const curMeasureState = measureStateRef.current;
+    const curLine = currentLineRef.current;
+    if (curMeasureState) {
+      let leftFingerPosition = getJointPosition(leftHand, "index-finger-tip", frame, refSpace);
+      let rightFingerPosition = getJointPosition(rightHand, "index-finger-tip", frame, refSpace);
+      if (!leftFingerPosition || !rightFingerPosition)
+        return;
+      if (rayGrabGroup.current) {
+        leftFingerPosition = leftFingerPosition.applyMatrix4(rayGrabGroup.current.matrixWorld.clone().invert());
+        rightFingerPosition = rightFingerPosition.applyMatrix4(rayGrabGroup.current.matrixWorld.clone().invert());
+      }
+      let currentStart = leftFingerPosition.clone();
+      let currentEnd = rightFingerPosition.clone();
+      if (curLine.setStartPoint) {
+        currentStart = curLine.startPoint;
+      }
+      if (curLine.setEndPoint) {
+        currentEnd = curLine.endPoint;
+      }
+      setCurrentLine({
+        startPoint: currentStart,
+        midPoint: new Vector3().addVectors(currentStart, currentEnd).multiplyScalar(0.5),
+        endPoint: currentEnd,
+        setStartPoint: curLine.setStartPoint,
+        setEndPoint: curLine.setEndPoint
+      });
+      if (isPinching(rightHand, frame, refSpace)) {
+        setCurrentLine((prev) => ({
+          ...prev,
+          setEndPoint: true
+        }));
+      }
+      if (isPinching(leftHand, frame, refSpace)) {
+        setCurrentLine((prev) => ({
+          ...prev,
+          setStartPoint: true
+        }));
+      }
+      if (curLine.setStartPoint && curLine.setEndPoint) {
+        setLines((prev) => [...prev, curLine]);
+        setShowLine(false);
+        setMeasureState(false);
+        setDebounce(8);
+      }
+    } else if (debounceRef.current <= 0 && model.current && isPresenting) {
+      const modelScene = model.current;
+      modelScene.children[0].children.forEach((_childVal, childID) => {
+        const child = modelScene.children[0].children[childID];
+        const currentObjectBB = new Box3().setFromObject(child);
+        const intersectsLeftTip = leftTipBB.intersectsBox(currentObjectBB);
+        const intersectsRightTip = rightTipBB.intersectsBox(currentObjectBB);
+        if (intersectsLeftTip || intersectsRightTip) {
+          intersected = true;
+          setObsHighlight(child.name);
+          setHighlighted(true);
+          if (intersectsLeftTip && isPinching(leftHand, frame, refSpace)) {
+            setDebounce(10);
+            intersected = false;
+          }
+          if (intersectsRightTip && isPinching(rightHand, frame, refSpace)) {
+            setDebounce(10);
+            intersected = false;
+          }
+        }
+      });
+      if (!intersected && highlightedRef.current) {
+        setObsHighlight(null);
+        setHighlighted(false);
+      }
+    }
+  });
+  const handlePointerDown = (e) => {
+    if (!isPresenting)
+      return;
+    e.stopPropagation();
+    e.target.setPointerCapture(e.pointerId);
+    if (grabControllerRef.current === null) {
+      grabControllerRef.current = e.pointerId;
+      lastPointerPositions.current.set(e.pointerId, e.point.clone());
+      if (rayGrabGroup.current) {
+        initialScale.current = rayGrabGroup.current.scale.clone();
+      }
+    } else if (secondPointerId.current === null && e.pointerId !== grabControllerRef.current) {
+      secondPointerId.current = e.pointerId;
+      lastPointerPositions.current.set(e.pointerId, e.point.clone());
+      const p1 = lastPointerPositions.current.get(grabControllerRef.current);
+      const p2 = e.point;
+      if (p1) {
+        initialDistance.current = p1.distanceTo(p2);
+      }
+      if (rayGrabGroup.current) {
+        initialScale.current = rayGrabGroup.current.scale.clone();
+      }
+    }
+  };
+  const handlePointerUp = (e) => {
+    e.target.releasePointerCapture(e.pointerId);
+    lastPointerPositions.current.delete(e.pointerId);
+    if (grabControllerRef.current === e.pointerId) {
+      grabControllerRef.current = null;
+      initialScale.current = null;
+    }
+    if (secondPointerId.current === e.pointerId) {
+      secondPointerId.current = null;
+      initialDistance.current = 0;
+    }
+  };
+  const handlePointerMove = (e) => {
+    if (!rayGrabGroup.current || !e.point)
+      return;
+    const isFirstPointer = grabControllerRef.current === e.pointerId;
+    const isSecondPointer = secondPointerId.current === e.pointerId;
+    if (!isFirstPointer && !isSecondPointer)
+      return;
+    const prevPos = lastPointerPositions.current.get(e.pointerId);
+    lastPointerPositions.current.set(e.pointerId, e.point.clone());
+    if (secondPointerId.current !== null && initialDistance.current > 0 && initialScale.current) {
+      const p1 = lastPointerPositions.current.get(grabControllerRef.current);
+      const p2 = lastPointerPositions.current.get(secondPointerId.current);
+      if (p1 && p2) {
+        const currentDistance = p1.distanceTo(p2);
+        const scaleFactor = currentDistance / initialDistance.current;
+        rayGrabGroup.current.scale.copy(initialScale.current).multiplyScalar(scaleFactor);
+      }
+    } else if (isFirstPointer && prevPos) {
+      const delta = e.point.clone().sub(prevPos);
+      rayGrabGroup.current.position.add(delta);
+    }
+  };
+  if (isPresenting) {
+    return jsxs("group", { children: [jsxs("group", { ref: rayGrabGroup, onPointerDown: handlePointerDown, onPointerUp: handlePointerUp, onPointerMove: handlePointerMove, children: [segmentationGroup?.visible ? jsxs("group", { children: [jsx("hemisphereLight", { color: 8421504, groundColor: 6316128 }), jsx("directionalLight", { color: 16777215, position: [0, -800, 0] }), jsx("primitive", { ref: model, object: segmentationGroup, position: [-0.18, 1.13, -1], scale: [
+      2e-3 * segmentationSceneScale[0],
+      2e-3 * segmentationSceneScale[1],
+      2e-3 * segmentationSceneScale[2]
+    ] })] }) : null, renderingSettings.uniforms && renderingSettings.shader && renderingSettings.meshScale ? jsx("group", { children: jsxs("mesh", { name: "cube", position: [-0.18, 1.13, -1], rotation: [0, 0, 0], scale: [
+      2e-3 * renderingSettings.meshScale[0],
+      2e-3 * renderingSettings.meshScale[1],
+      2e-3 * renderingSettings.meshScale[2]
+    ], ref: materialRef, children: [isValidGeometrySize(renderingSettings.geometrySize) && jsx("boxGeometry", { args: renderingSettings.geometrySize }), jsx("shaderMaterial", { customProgramCacheKey: () => "1", side: FrontSide, uniforms: renderingSettings.uniforms, needsUpdate: true, transparent: true, vertexShader: renderingSettings.shader.vertexShader, fragmentShader: renderingSettings.shader.fragmentShader })] }) }) : null] }), jsx("group", { name: "currentLine", ref: distanceRef, children: showLine ? jsx(MeasureLine, { currentLine, scale: 1 / 2e-3 * 0.4 }) : null }), jsx("group", { name: "lines", children: lines.map((object) => jsx(MeasureLine, { currentLine: object, scale: 1 / 2e-3 * 0.4 }, stringifyLineData(object))) })] });
+  }
+  return jsxs("group", { children: [jsxs("group", { children: [segmentationGroup?.visible ? jsxs("group", { children: [jsx("hemisphereLight", { color: 8421504, groundColor: 6316128 }), jsx("directionalLight", { color: 16777215, position: [0, -800, 0] }), jsx("directionalLight", { color: 16777215, position: [0, 800, 0] }), jsx(Bvh, { firstHitOnly: true, children: jsx("primitive", { ref: model, object: segmentationGroup, position: [0, 0, 0], onClick: (e) => {
+    if (e.object.parent?.userData.name === "finalPass") {
+      highlightEntity(e.object.name, e.object.userData.layerScope, e.object.userData.channelScope);
+    }
+  }, onPointerOver: (e) => {
+    setObsHighlight(e.object.name);
+  }, onPointerOut: () => setObsHighlight(null) }) })] }) : null, renderingSettings.uniforms && renderingSettings.shader && renderingSettings.meshScale && renderingSettings.geometrySize ? jsx("group", { children: jsxs("mesh", { scale: renderingSettings.meshScale, ref: materialRef, children: [jsx("boxGeometry", { args: renderingSettings.geometrySize }), jsx("shaderMaterial", { customProgramCacheKey: () => "1", side: FrontSide, uniforms: renderingSettings.uniforms, needsUpdate: true, transparent: true, vertexShader: renderingSettings.shader.vertexShader, fragmentShader: renderingSettings.shader.fragmentShader })] }) }) : null] }), jsx("group", { name: "lines", children: lines.map((object) => jsx(MeasureLine, { currentLine: object, scale: 1 }, stringifyLineData(object))) })] });
+}
+export {
+  GeometryAndMeshXR as default
+};

package/dist/{ReactNeuroglancer-Cl5UUROE.js → ReactNeuroglancer-CGctZU7S.js}

@@ -1,5 +1,6 @@
-import { aG as getDefaultExportFromCjs, b1 as requireAssign, b2 as require_export, b3 as require_core, b4 as require_fails, b5 as require_toObject, b6 as require_objectKeys, b7 as require_cof, b8 as require_wks, b9 as require_iterators, ba as requireWeb_dom_iterable, bb as requireEs6_string_iterator, bc as require_anObject, bd as require_hide, be as require_ctx, bf as require_toLength, bg as require_global, bh as require_objectDp, bi as require_descriptors, bj as require_isObject, bk as require_objectCreate, bl as require_iterDefine, bm as require_iterStep, bn as require_meta, bo as require_isArray, bp as require_iobject, bq as require_setToStringTag, br as require_aFunction, bs as requireIterator, bt as require_propertyDesc, a_ as commonjsGlobal, bu as requireEs6_symbol, bv as requireDefineProperty, bw as require_toIobject, bx as require_objectGopd, by as require_html, bz as require_domCreate, bA as require_library, bB as requireSymbol, bC as require_objectPie, bD as require_has, bE as require_redefine, bF as require_objectAssign, bG as diffCameraState, ao as jsxRuntimeExports } from "./index-B1IhEdcb.js";
+import { jsx, jsxs } from "react/jsx-runtime";
 import React__default from "react";
+import { a as getDefaultExportFromCjs, d as requireAssign, f as require_export, h as require_core, j as require_fails, k as require_toObject, m as require_objectKeys, n as require_cof, o as require_wks, p as require_iterators, q as requireWeb_dom_iterable, s as requireEs6_string_iterator, t as require_anObject, v as require_hide, w as require_ctx, x as require_toLength, y as require_global, z as require_objectDp, A as require_descriptors, D as require_isObject, E as require_objectCreate, F as require_iterDefine, G as require_iterStep, H as require_meta, I as require_isArray, J as require_iobject, K as require_setToStringTag, M as require_aFunction, N as requireIterator, O as require_propertyDesc, c as commonjsGlobal, P as requireEs6_symbol, Q as requireDefineProperty, R as require_toIobject, S as require_objectGopd, T as require_html, U as require_domCreate, V as require_library, W as requireSymbol, X as require_objectPie, Y as require_has, Z as require_redefine, _ as require_objectAssign, $ as diffCameraState } from "./index-5W6nu-ix.js";
 var assignExports = requireAssign();
 const _Object$assign = /* @__PURE__ */ getDefaultExportFromCjs(assignExports);
 var es6_object_keys = {};
@@ -65757,7 +65758,7 @@ class Neuroglancer extends React__default.Component {
   };
   render() {
     const { perspectiveZoom } = this.props;
-    return jsxRuntimeExports.jsx("div", { className: "neuroglancer-container", ref: this.ngContainer, children: jsxRuntimeExports.jsxs("p", { children: ["Neuroglancer here with zoom ", perspectiveZoom] }) });
+    return jsx("div", { className: "neuroglancer-container", ref: this.ngContainer, children: jsxs("p", { children: ["Neuroglancer here with zoom ", perspectiveZoom] }) });
   }
 }
 export {

package/dist/XREnterButton-vmEhdF4L.js

@@ -0,0 +1,52 @@
+import { jsx } from "react/jsx-runtime";
+import { useState, useEffect } from "react";
+import { x as xrStore } from "./xrStore-BymedRtx.js";
+function XREnterButton() {
+  const [supported, setSupported] = useState(false);
+  const [entered, setEntered] = useState(false);
+  useEffect(() => {
+    let cancelled = false;
+    if (navigator.xr) {
+      navigator.xr.isSessionSupported("immersive-ar").then((result) => {
+        if (!cancelled)
+          setSupported(result);
+      }).catch(() => {
+      });
+    }
+    return () => {
+      cancelled = true;
+    };
+  }, []);
+  useEffect(() => {
+    const unsubscribe = xrStore.subscribe((state) => {
+      setEntered(state.session != null);
+    });
+    return unsubscribe;
+  }, []);
+  if (!supported)
+    return null;
+  const handleClick = () => {
+    if (entered) {
+      const { session } = xrStore.getState();
+      if (session)
+        session.end();
+    } else {
+      xrStore.enterAR();
+    }
+  };
+  return jsx("button", { type: "button", onClick: handleClick, style: {
+    border: "1px solid white",
+    padding: "12px 24px",
+    borderRadius: "4px",
+    background: "rgba(0, 0, 0, 0.1)",
+    color: "white",
+    font: "normal 0.8125rem sans-serif",
+    outline: "none",
+    cursor: "pointer",
+    zIndex: 1,
+    position: "absolute"
+  }, children: entered ? "Exit AR" : "Enter AR" });
+}
+export {
+  XREnterButton as default
+};

package/dist/XRSceneComponents-DnZLSAJz.js

@@ -0,0 +1,62 @@
+import { jsxs, Fragment, jsx } from "react/jsx-runtime";
+import { useRef } from "react";
+import { useXRInputSourceState, useXR } from "@react-three/xr";
+import { useThree, useFrame } from "@react-three/fiber";
+function getHandJoint(hand, jointName) {
+  return hand.get(jointName);
+}
+function HandBbox() {
+  const rightHand = useXRInputSourceState("hand", "right");
+  const leftHand = useXRInputSourceState("hand", "left");
+  const rightTipRef = useRef(null);
+  const leftTipRef = useRef(null);
+  const { gl } = useThree();
+  useFrame((_state, _delta, frame) => {
+    if (!frame || !gl.xr.isPresenting)
+      return;
+    const refSpace = gl.xr.getReferenceSpace();
+    if (!refSpace)
+      return;
+    if (rightHand?.inputSource?.hand && rightTipRef.current) {
+      const jointSpace = getHandJoint(rightHand.inputSource.hand, "index-finger-tip");
+      if (jointSpace) {
+        const pose = frame.getJointPose?.(jointSpace, refSpace);
+        if (pose) {
+          rightTipRef.current.position.set(pose.transform.position.x, pose.transform.position.y, pose.transform.position.z);
+        }
+      }
+    }
+    if (leftHand?.inputSource?.hand && leftTipRef.current) {
+      const jointSpace = getHandJoint(leftHand.inputSource.hand, "index-finger-tip");
+      if (jointSpace) {
+        const pose = frame.getJointPose?.(jointSpace, refSpace);
+        if (pose) {
+          leftTipRef.current.position.set(pose.transform.position.x, pose.transform.position.y, pose.transform.position.z);
+        }
+      }
+    }
+  });
+  return jsxs(Fragment, { children: [jsxs("mesh", { name: "leftTipBbox", ref: leftTipRef, children: [jsx("boxGeometry", { args: [0.02, 0.02, 0.02] }), jsx("meshStandardMaterial", { color: "blue", transparent: true, opacity: 0 })] }), jsxs("mesh", { name: "rightTipBbox", ref: rightTipRef, children: [jsx("boxGeometry", { args: [0.02, 0.02, 0.02] }), jsx("meshStandardMaterial", { color: "orange", transparent: true, opacity: 0 })] })] });
+}
+function HandDecorate() {
+  const session = useXR((state) => state.session);
+  const { scene } = useThree();
+  useFrame(() => {
+    if (!session)
+      return;
+    scene.traverse((child) => {
+      if (child.isMesh && child.material && child.userData?.xpiHand) {
+        const mesh = child;
+        mesh.material.transparent = true;
+        mesh.material.opacity = 0.5;
+      }
+    });
+  });
+  return null;
+}
+function XRSceneComponents() {
+  return jsxs(Fragment, { children: [jsx(HandBbox, {}), jsx(HandDecorate, {})] });
+}
+export {
+  XRSceneComponents as default
+};

package/dist/XRWrapper-C94X82Mb.js

@@ -0,0 +1,9 @@
+import { jsx } from "react/jsx-runtime";
+import { XR } from "@react-three/xr";
+import { x as xrStore } from "./xrStore-BymedRtx.js";
+function XRWrapper({ children }) {
+  return jsx(XR, { store: xrStore, children });
+}
+export {
+  XRWrapper as default
+};

package/dist/{deflate-BXY2A2Ns.js → deflate-DACPPK4G.js}

@@ -1,5 +1,5 @@
 import { i as inflate_1 } from "./pako.esm-SxljTded.js";
-import { aX as BaseDecoder } from "./index-B1IhEdcb.js";
+import { B as BaseDecoder } from "./index-5W6nu-ix.js";
 class DeflateDecoder extends BaseDecoder {
   decodeBlock(buffer) {
     return inflate_1(new Uint8Array(buffer)).buffer;