dhb-xr 0.2.1__py3-none-any.whl

dhb_xr/__init__.py

@@ -0,0 +1,61 @@
+"""
+dhb_xr: DHB Extended Representations for SE(3) invariant trajectory encoding.
+"""
+
+__version__ = "0.1.0"
+
+from dhb_xr.encoder.dhb_dr import encode_dhb_dr
+from dhb_xr.decoder.dhb_dr import decode_dhb_dr
+from dhb_xr.core.types import EncodingMethod, DHBMethod
+
+# Preprocessing
+from dhb_xr.preprocessing import (
+    TrajectoryPreprocessor,
+    ProcessedTrajectory,
+    TrajectoryDiagnostics,
+    analyze_trajectory,
+    detect_reversals,
+    detect_zero_motion,
+)
+
+# Visualization
+try:
+    from dhb_xr.visualization.plot import (
+        plot_se3_trajectory,
+        plot_se3_trajectories,
+        plot_invariants,
+    )
+    _VIS_AVAILABLE = True
+except ImportError:
+    _VIS_AVAILABLE = False
+    plot_se3_trajectory = None
+    plot_se3_trajectories = None
+    plot_invariants = None
+
+try:
+    from dhb_xr import _dhb_xr_cpp
+    cpp_version = _dhb_xr_cpp.cpp_version
+    _CPP_AVAILABLE = True
+except ImportError:
+    cpp_version = None
+    _CPP_AVAILABLE = False
+
+__all__ = [
+    "__version__",
+    "encode_dhb_dr",
+    "decode_dhb_dr",
+    "EncodingMethod",
+    "DHBMethod",
+    "cpp_version",
+    # Preprocessing
+    "TrajectoryPreprocessor",
+    "ProcessedTrajectory",
+    "TrajectoryDiagnostics",
+    "analyze_trajectory",
+    "detect_reversals",
+    "detect_zero_motion",
+    # Visualization
+    "plot_se3_trajectory",
+    "plot_se3_trajectories",
+    "plot_invariants",
+]

dhb_xr/cli.py

@@ -0,0 +1,206 @@
+"""CLI utilities for DHB-XR.
+
+Currently provides:
+- `dhb_xr-examples`: locate or copy example scripts for pip-installed users.
+"""
+
+import argparse
+import os
+import shlex
+import shutil
+import sys
+from pathlib import Path
+from typing import Optional
+
+
+def _find_examples_dir() -> Optional[Path]:
+    """Find the examples directory in the installed package."""
+    try:
+        import dhb_xr
+
+        # Get the package directory
+        dhb_xr_pkg_dir = Path(dhb_xr.__file__).parent
+
+        # Check multiple possible locations (in order of likelihood)
+        candidates = [
+            # Relative to package parent (for editable installs from source)
+            dhb_xr_pkg_dir.parent.parent / "examples",
+            # At site-packages root (if installed via package data)
+            dhb_xr_pkg_dir.parent / "examples",
+            # In the dhb_xr package itself
+            dhb_xr_pkg_dir / "examples",
+        ]
+
+        for candidate in candidates:
+            if candidate.exists() and candidate.is_dir():
+                # Verify it has example files
+                if any(candidate.glob("*.py")):
+                    return candidate
+    except Exception:
+        pass
+
+    # Fallback: check all sys.path entries
+    for site_packages in sys.path:
+        try:
+            site_path = Path(site_packages)
+            if not site_path.exists():
+                continue
+
+            # Check various locations
+            candidates = [
+                site_path / "examples",
+                site_path.parent / "examples",
+            ]
+
+            for candidate in candidates:
+                if candidate.exists() and candidate.is_dir():
+                    if any(candidate.glob("*.py")):
+                        return candidate
+        except Exception:
+            continue
+
+    return None
+
+
+def examples_cmd(argv: Optional[list[str]] = None) -> int:
+    """Entry point for `dhb_xr-examples`."""
+    parser = argparse.ArgumentParser(
+        prog="dhb_xr-examples",
+        description=(
+            "Locate or copy DHB-XR example scripts.\n\n"
+            "Examples are included in the pip package and can be run directly.\n"
+            "Use --copy to copy them to a local directory for editing."
+        ),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument(
+        "--copy",
+        nargs="?",
+        const="dhb_xr_examples",
+        metavar="DEST",
+        type=str,
+        help=(
+            "Copy examples to DEST. "
+            "If DEST is omitted, copies to ./dhb_xr_examples. "
+            "Example: `dhb_xr-examples --copy` or `dhb_xr-examples --copy ./examples`."
+        ),
+    )
+    parser.add_argument(
+        "--list",
+        action="store_true",
+        help="List available example scripts.",
+    )
+
+    args = parser.parse_args(argv)
+
+    examples_dir = _find_examples_dir()
+
+    if examples_dir is None:
+        print("ERROR: Could not find examples directory in installed package.", file=sys.stderr)
+        print("Examples may not be included in this installation.", file=sys.stderr)
+        print("Try: pip install --force-reinstall dhb_xr[examples]", file=sys.stderr)
+        return 1
+
+    if args.list:
+        print(f"Examples directory: {examples_dir}")
+        print("\nAvailable examples:")
+        for py_file in sorted(examples_dir.glob("*.py")):
+            if py_file.name != "__init__.py":
+                print(f"  - {py_file.name}")
+
+        integration_dir = examples_dir / "integration"
+        if integration_dir.exists() and integration_dir.is_dir():
+            integration_files = [f for f in integration_dir.glob("*.py") if f.name != "__init__.py"]
+            if integration_files:
+                print("  📂 integration/:")
+                for py_file in sorted(integration_files):
+                    print(f"      - {py_file.name}")
+
+        return 0
+
+    if args.copy:
+        dest = Path(args.copy).expanduser().resolve()
+    else:
+        dest = Path.cwd() / "dhb_xr_examples"
+
+    try:
+        # Ensure examples_dir is resolved to absolute path and verify it exists
+        try:
+            examples_dir_resolved = examples_dir.resolve()
+        except (OSError, RuntimeError):
+            examples_dir_resolved = examples_dir
+
+        if not examples_dir_resolved.exists():
+            if examples_dir.exists():
+                examples_dir_resolved = examples_dir
+            else:
+                print(f"ERROR: Examples directory does not exist: {examples_dir_resolved}", file=sys.stderr)
+                return 1
+
+        if not examples_dir_resolved.is_dir():
+            print(f"ERROR: Examples path exists but is not a directory: {examples_dir_resolved}", file=sys.stderr)
+            return 1
+
+        if dest.exists():
+            if not dest.is_dir():
+                print(f"ERROR: {dest} exists but is not a directory", file=sys.stderr)
+                return 1
+            response = input(f"Directory {dest} already exists. Overwrite? [y/N]: ")
+            if response.lower() != "y":
+                print("Cancelled.")
+                return 0
+            shutil.rmtree(dest)
+
+        # Copy examples
+        shutil.copytree(str(examples_dir_resolved), str(dest))
+
+        # Remove any compiled Python files
+        for pyc_file in dest.rglob("__pycache__"):
+            shutil.rmtree(pyc_file)
+        for pyc_file in dest.rglob("*.pyc"):
+            pyc_file.unlink()
+
+        print(f"✓ Copied examples to {dest}")
+        print(f"\nTo run an example:")
+        print(f"  cd {dest}")
+        print("  pip install dhb_xr  # Install core library"
+        print("  python basic_encoding.py  # Run an example"
+        # If the user is in a Pixi project, also show the pixi-friendly form.
+        if os.environ.get("PIXI_PROJECT_ROOT") or os.environ.get("PIXI_ENVIRONMENT_NAME"):
+            print("  # or")
+            print("  pixi run python basic_encoding.py")
+        return 0
+
+    except Exception as e:
+        print(f"ERROR: Failed to copy examples: {e}", file=sys.stderr)
+        return 1
+
+    # Default: just show location
+    print(f"Examples directory: {examples_dir}")
+    print("\nTo run an example:")
+    print(f"  {shlex.quote(sys.executable)} {examples_dir}/basic_encoding.py")
+    print("\nTo copy examples to a local directory:")
+    print("  dhb_xr-examples --copy")
+    return 0
+
+
+def main() -> None:
+    """Main CLI entry point."""
+    # Check if we're being called as examples command
+    if len(sys.argv) > 1 and sys.argv[1] == "examples":
+        sys.argv = sys.argv[1:]  # Remove 'examples' from argv
+        sys.argv[0] = "dhb_xr-examples"  # Update program name
+        raise SystemExit(examples_cmd())
+    else:
+        # Default behavior - show help
+        print("DHB-XR CLI utilities")
+        print()
+        print("Available commands:")
+        print("  dhb_xr-examples  Locate or copy example scripts")
+        print()
+        print("For help on a specific command, run:")
+        print("  dhb_xr-examples --help")
+
+
+if __name__ == "__main__":
+    main()

dhb_xr/core/__init__.py

@@ -0,0 +1,28 @@
+"""Core types and geometry utilities."""
+
+from dhb_xr.core.types import SE3Pose, Trajectory, InvariantSequence, DHBMethod
+from dhb_xr.core.geometry import (
+    quat_to_rot,
+    rot_to_quat,
+    rot_to_euler,
+    euler_to_rot,
+    rot_to_axis_angle,
+    axis_angle_to_rot,
+    axis_angle_to_quat,
+    quat_to_axis_angle,
+)
+
+__all__ = [
+    "SE3Pose",
+    "Trajectory",
+    "InvariantSequence",
+    "DHBMethod",
+    "quat_to_rot",
+    "rot_to_quat",
+    "rot_to_euler",
+    "euler_to_rot",
+    "rot_to_axis_angle",
+    "axis_angle_to_rot",
+    "axis_angle_to_quat",
+    "quat_to_axis_angle",
+]

dhb_xr/core/geometry.py

@@ -0,0 +1,167 @@
+"""
+SO(3) / SE(3) geometry utilities.
+Quaternion convention: wxyz (scalar-first).
+"""
+
+import numpy as np
+from scipy.spatial.transform import Rotation
+
+_EPS = 1e-10
+
+
+def _wxyz_to_xyzw(q: np.ndarray) -> np.ndarray:
+    """wxyz (scalar first) -> xyzw (scipy convention)."""
+    q = np.asarray(q).reshape(4)
+    return np.array([q[1], q[2], q[3], q[0]], dtype=q.dtype)
+
+
+def _xyzw_to_wxyz(q: np.ndarray) -> np.ndarray:
+    """xyzw (scipy) -> wxyz (scalar first)."""
+    q = np.asarray(q).reshape(4)
+    return np.array([q[3], q[0], q[1], q[2]], dtype=q.dtype)
+
+
+def quat_to_rot(quat: np.ndarray) -> np.ndarray:
+    """
+    Quaternion to rotation matrix (SO3).
+    quat: (4,) wxyz.
+    Returns: (3,3) rotation matrix.
+    """
+    q = np.asarray(quat).reshape(4)
+    r = Rotation.from_quat(_wxyz_to_xyzw(q))
+    return r.as_matrix()
+
+
+def rot_to_quat(rot: np.ndarray) -> np.ndarray:
+    """
+    Rotation matrix to quaternion (wxyz).
+    rot: (3,3).
+    Returns: (4,) wxyz.
+    """
+    R = np.asarray(rot).reshape(3, 3)
+    r = Rotation.from_matrix(R)
+    return _xyzw_to_wxyz(r.as_quat())
+
+
+def x_rot(angle: float) -> np.ndarray:
+    """Rotation matrix about x-axis."""
+    return Rotation.from_euler("x", angle).as_matrix()
+
+
+def y_rot(angle: float) -> np.ndarray:
+    """Rotation matrix about y-axis."""
+    return Rotation.from_euler("y", angle).as_matrix()
+
+
+def z_rot(angle: float) -> np.ndarray:
+    """Rotation matrix about z-axis."""
+    return Rotation.from_euler("z", angle).as_matrix()
+
+
+def euler_to_rot(angles: np.ndarray) -> np.ndarray:
+    """Euler XYZ (extrinsic) to rotation matrix. angles: (3,) [rx, ry, rz]."""
+    a = np.asarray(angles).reshape(3)
+    return Rotation.from_euler("xyz", a).as_matrix()
+
+
+def rot_to_euler(rot: np.ndarray) -> np.ndarray:
+    """Rotation matrix to Euler XYZ. Returns (3,) [rx, ry, rz]."""
+    R = np.asarray(rot).reshape(3, 3)
+    return Rotation.from_matrix(R).as_euler("xyz")
+
+
+def rot_to_axis_angle(rot: np.ndarray) -> np.ndarray:
+    """Rotation matrix to axis-angle (rotation vector). (3,) in rad."""
+    R = np.asarray(rot).reshape(3, 3)
+    r = Rotation.from_matrix(R)
+    return r.as_rotvec()
+
+
+def axis_angle_to_rot(axis_angle: np.ndarray) -> np.ndarray:
+    """Axis-angle to rotation matrix."""
+    v = np.asarray(axis_angle).reshape(3)
+    return Rotation.from_rotvec(v).as_matrix()
+
+
+def axis_angle_to_quat(rotvec: np.ndarray) -> np.ndarray:
+    """Axis-angle to quaternion (wxyz)."""
+    v = np.asarray(rotvec).reshape(3)
+    n = np.linalg.norm(v)
+    if n < _EPS:
+        return np.array([1.0, 0.0, 0.0, 0.0])
+    r = Rotation.from_rotvec(v)
+    return _xyzw_to_wxyz(r.as_quat())
+
+
+def quat_to_axis_angle(quat: np.ndarray) -> np.ndarray:
+    """Quaternion (wxyz) to axis-angle. Single (4,) or batch (N,4) -> (3,) or (N,3)."""
+    q = np.asarray(quat)
+    if q.ndim == 1:
+        q = q.reshape(1, 4)
+        single = True
+    else:
+        single = False
+    r = Rotation.from_quat(_wxyz_to_xyzw(q))
+    out = r.as_rotvec()
+    return out.reshape(-1)[:3] if single else out
+
+
+def quat_inv(quat: np.ndarray) -> np.ndarray:
+    """Inverse of unit quaternion (wxyz). q^{-1} = (w, -x, -y, -z)."""
+    q = np.asarray(quat).reshape(4)
+    return np.array([q[0], -q[1], -q[2], -q[3]], dtype=q.dtype)
+
+
+def quat_multiply(q1: np.ndarray, q2: np.ndarray) -> np.ndarray:
+    """Multiply quaternions (wxyz): q1 * q2."""
+    w1, x1, y1, z1 = np.asarray(q1).reshape(4)
+    w2, x2, y2, z2 = np.asarray(q2).reshape(4)
+    w = w1 * w2 - x1 * x2 - y1 * y2 - z1 * z2
+    x = w1 * x2 + x1 * w2 + y1 * z2 - z1 * y2
+    y = w1 * y2 - x1 * z2 + y1 * w2 + z1 * x2
+    z = w1 * z2 + x1 * y2 - y1 * x2 + z1 * w2
+    return np.array([w, x, y, z])
+
+
+def quat_slerp(q0: np.ndarray, q1: np.ndarray, t: float) -> np.ndarray:
+    """
+    Spherical linear interpolation between two unit quaternions (wxyz).
+    t in [0, 1]. Returns (4,) wxyz.
+    """
+    from scipy.spatial.transform import Slerp
+    q0 = np.asarray(q0).reshape(4)
+    q1 = np.asarray(q1).reshape(4)
+    q1 = quat_ensure_continuous(q1, q0)
+    key_times = np.array([0.0, 1.0])
+    rots = Rotation.from_quat(np.stack([_wxyz_to_xyzw(q0), _wxyz_to_xyzw(q1)]))
+    slerp = Slerp(key_times, rots)
+    r = slerp(float(t))
+    return _xyzw_to_wxyz(r.as_quat())
+
+
+def quat_relative_axis_angle(q_from: np.ndarray, q_to: np.ndarray) -> np.ndarray:
+    """
+    Axis-angle (3,) of the relative rotation from q_from to q_to:
+    R_to @ R_from^T, i.e. q_to * q_from^{-1}. Magnitude is geodesic distance in rad.
+    """
+    q_rel = quat_multiply(q_to, quat_inv(q_from))
+    return quat_to_axis_angle(q_rel)
+
+
+def quat_ensure_continuous(q_current: np.ndarray, q_prev: np.ndarray) -> np.ndarray:
+    """Flip sign of q_current so q_current · q_prev >= 0 (same hemisphere)."""
+    qc = np.asarray(q_current).reshape(4)
+    qp = np.asarray(q_prev).reshape(4)
+    if np.dot(qc, qp) < 0:
+        return -qc
+    return qc
+
+
+def bound_angle(angle: float) -> float:
+    """Wrap angle to (-pi, pi]."""
+    a = float(angle)
+    if a > np.pi:
+        a -= 2 * np.pi
+    elif a <= -np.pi:
+        a += 2 * np.pi
+    return a

dhb_xr/core/geometry_torch.py

@@ -0,0 +1,77 @@
+"""PyTorch geometry utilities for batched SO(3)/SE(3) operations."""
+
+try:
+    import torch
+except ImportError:
+    torch = None
+
+if torch is not None:
+
+    def quat_to_rot_torch(q: "torch.Tensor") -> "torch.Tensor":
+        """(..., 4) wxyz -> (..., 3, 3)."""
+        w, x, y, z = q[..., 0], q[..., 1], q[..., 2], q[..., 3]
+        R = torch.stack(
+            [
+                1 - 2 * (y * y + z * z),
+                2 * (x * y - w * z),
+                2 * (x * z + w * y),
+                2 * (x * y + w * z),
+                1 - 2 * (x * x + z * z),
+                2 * (y * z - w * x),
+                2 * (x * z - w * y),
+                2 * (y * z + w * x),
+                1 - 2 * (x * x + y * y),
+            ],
+            dim=-1,
+        )
+        return R.reshape(*q.shape[:-1], 3, 3)
+
+    def rot_to_quat_torch(R: "torch.Tensor") -> "torch.Tensor":
+        """(..., 3, 3) -> (..., 4) wxyz."""
+        trace = R[..., 0, 0] + R[..., 1, 1] + R[..., 2, 2]
+        w = torch.sqrt(1 + trace + 1e-8) / 2
+        x = (R[..., 2, 1] - R[..., 1, 2]) / (4 * w + 1e-8)
+        y = (R[..., 0, 2] - R[..., 2, 0]) / (4 * w + 1e-8)
+        z = (R[..., 1, 0] - R[..., 0, 1]) / (4 * w + 1e-8)
+        return torch.stack([w, x, y, z], dim=-1)
+
+    def rot_to_axis_angle_torch(R: "torch.Tensor") -> "torch.Tensor":
+        """(..., 3, 3) -> (..., 3) rotation vector."""
+        angle = torch.acos(
+            torch.clamp((R[..., 0, 0] + R[..., 1, 1] + R[..., 2, 2] - 1) / 2, -1, 1)
+        )
+        denom = torch.sqrt(
+            (R[..., 2, 1] - R[..., 1, 2]) ** 2
+            + (R[..., 0, 2] - R[..., 2, 0]) ** 2
+            + (R[..., 1, 0] - R[..., 0, 1]) ** 2
+            + 1e-12
+        )
+        scale = torch.where(
+            angle.abs() < 1e-6,
+            torch.ones_like(angle),
+            angle / denom,
+        )
+        x = (R[..., 2, 1] - R[..., 1, 2]) * scale
+        y = (R[..., 0, 2] - R[..., 2, 0]) * scale
+        z = (R[..., 1, 0] - R[..., 0, 1]) * scale
+        return torch.stack([x, y, z], dim=-1)
+
+    def axis_angle_to_rot_torch(v: "torch.Tensor") -> "torch.Tensor":
+        """(..., 3) -> (..., 3, 3). Rodrigues."""
+        angle = v.norm(dim=-1, keepdim=True).clamp(min=1e-8)
+        axis = v / angle
+        K = torch.zeros(*v.shape[:-1], 3, 3, device=v.device, dtype=v.dtype)
+        K[..., 0, 1] = -axis[..., 2]
+        K[..., 0, 2] = axis[..., 1]
+        K[..., 1, 0] = axis[..., 2]
+        K[..., 1, 2] = -axis[..., 0]
+        K[..., 2, 0] = -axis[..., 1]
+        K[..., 2, 1] = axis[..., 0]
+        I = torch.eye(3, device=v.device, dtype=v.dtype).expand_as(K)
+        return I + torch.sin(angle).unsqueeze(-1) * K + (1 - torch.cos(angle)).unsqueeze(-1) * (K @ K)
+
+else:
+    quat_to_rot_torch = None
+    rot_to_quat_torch = None
+    rot_to_axis_angle_torch = None
+    axis_angle_to_rot_torch = None

dhb_xr/core/types.py

@@ -0,0 +1,113 @@
+"""Core data types for SE(3) trajectories and DHB invariants."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import List, Optional, Literal, Dict, Any
+
+import numpy as np
+
+
+class DHBMethod(Enum):
+    """DHB encoding method."""
+
+    ORIGINAL = "original"  # 3 invariants per component (magnitude + 2 angles)
+    DOUBLE_REFLECTION = "double_reflection"  # 4 invariants (magnitude + Euler XYZ)
+    QUATERNION = "quaternion"  # 5 invariants (magnitude + unit quaternion)
+
+
+class EncodingMethod(Enum):
+    """Encoding method for initial frame computation."""
+
+    POSITION = "pos"  # Position-based encoding: use initial position for frame origin
+    VELOCITY = "vel"  # Velocity-based encoding: use first position difference for frame origin
+
+
+@dataclass
+class SE3Pose:
+    """Single SE(3) pose: position and quaternion (w, x, y, z)."""
+
+    position: np.ndarray  # (3,)
+    quaternion: np.ndarray  # (4,) wxyz scalar-first
+
+    def __post_init__(self) -> None:
+        self.position = np.asarray(self.position, dtype=np.float64).reshape(3)
+        self.quaternion = np.asarray(self.quaternion, dtype=np.float64).reshape(4)
+        nq = np.linalg.norm(self.quaternion)
+        if nq > 1e-10:
+            self.quaternion = self.quaternion / nq
+
+    def to_dict(self) -> Dict[str, np.ndarray]:
+        return {"position": self.position.copy(), "quaternion": self.quaternion.copy()}
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, np.ndarray]) -> SE3Pose:
+        return cls(position=d["position"], quaternion=d["quaternion"])
+
+
+@dataclass
+class Trajectory:
+    """SE(3) trajectory: sequence of poses and optional timestamps."""
+
+    poses: List[SE3Pose]
+    timestamps: Optional[np.ndarray] = None
+
+    def __len__(self) -> int:
+        return len(self.poses)
+
+    @property
+    def positions(self) -> np.ndarray:
+        """(N, 3) position array."""
+        return np.array([p.position for p in self.poses])
+
+    @property
+    def quaternions(self) -> np.ndarray:
+        """(N, 4) quaternion array (wxyz)."""
+        return np.array([p.quaternion for p in self.poses])
+
+    @classmethod
+    def from_arrays(
+        cls,
+        positions: np.ndarray,
+        quaternions: np.ndarray,
+        timestamps: Optional[np.ndarray] = None,
+    ) -> Trajectory:
+        """Build from (N,3) positions and (N,4) quaternions (wxyz)."""
+        n = len(positions)
+        assert len(quaternions) == n
+        poses = [
+            SE3Pose(position=positions[i], quaternion=quaternions[i])
+            for i in range(n)
+        ]
+        return cls(poses=poses, timestamps=timestamps)
+
+
+@dataclass
+class InvariantSequence:
+    """DHB invariant sequence (linear + angular)."""
+
+    linear: np.ndarray  # (N-1, k) k=3 original, k=4 DR, k=5 QR
+    angular: np.ndarray  # (N-1, k)
+    method: Literal["dhb_dr", "dhb_qr", "original"]
+    initial_pose: Dict[str, np.ndarray]
+    linear_frame_initial: Optional[np.ndarray] = None  # (4,4) if available
+    angular_frame_initial: Optional[np.ndarray] = None
+
+    def __post_init__(self) -> None:
+        self.linear = np.asarray(self.linear, dtype=np.float64)
+        self.angular = np.asarray(self.angular, dtype=np.float64)
+        assert self.linear.shape[0] == self.angular.shape[0]
+        assert self.linear.shape[1] == self.angular.shape[1]
+
+    @property
+    def length(self) -> int:
+        return self.linear.shape[0]
+
+    @property
+    def invariant_dim(self) -> int:
+        return self.linear.shape[1]
+
+    def concatenated(self) -> np.ndarray:
+        """(N-1, 2*k) linear and angular stacked."""
+        return np.concatenate([self.linear, self.angular], axis=1)

dhb_xr/database/__init__.py

@@ -0,0 +1,10 @@
+"""Motion database: storage, similarity, retrieval."""
+
+__all__ = ["MotionDatabase", "invariant_distance", "soft_dtw_distance"]
+
+from dhb_xr.database.similarity import invariant_distance, soft_dtw_distance
+
+try:
+    from dhb_xr.database.motion_db import MotionDatabase
+except ImportError:
+    MotionDatabase = None