dhb-xr 0.2.1__py3-none-any.whl

dhb_xr/database/motion_db.py

@@ -0,0 +1,79 @@
+"""Motion database: store trajectories and invariants, similarity search."""
+
+import numpy as np
+from typing import List, Dict, Any, Optional
+
+from dhb_xr.encoder.dhb_dr import encode_dhb_dr
+from dhb_xr.core.types import DHBMethod, EncodingMethod
+from dhb_xr.database.similarity import invariant_distance, soft_dtw_distance
+
+try:
+    import faiss
+    HAS_FAISS = True
+except ImportError:
+    HAS_FAISS = False
+
+
+class MotionDatabase:
+    """
+    Store trajectories as invariants; optional FAISS index for fast retrieval.
+    add(trajectory, metadata) -> encode and store
+    retrieve(query_trajectory, k) -> top-k similar (by L2 on invariants or DTW).
+    """
+
+    def __init__(self, dhb_method: str = "double_reflection", use_faiss: bool = False):
+        self.dhb_method = DHBMethod.DOUBLE_REFLECTION if dhb_method == "double_reflection" else DHBMethod.ORIGINAL
+        self.k_inv = 4 if self.dhb_method == DHBMethod.DOUBLE_REFLECTION else 3
+        self.invariants_list: List[np.ndarray] = []
+        self.metadata_list: List[Dict[str, Any]] = []
+        self.use_faiss = use_faiss and HAS_FAISS
+        self.index: Optional[Any] = None
+        self.embedding_dim: Optional[int] = None
+
+    def add(
+        self,
+        positions: np.ndarray,
+        quaternions: np.ndarray,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        out = encode_dhb_dr(
+            positions, quaternions,
+            method=EncodingMethod.POSITION, use_default_initial_frames=True, dhb_method=self.dhb_method,
+        )
+        U = np.concatenate([
+            out["linear_motion_invariants"],
+            out["angular_motion_invariants"],
+        ], axis=1)
+        self.invariants_list.append(U.astype(np.float32))
+        self.metadata_list.append(metadata or {})
+        if self.use_faiss and U.size > 0:
+            flat = U.flatten()
+            if self.embedding_dim is None:
+                self.embedding_dim = flat.shape[0]
+                self.index = faiss.IndexFlatL2(self.embedding_dim)
+            emb = flat.reshape(1, -1).astype(np.float32)
+            if emb.shape[1] == self.embedding_dim:
+                self.index.add(emb)
+
+    def retrieve(
+        self,
+        query_positions: np.ndarray,
+        query_quaternions: np.ndarray,
+        k: int = 10,
+        use_dtw: bool = False,
+    ) -> List[tuple]:
+        out = encode_dhb_dr(
+            query_positions, query_quaternions,
+            method=EncodingMethod.POSITION, use_default_initial_frames=True, dhb_method=self.dhb_method,
+        )
+        U_q = np.concatenate([
+            out["linear_motion_invariants"],
+            out["angular_motion_invariants"],
+        ], axis=1)
+        if use_dtw:
+            dists = [soft_dtw_distance(U_q, U) for U in self.invariants_list]
+            idx = np.argsort(dists)[:k]
+            return [(self.invariants_list[i], self.metadata_list[i], dists[i]) for i in idx]
+        dists = [invariant_distance(U_q, U) for U in self.invariants_list]
+        idx = np.argsort(dists)[:k]
+        return [(self.invariants_list[i], self.metadata_list[i], dists[i]) for i in idx]

dhb_xr/database/retrieval.py

@@ -0,0 +1,6 @@
+"""ANN retrieval helpers (FAISS). Re-exported via database/__init__.py."""
+
+from dhb_xr.database.motion_db import MotionDatabase
+from dhb_xr.database.similarity import invariant_distance, soft_dtw_distance
+
+__all__ = ["MotionDatabase", "invariant_distance", "soft_dtw_distance"]

dhb_xr/database/similarity.py

@@ -0,0 +1,71 @@
+"""Similarity and distance measures for invariant sequences."""
+
+import numpy as np
+from typing import Optional
+
+from dhb_xr.core import geometry as geom
+
+
+def quaternion_geodesic_distance(q1: np.ndarray, q2: np.ndarray) -> np.ndarray:
+    """Quaternion geodesic distance (rad). q1, q2: (..., 4) wxyz. Returns scalar or array."""
+    q1 = np.asarray(q1).reshape(-1, 4)
+    q2 = np.asarray(q2).reshape(-1, 4)
+    dot = np.abs(np.sum(q1 * q2, axis=-1))
+    dot = np.clip(dot, 0, 1)
+    return 2 * np.arccos(dot)
+
+
+def invariant_distance(
+    U: np.ndarray,
+    V: np.ndarray,
+    weights: Optional[np.ndarray] = None,
+    use_quat_geodesic: bool = False,
+    quat_start_idx: int = 1,
+    quat_len: int = 4,
+) -> float:
+    """
+    Aligned L2 distance between invariant sequences.
+    U, V: (N, 2*k) or (N, k_lin + k_ang). If use_quat_geodesic, angular quaternion part uses geodesic.
+    """
+    U = np.asarray(U)
+    V = np.asarray(V)
+    assert U.shape == V.shape
+    if weights is None:
+        weights = np.ones(U.shape[1])
+    weights = np.asarray(weights).reshape(-1)
+    diff = U - V
+    if use_quat_geodesic:
+        # Assume linear then angular; each component [m, ...]. Angular has quat at [quat_start_idx:quat_start_idx+quat_len]
+        half = U.shape[1] // 2
+        for i in range(U.shape[0]):
+            for j in [0, 1]:
+                base = j * half
+                if base + quat_start_idx + quat_len <= U.shape[1]:
+                    q1 = U[i, base + quat_start_idx : base + quat_start_idx + quat_len]
+                    q2 = V[i, base + quat_start_idx : base + quat_start_idx + quat_len]
+                    d = quaternion_geodesic_distance(q1, q2)
+                    diff[i, base + quat_start_idx] = d
+        dist = np.sqrt(np.sum(weights * (diff ** 2)))
+    else:
+        dist = np.sqrt(np.sum(weights * (diff ** 2)))
+    return float(dist)
+
+
+def soft_dtw_distance(
+    U: np.ndarray,
+    V: np.ndarray,
+    gamma: float = 1.0,
+) -> float:
+    """Soft-DTW (differentiable) between two sequences. Requires dtaidistance or simple implementation."""
+    try:
+        from dtaidistance import dtw
+        return float(dtw.distance(U, V, use_c=True))
+    except ImportError:
+        n, m = len(U), len(V)
+        D = np.zeros((n + 1, m + 1)) + np.inf
+        D[0, 0] = 0
+        for i in range(1, n + 1):
+            for j in range(1, m + 1):
+                d_ij = np.sum((U[i - 1] - V[j - 1]) ** 2)
+                D[i, j] = d_ij + min(D[i - 1, j], D[i, j - 1], D[i - 1, j - 1])
+        return float(D[n, m])

dhb_xr/decoder/__init__.py

@@ -0,0 +1,13 @@
+"""DHB decoders: DHB-DR, DHB-QR, batched PyTorch."""
+
+from dhb_xr.decoder.dhb_dr import decode_dhb_dr
+
+__all__ = [
+    "decode_dhb_dr",
+    "decode_dhb_qr",
+]
+
+try:
+    from dhb_xr.decoder.dhb_qr import decode_dhb_qr
+except ImportError:
+    decode_dhb_qr = None

dhb_xr/decoder/decoder_torch.py

@@ -0,0 +1,52 @@
+"""Batched DHB decoder in PyTorch: wrapper over numpy decode."""
+
+try:
+    import torch
+    import torch.nn as nn
+except ImportError:
+    torch = None
+    nn = None
+
+if torch is not None:
+
+    import numpy as np
+    from dhb_xr.decoder.dhb_dr import decode_dhb_dr
+    from dhb_xr.core.types import DHBMethod
+
+    class DHBDecoderTorch(nn.Module):
+        """
+        Batched DHB-DR decoder.
+        invariants (B, N-2, 8), initial_poses list of dict -> positions (B, N', 3), quaternions (B, N', 4).
+        """
+
+        def __init__(self, dhb_method: str = "double_reflection"):
+            super().__init__()
+            self.dhb_method = DHBMethod.DOUBLE_REFLECTION if dhb_method == "double_reflection" else DHBMethod.ORIGINAL
+
+        def forward(
+            self,
+            invariants: torch.Tensor,
+            initial_poses: list,
+        ) -> tuple:
+            B = invariants.shape[0]
+            k = 4 if self.dhb_method == DHBMethod.DOUBLE_REFLECTION else 3
+            assert invariants.shape[2] == 2 * k
+            pos_list = []
+            quat_list = []
+            for b in range(B):
+                inv = invariants[b].detach().cpu().numpy()
+                lin = inv[:, :k]
+                ang = inv[:, k:]
+                init = initial_poses[b] if isinstance(initial_poses[b], dict) else {
+                    "position": initial_poses[b]["position"].cpu().numpy() if hasattr(initial_poses[b]["position"], "cpu") else np.asarray(initial_poses[b]["position"]),
+                    "quaternion": initial_poses[b]["quaternion"].cpu().numpy() if hasattr(initial_poses[b]["quaternion"], "cpu") else np.asarray(initial_poses[b]["quaternion"]),
+                }
+                out = decode_dhb_dr(lin, ang, init, method=EncodingMethod.POSITION, dhb_method=self.dhb_method, drop_padded=True)
+                pos_list.append(torch.from_numpy(out["positions"]))
+                quat_list.append(torch.from_numpy(out["quaternions"]))
+            positions = torch.stack(pos_list, dim=0)
+            quaternions = torch.stack(quat_list, dim=0)
+            return positions, quaternions
+
+else:
+    DHBDecoderTorch = None

dhb_xr/decoder/dhb_dr.py

@@ -0,0 +1,261 @@
+"""
+DHB-DR decoder: reconstruct SE(3) trajectory from invariants.
+Quaternion convention: wxyz (scalar-first).
+
+Robustness features:
+- Initial pose validation
+- Divergence detection with optional warnings
+- NaN/Inf handling for degenerate invariants
+"""
+
+import numpy as np
+import warnings
+from typing import Dict, Any, Optional
+from dataclasses import dataclass
+
+from dhb_xr.core.types import DHBMethod, EncodingMethod
+from dhb_xr.core import geometry as geom
+
+EPSILON = 1e-10
+
+
+@dataclass
+class DecodingDiagnostics:
+    """Diagnostics from decoding."""
+    initial_pose_valid: bool = True
+    num_nan_positions: int = 0
+    num_nan_quaternions: int = 0
+    max_step_size: float = 0.0
+    trajectory_length: float = 0.0
+
+
+def _validate_initial_pose(initial_pose: Dict[str, np.ndarray]) -> bool:
+    """Validate that initial pose is well-formed."""
+    try:
+        pos = np.asarray(initial_pose["position"]).reshape(3)
+        quat = np.asarray(initial_pose["quaternion"]).reshape(4)
+
+        # Check for NaN/Inf
+        if not np.all(np.isfinite(pos)):
+            return False
+        if not np.all(np.isfinite(quat)):
+            return False
+
+        # Check quaternion is normalized
+        quat_norm = np.linalg.norm(quat)
+        if abs(quat_norm - 1.0) > 0.01:
+            return False
+
+        return True
+    except (KeyError, ValueError):
+        return False
+
+
+def _normalize_quaternion(quat: np.ndarray) -> np.ndarray:
+    """Normalize quaternion to unit length."""
+    norm = np.linalg.norm(quat)
+    if norm > EPSILON:
+        return quat / norm
+    return np.array([1.0, 0.0, 0.0, 0.0])
+
+
+def decode_dhb_dr(
+    linear_motion_invariants: np.ndarray,
+    angular_motion_invariants: np.ndarray,
+    initial_pose: Dict[str, np.ndarray],
+    method: EncodingMethod = EncodingMethod.POSITION,
+    dhb_method: DHBMethod = DHBMethod.DOUBLE_REFLECTION,
+    drop_padded: bool = True,
+    robust_mode: bool = False,
+    validate_initial_pose: bool = False,
+    return_diagnostics: bool = False,
+) -> Dict[str, Any]:
+    """
+    Reconstruct poses from DHB invariants.
+
+    Parameters:
+        linear_motion_invariants: (N, k) linear invariants
+        angular_motion_invariants: (N, k) angular invariants
+        initial_pose: {'position': (3,), 'quaternion': (4,) wxyz}
+        method: 'pos' or 'vel'
+        dhb_method: DHBMethod.ORIGINAL (3 inv) or DHBMethod.DOUBLE_REFLECTION (4 inv)
+        drop_padded: if True, return positions/quaternions[2:] to match encoder padding
+        robust_mode: Enable robustness features (NaN handling, normalization)
+        validate_initial_pose: Check initial pose validity before decoding
+        return_diagnostics: Include decoding diagnostics in output
+
+    Returns:
+        dict with 'positions' (N,3), 'quaternions' (N,4) wxyz,
+        and optionally 'diagnostics' if return_diagnostics=True.
+    """
+    diagnostics = DecodingDiagnostics() if return_diagnostics else None
+
+    # Validate initial pose if requested
+    if validate_initial_pose or robust_mode:
+        if not _validate_initial_pose(initial_pose):
+            if diagnostics:
+                diagnostics.initial_pose_valid = False
+            if robust_mode:
+                warnings.warn("Invalid initial pose detected. Using identity pose.")
+                initial_pose = {
+                    "position": np.zeros(3),
+                    "quaternion": np.array([1.0, 0.0, 0.0, 0.0])
+                }
+            else:
+                raise ValueError("Invalid initial pose: position or quaternion is malformed or contains NaN/Inf")
+    linear_inv = np.asarray(linear_motion_invariants, dtype=np.float64)
+    angular_inv = np.asarray(angular_motion_invariants, dtype=np.float64)
+    num_samples = linear_inv.shape[0]
+    assert angular_inv.shape[0] == num_samples
+
+    if dhb_method == DHBMethod.ORIGINAL:
+        linear_magnitude = linear_inv[:, 0]
+        linear_angle_y = linear_inv[:, 1]
+        linear_angle_x = linear_inv[:, 2]
+        angular_magnitude = angular_inv[:, 0]
+        angular_angle_y = angular_inv[:, 1]
+        angular_angle_x = angular_inv[:, 2]
+    else:
+        linear_magnitude = linear_inv[:, 0]
+        linear_angles = linear_inv[:, 1:4]
+        angular_magnitude = angular_inv[:, 0]
+        angular_angles = angular_inv[:, 1:4]
+
+    position_mode = method == EncodingMethod.POSITION
+    init_pos = np.asarray(initial_pose["position"]).reshape(3)
+    init_quat = np.asarray(initial_pose["quaternion"]).reshape(4)
+
+    trajectory_position = np.zeros((num_samples, 3))
+    trajectory_quaternions = np.zeros((num_samples, 4))
+    trajectory_quaternions[0] = init_quat
+
+    linear_frame = np.eye(4)
+    linear_frame[:3, 3] = init_pos
+    linear_frame[3, 3] = float(position_mode)
+
+    angular_frame = np.eye(4)
+    angular_rot_temp = geom.quat_to_rot(init_quat)
+
+    prev_pos = init_pos.copy()
+
+    for i in range(num_samples):
+        if position_mode:
+            trajectory_position[i] = linear_frame[:3, 3]
+
+        if dhb_method == DHBMethod.ORIGINAL:
+            R_lin = geom.y_rot(linear_angle_y[i]) @ geom.x_rot(linear_angle_x[i])
+        else:
+            R_lin = geom.euler_to_rot(linear_angles[i])
+
+        trans = np.array([linear_magnitude[i], 0.0, 0.0])
+        T = np.eye(4)
+        T[:3, :3] = R_lin
+        T[:3, 3] = trans
+        T[3, 3] = float(position_mode)
+        linear_frame = linear_frame @ T
+
+        if not position_mode:
+            trajectory_position[i] = linear_frame[:3, 3]
+
+        # Handle NaN in robust mode
+        if robust_mode:
+            if not np.all(np.isfinite(trajectory_position[i])):
+                if diagnostics:
+                    diagnostics.num_nan_positions += 1
+                trajectory_position[i] = prev_pos.copy()
+            else:
+                # Track step size for diagnostics
+                step_size = np.linalg.norm(trajectory_position[i] - prev_pos)
+                if diagnostics:
+                    diagnostics.max_step_size = max(diagnostics.max_step_size, step_size)
+                    diagnostics.trajectory_length += step_size
+                prev_pos = trajectory_position[i].copy()
+
+        rvec = angular_frame[:3, :3] @ np.array([angular_magnitude[i], 0.0, 0.0])
+
+        if dhb_method == DHBMethod.ORIGINAL:
+            R_ang = geom.y_rot(angular_angle_y[i]) @ geom.x_rot(angular_angle_x[i])
+        else:
+            R_ang = geom.euler_to_rot(angular_angles[i])
+
+        angular_rot_temp = angular_rot_temp @ geom.axis_angle_to_rot(rvec).T
+        if i < num_samples - 1:
+            quat = geom.rot_to_quat(angular_rot_temp)
+            # Normalize quaternion in robust mode
+            if robust_mode:
+                quat = _normalize_quaternion(quat)
+                if not np.all(np.isfinite(quat)):
+                    if diagnostics:
+                        diagnostics.num_nan_quaternions += 1
+                    quat = trajectory_quaternions[i].copy()  # Use previous
+            trajectory_quaternions[i + 1] = quat
+        angular_frame[:3, :3] = angular_frame[:3, :3] @ R_ang
+
+    if drop_padded:
+        trajectory_position = trajectory_position[2:]
+        trajectory_quaternions = trajectory_quaternions[2:]
+
+    result = {
+        "positions": trajectory_position,
+        "quaternions": trajectory_quaternions,
+    }
+
+    if return_diagnostics and diagnostics is not None:
+        result["diagnostics"] = diagnostics
+
+    return result
+
+
+def reconstruct_trajectory_single_step(
+    linear_invariants: np.ndarray,
+    angular_invariants: np.ndarray,
+    current_linear_frame: np.ndarray,
+    current_angular_frame: np.ndarray,
+    method: str,
+    dhb_method: DHBMethod = DHBMethod.DOUBLE_REFLECTION,
+) -> tuple:
+    """Single-step reconstruction for use in optimization. Returns (new_linear_frame, new_angular_frame, new_position, new_rotation_vec)."""
+    if dhb_method == DHBMethod.ORIGINAL:
+        linear_magnitude = linear_invariants[0]
+        linear_angle_y = linear_invariants[1]
+        linear_angle_x = linear_invariants[2]
+        angular_magnitude = angular_invariants[0]
+        angular_angle_y = angular_invariants[1]
+        angular_angle_x = angular_invariants[2]
+    else:
+        linear_magnitude = float(linear_invariants[0])
+        linear_angles = linear_invariants[1:4]
+        angular_magnitude = float(angular_invariants[0])
+        angular_angles = angular_invariants[1:4]
+
+    position_mode = method == EncodingMethod.POSITION
+    if position_mode:
+        new_position = current_linear_frame[:3, 3].copy()
+
+    if dhb_method == DHBMethod.ORIGINAL:
+        R_lin = geom.y_rot(linear_angle_y) @ geom.x_rot(linear_angle_x)
+    else:
+        R_lin = geom.euler_to_rot(linear_angles)
+
+    T = np.eye(4)
+    T[:3, :3] = R_lin
+    T[:3, 3] = np.array([linear_magnitude, 0.0, 0.0])
+    T[3, 3] = float(position_mode)
+    new_linear_frame = current_linear_frame @ T
+
+    if not position_mode:
+        new_position = new_linear_frame[:3, 3].copy()
+
+    new_rotation = current_angular_frame[:3, :3] @ np.array(
+        [angular_magnitude, 0.0, 0.0]
+    )
+
+    if dhb_method == DHBMethod.ORIGINAL:
+        R_ang = geom.y_rot(angular_angle_y) @ geom.x_rot(angular_angle_x)
+    else:
+        R_ang = geom.euler_to_rot(angular_angles)
+
+    new_angular_frame = np.eye(4)
+    new_angular_frame[:3, :3] = current_angular_frame[:3, :3] @ R_ang
+
+    return new_linear_frame, new_angular_frame, new_position, new_rotation

dhb_xr/decoder/dhb_qr.py

@@ -0,0 +1,89 @@
+"""
+DHB-QR decoder: reconstruct trajectory from quaternion-based invariants.
+Per-step: magnitude + unit quaternion (5 values per component).
+"""
+
+import numpy as np
+from typing import Dict, Any
+
+from dhb_xr.core.types import EncodingMethod
+from dhb_xr.core import geometry as geom
+
+
+def decode_dhb_qr(
+    linear_motion_invariants: np.ndarray,
+    angular_motion_invariants: np.ndarray,
+    initial_pose: Dict[str, np.ndarray],
+    method: str = "pos",
+    drop_padded: bool = True,
+) -> Dict[str, Any]:
+    """
+    Reconstruct poses from DHB-QR invariants.
+
+    initial_pose: {'position': (3,), 'quaternion': (4,) wxyz}
+    drop_padded: if True, return positions/quaternions[2:].
+
+    Returns dict with 'positions' (N,3), 'quaternions' (N,4) wxyz.
+    """
+    linear_inv = np.asarray(linear_motion_invariants, dtype=np.float64)
+    angular_inv = np.asarray(angular_motion_invariants, dtype=np.float64)
+    num_samples = linear_inv.shape[0]
+    assert angular_inv.shape[0] == num_samples and linear_inv.shape[1] == 5
+
+    linear_magnitude = linear_inv[:, 0]
+    linear_quat = linear_inv[:, 1:5]  # (N, 4) wxyz
+    angular_magnitude = angular_inv[:, 0]
+    angular_quat = angular_inv[:, 1:5]
+
+    # Normalize quaternions
+    for i in range(num_samples):
+        n = np.linalg.norm(linear_quat[i])
+        if n > 1e-12:
+            linear_quat[i] /= n
+        n = np.linalg.norm(angular_quat[i])
+        if n > 1e-12:
+            angular_quat[i] /= n
+
+    position_mode = method == EncodingMethod.POSITION
+    init_pos = np.asarray(initial_pose["position"]).reshape(3)
+    init_quat = np.asarray(initial_pose["quaternion"]).reshape(4)
+
+    trajectory_position = np.zeros((num_samples, 3))
+    trajectory_quaternions = np.zeros((num_samples, 4))
+    trajectory_quaternions[0] = init_quat
+
+    linear_frame = np.eye(4)
+    linear_frame[:3, 3] = init_pos
+    linear_frame[3, 3] = float(position_mode)
+    angular_rot_temp = geom.quat_to_rot(init_quat)
+
+    for i in range(num_samples):
+        if position_mode:
+            trajectory_position[i] = linear_frame[:3, 3]
+
+        R_lin = geom.quat_to_rot(linear_quat[i])
+        trans = R_lin @ np.array([linear_magnitude[i], 0.0, 0.0])
+        T = np.eye(4)
+        T[:3, :3] = R_lin
+        T[:3, 3] = trans
+        T[3, 3] = float(position_mode)
+        linear_frame = linear_frame @ T
+
+        if not position_mode:
+            trajectory_position[i] = linear_frame[:3, 3]
+
+        rvec = geom.quat_to_rot(angular_quat[i]) @ np.array(
+            [angular_magnitude[i], 0.0, 0.0]
+        )
+        angular_rot_temp = angular_rot_temp @ geom.axis_angle_to_rot(rvec).T
+        if i < num_samples - 1:
+            trajectory_quaternions[i + 1] = geom.rot_to_quat(angular_rot_temp)
+
+    if drop_padded:
+        trajectory_position = trajectory_position[2:]
+        trajectory_quaternions = trajectory_quaternions[2:]
+
+    return {
+        "positions": trajectory_position,
+        "quaternions": trajectory_quaternions,
+    }

dhb_xr/encoder/__init__.py

@@ -0,0 +1,27 @@
+"""DHB encoders: DHB-DR (Euler), DHB-QR (quaternion), DHB-TI (time-invariant), batched PyTorch."""
+
+from dhb_xr.core.types import DHBMethod
+from dhb_xr.encoder.dhb_dr import encode_dhb_dr
+from dhb_xr.encoder.padding import extrapolate_boundary_poses
+from dhb_xr.encoder.dhb_ti import (
+    compute_progress,
+    resample_by_progress,
+    encode_dhb_dr_ti,
+    encode_dhb_qr_ti,
+)
+
+__all__ = [
+    "encode_dhb_dr",
+    "encode_dhb_qr",
+    "encode_dhb_dr_ti",
+    "encode_dhb_qr_ti",
+    "compute_progress",
+    "resample_by_progress",
+    "DHBMethod",
+    "extrapolate_boundary_poses",
+]
+
+try:
+    from dhb_xr.encoder.dhb_qr import encode_dhb_qr
+except ImportError:
+    encode_dhb_qr = None