transform-base 0.0.2__tar.gz

transform_base-0.0.2/MANIFEST.in

@@ -0,0 +1,19 @@
+include README.md
+prune test*
+prune tests*
+prune docs*
+prune examples*
+prune input*
+prune output*
+prune log*
+prune logs*
+prune tmp*
+prune temp*
+prune .git
+prune .pytest_cache
+prune .mypy_cache
+prune __pycache__
+global-exclude *.log
+global-exclude *.pyc
+global-exclude *.pyo
+global-exclude .DS_Store

transform_base-0.0.2/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: transform-base
+Version: 0.0.2
+Summary: 欧拉角、旋转矩阵、四元数、角轴及外参变换基础库，支持多种旋转顺序
+License-Expression: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.20
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+
+# transform-base
+
+欧拉角、旋转矩阵、四元数、角轴及外参变换基础库，支持多种旋转顺序（XYZ/XZY/YXZ/YZX/ZXY/ZYX）。
+
+## 安装
+
+```bash
+pip install transform-base
+```
+
+## 功能特性
+
+- **角度归一化**：`normalize_angle` 将角度归一化到 [-180, 180]
+- **欧拉角 ↔ 旋转矩阵**：支持 6 种旋转顺序（order），默认 ZYX
+- **旋转矩阵 ↔ 四元数**：`[x, y, z, w]` 格式
+- **旋转矩阵 ↔ 角轴**：Rodrigues 公式
+- **外参类 ExtrinsicParam**：欧拉/旋转矩阵/四元数/角轴多种初始化，齐次矩阵、点变换、复合与逆
+
+## 快速开始
+
+```python
+from transform_base import (
+    normalize_angle,
+    standard_euler_to_rotation_matrix,
+    rotation_matrix_to_standard_euler,
+    ExtrinsicParam,
+)
+
+# 欧拉角 -> 旋转矩阵 -> 欧拉角
+euler = [10.0, 20.0, 30.0]  # roll, pitch, yaw (度)
+R = standard_euler_to_rotation_matrix(*euler, order="ZYX")
+euler_back = rotation_matrix_to_standard_euler(R, order="ZYX")
+
+# 外参：欧拉角 + 平移
+ext = ExtrinsicParam(euler=[0, 0, 90], translation=[1, 0, 0])
+p_out = ext.transform_point([1, 0, 0])
+ext_inv = ext.inverse()
+```
+
+## 依赖
+
+- Python >= 3.10
+- numpy >= 1.20
+
+## License
+
+MIT

transform_base-0.0.2/README.md

@@ -0,0 +1,47 @@
+# transform-base
+
+欧拉角、旋转矩阵、四元数、角轴及外参变换基础库，支持多种旋转顺序（XYZ/XZY/YXZ/YZX/ZXY/ZYX）。
+
+## 安装
+
+```bash
+pip install transform-base
+```
+
+## 功能特性
+
+- **角度归一化**：`normalize_angle` 将角度归一化到 [-180, 180]
+- **欧拉角 ↔ 旋转矩阵**：支持 6 种旋转顺序（order），默认 ZYX
+- **旋转矩阵 ↔ 四元数**：`[x, y, z, w]` 格式
+- **旋转矩阵 ↔ 角轴**：Rodrigues 公式
+- **外参类 ExtrinsicParam**：欧拉/旋转矩阵/四元数/角轴多种初始化，齐次矩阵、点变换、复合与逆
+
+## 快速开始
+
+```python
+from transform_base import (
+    normalize_angle,
+    standard_euler_to_rotation_matrix,
+    rotation_matrix_to_standard_euler,
+    ExtrinsicParam,
+)
+
+# 欧拉角 -> 旋转矩阵 -> 欧拉角
+euler = [10.0, 20.0, 30.0]  # roll, pitch, yaw (度)
+R = standard_euler_to_rotation_matrix(*euler, order="ZYX")
+euler_back = rotation_matrix_to_standard_euler(R, order="ZYX")
+
+# 外参：欧拉角 + 平移
+ext = ExtrinsicParam(euler=[0, 0, 90], translation=[1, 0, 0])
+p_out = ext.transform_point([1, 0, 0])
+ext_inv = ext.inverse()
+```
+
+## 依赖
+
+- Python >= 3.10
+- numpy >= 1.20
+
+## License
+
+MIT

transform_base-0.0.2/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["setuptools>=61", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "transform-base"
+version = "0.0.2"
+description = "欧拉角、旋转矩阵、四元数、角轴及外参变换基础库，支持多种旋转顺序"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+dependencies = [
+    "numpy>=1.20",
+]
+
+[project.optional-dependencies]
+dev = ["pytest", "build", "twine"]
+
+[tool.setuptools.packages.find]
+exclude = [
+    "test*",
+    "tests*",
+    "docs*",
+    "examples*",
+    "input*",
+    "output*",
+    "log*",
+    "logs*",
+    "*.log",
+    "tmp*",
+    "temp*",
+    ".pytest_cache*",
+    ".mypy_cache*",
+    "__pycache__*",
+    "*.pyc",
+]

transform_base-0.0.2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

transform_base-0.0.2/transform_base/__init__.py

@@ -0,0 +1,30 @@
+# transform_base: 欧拉角、旋转矩阵、四元数、角轴及外参变换基础库
+from transform_base.transform import (
+    normalize_angle,
+    standard_euler_to_rotation_matrix,
+    rotation_matrix_to_standard_euler,
+    rotation_matrix_to_quaternion,
+    quaternion_to_rotation_matrix,
+    rotation_matrix_to_axis_angle,
+    axis_angle_to_rotation_matrix,
+    standard_euler_to_quaternion,
+    quaternion_to_standard_euler,
+    standard_euler_to_axis_angle,
+    axis_angle_to_standard_euler,
+    ExtrinsicParam,
+)
+
+__all__ = [
+    "normalize_angle",
+    "standard_euler_to_rotation_matrix",
+    "rotation_matrix_to_standard_euler",
+    "rotation_matrix_to_quaternion",
+    "quaternion_to_rotation_matrix",
+    "rotation_matrix_to_axis_angle",
+    "axis_angle_to_rotation_matrix",
+    "standard_euler_to_quaternion",
+    "quaternion_to_standard_euler",
+    "standard_euler_to_axis_angle",
+    "axis_angle_to_standard_euler",
+    "ExtrinsicParam",
+]

transform_base-0.0.2/transform_base/transform.py

@@ -0,0 +1,778 @@
+import numpy as np
+from typing import Tuple, Union, Optional
+import warnings
+
+
+# ==================== 角度归一化 ====================
+
+def normalize_angle(angle: float) -> float:
+    """
+    将角度归一化到[-180, 180]区间
+
+    参数:
+        angle: 输入角度,单位度
+
+    返回:
+        归一化后的角度,范围[-180, 180]
+    """
+    while angle > 180:
+        angle -= 360
+    while angle < -180:
+        angle += 360
+    return angle
+
+
+# ==================== Order参数辅助函数 ====================
+
+def _normalize_order(order: str) -> str:
+    """
+    规范化order参数（转大写，验证有效性，默认'ZYX'）
+
+    参数:
+        order: 旋转顺序字符串，支持 'XYZ', 'XZY', 'YXZ', 'YZX', 'ZXY', 'ZYX'（不区分大小写）
+               order表示从右往左读矩阵乘法的顺序，如ZYX表示 Rx @ Ry @ Rz
+
+    返回:
+        规范化后的order字符串（大写），不识别的输入默认返回'ZYX'
+    """
+    if order is None:
+        return 'ZYX'
+
+    order_upper = order.upper()
+    valid_orders = ['XYZ', 'XZY', 'YXZ', 'YZX', 'ZXY', 'ZYX']
+
+    if order_upper not in valid_orders:
+        warnings.warn(f"无效的order值'{order}',默认使用'ZYX'。有效值为: {valid_orders}", UserWarning)
+        return 'ZYX'
+
+    return order_upper
+
+
+def _get_basic_rotation_matrices(roll_rad: float, pitch_rad: float, yaw_rad: float) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """
+    获取基础旋转矩阵 Rx, Ry, Rz
+
+    参数:
+        roll_rad: 横滚角,单位弧度
+        pitch_rad: 俯仰角,单位弧度
+        yaw_rad: 航向角,单位弧度
+
+    返回:
+        (Rx, Ry, Rz): 三个基础旋转矩阵
+    """
+    # 绕X轴旋转(roll)
+    Rx = np.array([
+        [1, 0, 0],
+        [0, np.cos(roll_rad), -np.sin(roll_rad)],
+        [0, np.sin(roll_rad), np.cos(roll_rad)]
+    ])
+
+    # 绕Y轴旋转(pitch)
+    Ry = np.array([
+        [np.cos(pitch_rad), 0, np.sin(pitch_rad)],
+        [0, 1, 0],
+        [-np.sin(pitch_rad), 0, np.cos(pitch_rad)]
+    ])
+
+    # 绕Z轴旋转(yaw)
+    Rz = np.array([
+        [np.cos(yaw_rad), -np.sin(yaw_rad), 0],
+        [np.sin(yaw_rad), np.cos(yaw_rad), 0],
+        [0, 0, 1]
+    ])
+
+    return Rx, Ry, Rz
+
+
+def _euler_to_rotation_matrix_by_order(roll: float, pitch: float, yaw: float, order: str) -> np.ndarray:
+    """
+    根据order参数生成对应旋转顺序的旋转矩阵
+
+    order表示从右往左读矩阵乘法的顺序:
+    - 'ZYX': Rx @ Ry @ Rz (先绕Z轴，再绕Y轴，最后绕X轴) - 与v0.1.2相同
+    - 'XYZ': Rz @ Ry @ Rx (先绕X轴，再绕Y轴，最后绕Z轴)
+
+    参数:
+        roll: 横滚角,单位度
+        pitch: 俯仰角,单位度
+        yaw: 航向角,单位度
+        order: 旋转顺序,'XYZ', 'XZY', 'YXZ', 'YZX', 'ZXY', 'ZYX'
+
+    返回:
+        旋转矩阵,shape (3, 3)
+    """
+    order = _normalize_order(order)
+
+    roll_rad = np.deg2rad(roll)
+    pitch_rad = np.deg2rad(pitch)
+    yaw_rad = np.deg2rad(yaw)
+
+    Rx, Ry, Rz = _get_basic_rotation_matrices(roll_rad, pitch_rad, yaw_rad)
+
+    # 根据order组合旋转矩阵
+    # order表示从右往左读的顺序，如ZYX表示从右往左是Z-Y-X，即 Rx @ Ry @ Rz
+    rotation_map = {
+        'XYZ': Rz @ Ry @ Rx,  # 从右往左读: X-Y-Z
+        'XZY': Ry @ Rz @ Rx,  # 从右往左读: X-Z-Y
+        'YXZ': Rz @ Rx @ Ry,  # 从右往左读: Y-X-Z
+        'YZX': Rx @ Rz @ Ry,  # 从右往左读: Y-Z-X
+        'ZXY': Ry @ Rx @ Rz,  # 从右往左读: Z-X-Y
+        'ZYX': Rx @ Ry @ Rz,  # 从右往左读: Z-Y-X (与v0.1.2相同)
+    }
+
+    return rotation_map[order]
+
+
+def _rotation_matrix_to_euler_by_order(R: np.ndarray, order: str) -> Tuple[float, float, float]:
+    """
+    根据order参数从旋转矩阵提取对应顺序的欧拉角
+
+    参数:
+        R: 旋转矩阵,shape (3, 3)
+        order: 旋转顺序,'XYZ', 'XZY', 'YXZ', 'YZX', 'ZXY', 'ZYX'
+
+    返回:
+        (roll, pitch, yaw): 欧拉角三元组,单位度,范围[-180, 180]
+    """
+    order = _normalize_order(order)
+
+    if order == 'ZYX':
+        # R = Rx @ Ry @ Rz (与v0.1.2完全相同的提取公式)
+        sy = np.sqrt(R[0, 0]**2 + R[0, 1]**2)
+        singular = sy < 1e-6
+
+        if not singular:
+            roll = np.arctan2(-R[1, 2], R[2, 2])
+            pitch = np.arctan2(R[0, 2], sy)
+            yaw = np.arctan2(-R[0, 1], R[0, 0])
+        else:
+            roll = np.arctan2(R[2, 1], R[1, 1])
+            pitch = np.arctan2(R[0, 2], sy)
+            yaw = 0
+
+    elif order == 'XYZ':
+        # R = Rz @ Ry @ Rx
+        sin_pitch = -R[2, 0]
+        cos_pitch = np.sqrt(R[0, 0]**2 + R[1, 0]**2)
+
+        if cos_pitch < 1e-6:  # 万向锁
+            pitch = np.arctan2(sin_pitch, cos_pitch)
+            if sin_pitch > 0:
+                yaw = np.arctan2(-R[0, 1], R[1, 1])
+                roll = 0
+            else:
+                yaw = np.arctan2(R[0, 1], R[1, 1])
+                roll = 0
+        else:
+            pitch = np.arctan2(sin_pitch, cos_pitch)
+            roll = np.arctan2(R[2, 1], R[2, 2])
+            yaw = np.arctan2(R[1, 0], R[0, 0])
+
+    elif order == 'XZY':
+        # R = Ry @ Rz @ Rx
+        sin_yaw = R[1, 0]
+        cos_yaw = np.sqrt(R[0, 0]**2 + R[2, 0]**2)
+
+        if cos_yaw < 1e-6:  # 万向锁
+            yaw = np.arctan2(sin_yaw, cos_yaw)
+            if sin_yaw > 0:
+                roll = np.arctan2(R[0, 2], R[0, 0])
+                pitch = 0
+            else:
+                roll = np.arctan2(-R[0, 2], R[0, 0])
+                pitch = 0
+        else:
+            yaw = np.arctan2(sin_yaw, cos_yaw)
+            roll = np.arctan2(-R[1, 2], R[1, 1])
+            pitch = np.arctan2(-R[2, 0], R[0, 0])
+
+    elif order == 'YXZ':
+        # R = Rz @ Rx @ Ry
+        sin_roll = R[2, 1]
+        cos_roll = np.sqrt(R[0, 1]**2 + R[1, 1]**2)
+
+        if cos_roll < 1e-6:  # 万向锁
+            roll = np.arctan2(sin_roll, cos_roll)
+            if sin_roll > 0:
+                yaw = np.arctan2(R[0, 2], R[0, 0])
+                pitch = 0
+            else:
+                yaw = np.arctan2(-R[0, 2], R[0, 0])
+                pitch = 0
+        else:
+            roll = np.arctan2(sin_roll, cos_roll)
+            pitch = np.arctan2(-R[2, 0], R[2, 2])
+            yaw = np.arctan2(-R[0, 1], R[1, 1])
+
+    elif order == 'YZX':
+        # R = Rx @ Rz @ Ry
+        sin_yaw = -R[0, 1]
+        cos_yaw = np.sqrt(R[1, 1]**2 + R[2, 1]**2)
+
+        if cos_yaw < 1e-6:  # 万向锁
+            yaw = np.arctan2(sin_yaw, cos_yaw)
+            if sin_yaw > 0:
+                pitch = np.arctan2(-R[2, 0], R[2, 2])
+                roll = 0
+            else:
+                pitch = np.arctan2(R[2, 0], R[2, 2])
+                roll = 0
+        else:
+            yaw = np.arctan2(sin_yaw, cos_yaw)
+            roll = np.arctan2(R[2, 1], R[1, 1])
+            pitch = np.arctan2(R[0, 2], R[0, 0])
+
+    elif order == 'ZXY':
+        # R = Ry @ Rx @ Rz
+        sin_roll = -R[1, 2]
+        cos_roll = np.sqrt(R[0, 2]**2 + R[2, 2]**2)
+
+        if cos_roll < 1e-6:  # 万向锁
+            roll = np.arctan2(sin_roll, cos_roll)
+            if sin_roll > 0:
+                pitch = np.arctan2(-R[0, 1], R[0, 0])
+                yaw = 0
+            else:
+                pitch = np.arctan2(R[0, 1], R[0, 0])
+                yaw = 0
+        else:
+            roll = np.arctan2(sin_roll, cos_roll)
+            pitch = np.arctan2(R[0, 2], R[2, 2])
+            yaw = np.arctan2(R[1, 0], R[1, 1])
+
+    # 转换为度并归一化
+    roll_deg = normalize_angle(np.rad2deg(roll))
+    pitch_deg = normalize_angle(np.rad2deg(pitch))
+    yaw_deg = normalize_angle(np.rad2deg(yaw))
+
+    return roll_deg, pitch_deg, yaw_deg
+
+
+# ==================== 标准欧拉角(支持order参数) ====================
+
+def standard_euler_to_rotation_matrix(roll: float, pitch: float, yaw: float, order: str = 'ZYX') -> np.ndarray:
+    """
+    标准欧拉角转旋转矩阵(支持多种旋转顺序)
+
+    默认order='ZYX'：R = Rx @ Ry @ Rz (先绕Z轴，再绕Y轴，最后绕X轴)
+
+    参数:
+        roll: 横滚角,单位度
+        pitch: 俯仰角,单位度
+        yaw: 航向角,单位度
+        order: 旋转顺序,默认'ZYX',支持 'XYZ', 'XZY', 'YXZ', 'YZX', 'ZXY', 'ZYX'（不区分大小写）
+
+    返回:
+        旋转矩阵,shape (3, 3)
+    """
+    order = _normalize_order(order)
+    return _euler_to_rotation_matrix_by_order(roll, pitch, yaw, order)
+
+
+def rotation_matrix_to_standard_euler(R: np.ndarray, order: str = 'ZYX') -> Tuple[float, float, float]:
+    """
+    旋转矩阵转标准欧拉角(支持多种旋转顺序)
+
+    参数:
+        R: 旋转矩阵,shape (3, 3)
+        order: 旋转顺序,默认'ZYX',支持 'XYZ', 'XZY', 'YXZ', 'YZX', 'ZXY', 'ZYX'（不区分大小写）
+
+    返回:
+        (roll, pitch, yaw): 欧拉角三元组,单位度,范围[-180, 180]
+    """
+    order = _normalize_order(order)
+    return _rotation_matrix_to_euler_by_order(R, order)
+
+
+# ==================== 旋转矩阵与四元数转换 ====================
+
+def rotation_matrix_to_quaternion(R: np.ndarray) -> np.ndarray:
+    """
+    将旋转矩阵转换为四元数 [x, y, z, w]
+
+    参数:
+        R: 旋转矩阵,shape (3, 3)
+
+    返回:
+        四元数 [x, y, z, w],shape (4,)
+    """
+    trace = np.trace(R)
+
+    if trace > 0:
+        s = 0.5 / np.sqrt(trace + 1.0)
+        w = 0.25 / s
+        x = (R[2, 1] - R[1, 2]) * s
+        y = (R[0, 2] - R[2, 0]) * s
+        z = (R[1, 0] - R[0, 1]) * s
+    elif R[0, 0] > R[1, 1] and R[0, 0] > R[2, 2]:
+        s = 2.0 * np.sqrt(1.0 + R[0, 0] - R[1, 1] - R[2, 2])
+        w = (R[2, 1] - R[1, 2]) / s
+        x = 0.25 * s
+        y = (R[0, 1] + R[1, 0]) / s
+        z = (R[0, 2] + R[2, 0]) / s
+    elif R[1, 1] > R[2, 2]:
+        s = 2.0 * np.sqrt(1.0 + R[1, 1] - R[0, 0] - R[2, 2])
+        w = (R[0, 2] - R[2, 0]) / s
+        x = (R[0, 1] + R[1, 0]) / s
+        y = 0.25 * s
+        z = (R[1, 2] + R[2, 1]) / s
+    else:
+        s = 2.0 * np.sqrt(1.0 + R[2, 2] - R[0, 0] - R[1, 1])
+        w = (R[1, 0] - R[0, 1]) / s
+        x = (R[0, 2] + R[2, 0]) / s
+        y = (R[1, 2] + R[2, 1]) / s
+        z = 0.25 * s
+
+    quaternion = np.array([x, y, z, w])
+    # 归一化
+    return quaternion / np.linalg.norm(quaternion)
+
+
+def quaternion_to_rotation_matrix(q: Union[list, np.ndarray]) -> np.ndarray:
+    """
+    将四元数转换为旋转矩阵
+
+    参数:
+        q: 四元数 [x, y, z, w],shape (4,)
+
+    返回:
+        旋转矩阵,shape (3, 3)
+    """
+    q = np.array(q, dtype=float)
+    # 归一化
+    q = q / np.linalg.norm(q)
+
+    x, y, z, w = q
+
+    R = np.array([
+        [1 - 2*(y**2 + z**2), 2*(x*y - w*z), 2*(x*z + w*y)],
+        [2*(x*y + w*z), 1 - 2*(x**2 + z**2), 2*(y*z - w*x)],
+        [2*(x*z - w*y), 2*(y*z + w*x), 1 - 2*(x**2 + y**2)]
+    ])
+
+    return R
+
+
+# ==================== 旋转矩阵与角轴转换 ====================
+
+def rotation_matrix_to_axis_angle(R: np.ndarray) -> Tuple[np.ndarray, float]:
+    """
+    将旋转矩阵转换为角轴表示
+
+    参数:
+        R: 旋转矩阵,shape (3, 3)
+
+    返回:
+        axis: 旋转轴单位向量,shape (3,)
+        angle: 旋转角度,单位弧度
+    """
+    # 计算旋转角度
+    trace = np.trace(R)
+    angle = np.arccos(np.clip((trace - 1) / 2, -1, 1))
+
+    # 处理特殊情况
+    if np.abs(angle) < 1e-10:
+        # 无旋转
+        return np.array([1.0, 0.0, 0.0]), 0.0
+    elif np.abs(angle - np.pi) < 1e-10:
+        # 180度旋转
+        # 找到对角线最大元素对应的轴
+        diag = np.diag(R)
+        k = np.argmax(diag)
+        axis = np.zeros(3)
+        axis[k] = np.sqrt((R[k, k] + 1) / 2)
+        if k == 0:
+            axis[1] = R[0, 1] / (2 * axis[0])
+            axis[2] = R[0, 2] / (2 * axis[0])
+        elif k == 1:
+            axis[0] = R[1, 0] / (2 * axis[1])
+            axis[2] = R[1, 2] / (2 * axis[1])
+        else:
+            axis[0] = R[2, 0] / (2 * axis[2])
+            axis[1] = R[2, 1] / (2 * axis[2])
+        return axis, angle
+    else:
+        # 一般情况
+        axis = np.array([
+            R[2, 1] - R[1, 2],
+            R[0, 2] - R[2, 0],
+            R[1, 0] - R[0, 1]
+        ])
+        axis = axis / (2 * np.sin(angle))
+        return axis, angle
+
+
+def axis_angle_to_rotation_matrix(axis: np.ndarray, angle: float) -> np.ndarray:
+    """
+    将角轴表示转换为旋转矩阵(Rodrigues公式)
+
+    参数:
+        axis: 旋转轴单位向量,shape (3,)
+        angle: 旋转角度,单位弧度
+
+    返回:
+        旋转矩阵,shape (3, 3)
+    """
+    # 归一化旋转轴
+    axis = np.array(axis, dtype=float)
+    axis = axis / np.linalg.norm(axis)
+
+    # Rodrigues公式
+    K = np.array([
+        [0, -axis[2], axis[1]],
+        [axis[2], 0, -axis[0]],
+        [-axis[1], axis[0], 0]
+    ])
+
+    R = np.eye(3) + np.sin(angle) * K + (1 - np.cos(angle)) * (K @ K)
+    return R
+
+
+# ==================== 标准欧拉角转换函数(支持order) ====================
+
+def standard_euler_to_quaternion(roll: float, pitch: float, yaw: float, order: str = 'ZYX') -> np.ndarray:
+    """
+    标准欧拉角转四元数
+
+    参数:
+        roll: 横滚角,单位度
+        pitch: 俯仰角,单位度
+        yaw: 航向角,单位度
+        order: 旋转顺序,默认'ZYX'
+
+    返回:
+        四元数 [x, y, z, w],shape (4,)
+    """
+    R = standard_euler_to_rotation_matrix(roll, pitch, yaw, order)
+    return rotation_matrix_to_quaternion(R)
+
+
+def quaternion_to_standard_euler(q: Union[list, np.ndarray], order: str = 'ZYX') -> Tuple[float, float, float]:
+    """
+    四元数转标准欧拉角
+
+    参数:
+        q: 四元数 [x, y, z, w],shape (4,)
+        order: 旋转顺序,默认'ZYX'
+
+    返回:
+        (roll, pitch, yaw): 欧拉角三元组,单位度,范围[-180, 180]
+    """
+    R = quaternion_to_rotation_matrix(q)
+    return rotation_matrix_to_standard_euler(R, order)
+
+
+def standard_euler_to_axis_angle(roll: float, pitch: float, yaw: float, order: str = 'ZYX') -> Tuple[np.ndarray, float]:
+    """
+    标准欧拉角转角轴表示
+
+    参数:
+        roll: 横滚角,单位度
+        pitch: 俯仰角,单位度
+        yaw: 航向角,单位度
+        order: 旋转顺序,默认'ZYX'
+
+    返回:
+        axis: 旋转轴单位向量,shape (3,)
+        angle: 旋转角度,单位弧度
+    """
+    R = standard_euler_to_rotation_matrix(roll, pitch, yaw, order)
+    return rotation_matrix_to_axis_angle(R)
+
+
+def axis_angle_to_standard_euler(axis: np.ndarray, angle: float, order: str = 'ZYX') -> Tuple[float, float, float]:
+    """
+    角轴表示转标准欧拉角
+
+    参数:
+        axis: 旋转轴单位向量,shape (3,)
+        angle: 旋转角度,单位弧度
+        order: 旋转顺序,默认'ZYX'
+
+    返回:
+        (roll, pitch, yaw): 欧拉角三元组,单位度,范围[-180, 180]
+    """
+    R = axis_angle_to_rotation_matrix(axis, angle)
+    return rotation_matrix_to_standard_euler(R, order)
+
+
+# ==================== 外参类(支持order) ====================
+
+class ExtrinsicParam:
+    """
+    外参类,存储旋转矩阵和平移向量
+
+    初始化方式:
+        1. ExtrinsicParam(euler=[roll, pitch, yaw], translation=[x, y, z], euler_order='ZYX')
+        2. ExtrinsicParam(rotation_matrix=R, translation=[x, y, z], euler_order='ZYX')
+        3. ExtrinsicParam(axis_angle=(axis, angle), translation=[x, y, z], euler_order='ZYX')
+        4. ExtrinsicParam(quaternion=[x, y, z, w], translation=[x, y, z], euler_order='ZYX')
+        5. ExtrinsicParam.from_homogeneous_matrix(T, euler_order='ZYX')  # 从4x4矩阵创建
+
+    属性:
+        rotation_matrix: 旋转矩阵,shape (3, 3)
+        translation: 平移向量 [x, y, z],单位米
+        euler_order: 欧拉角旋转顺序,默认'ZYX'
+        standard_euler: 标准欧拉角 [roll, pitch, yaw],单位度,范围[-180, 180]
+        axis: 角轴旋转轴,shape (3,)
+        angle: 角轴旋转角,单位弧度
+        quaternion: 四元数 [x, y, z, w],shape (4,)
+    """
+
+    def __init__(self,
+                 euler: Optional[Union[list, np.ndarray]] = None,
+                 translation: Optional[Union[list, np.ndarray]] = None,
+                 rotation_matrix: Optional[np.ndarray] = None,
+                 axis_angle: Optional[Tuple[np.ndarray, float]] = None,
+                 quaternion: Optional[Union[list, np.ndarray]] = None,
+                 euler_order: str = 'ZYX'):
+        """
+        初始化外参
+
+        参数:
+            euler: 欧拉角 [roll, pitch, yaw],单位度
+            translation: 平移向量 [x, y, z],单位米
+            rotation_matrix: 旋转矩阵,shape (3, 3)
+            axis_angle: 角轴表示 (axis, angle),axis为单位向量,angle单位弧度
+            quaternion: 四元数 [x, y, z, w],shape (4,)
+            euler_order: 欧拉角旋转顺序,默认'ZYX'(与v0.1.2相同)
+        """
+        # 存储欧拉角顺序
+        self.euler_order = _normalize_order(euler_order)
+
+        if euler is not None:
+            self.rotation_matrix = standard_euler_to_rotation_matrix(*euler, self.euler_order)
+        elif rotation_matrix is not None:
+            self.rotation_matrix = np.array(rotation_matrix, dtype=float)
+        elif axis_angle is not None:
+            axis, angle = axis_angle
+            self.rotation_matrix = axis_angle_to_rotation_matrix(axis, angle)
+        elif quaternion is not None:
+            self.rotation_matrix = quaternion_to_rotation_matrix(quaternion)
+        else:
+            self.rotation_matrix = np.eye(3)
+
+        # 计算标准欧拉角表示（使用存储的euler_order）
+        self.standard_euler = np.array(rotation_matrix_to_standard_euler(self.rotation_matrix, self.euler_order))
+
+        # 计算角轴表示
+        self.axis, self.angle = rotation_matrix_to_axis_angle(self.rotation_matrix)
+
+        # 计算四元数表示 [x, y, z, w]
+        self.quaternion = rotation_matrix_to_quaternion(self.rotation_matrix)
+
+        self.translation = np.array(translation, dtype=float) if translation is not None else np.zeros(3)
+
+    @classmethod
+    def from_homogeneous_matrix(cls, T: np.ndarray, euler_order: str = 'ZYX') -> 'ExtrinsicParam':
+        """
+        从4x4齐次变换矩阵创建外参对象
+
+        参数:
+            T: 4x4齐次变换矩阵,格式为:
+               [[R11, R12, R13, tx],
+                [R21, R22, R23, ty],
+                [R31, R32, R33, tz],
+                [  0,   0,   0,  1]]
+            euler_order: 欧拉角旋转顺序,默认'ZYX'
+
+        返回:
+            ExtrinsicParam对象
+        """
+        T = np.array(T, dtype=float)
+        if T.shape != (4, 4):
+            raise ValueError(f"齐次矩阵必须是4x4矩阵,当前shape: {T.shape}")
+
+        # 验证最后一行是否为 [0, 0, 0, 1]
+        if not np.allclose(T[3, :], [0, 0, 0, 1]):
+            raise ValueError(f"齐次矩阵最后一行必须是[0, 0, 0, 1],当前为: {T[3, :]}")
+
+        rotation_matrix = T[:3, :3]
+        translation = T[:3, 3]
+
+        return cls(rotation_matrix=rotation_matrix, translation=translation, euler_order=euler_order)
+
+    def __matmul__(self, other: 'ExtrinsicParam') -> 'ExtrinsicParam':
+        """
+        外参复合运算（@ 运算符，推荐使用）
+
+        齐次变换复合: T_result = T_left @ T_right
+        对应: R_result = R_left @ R_right
+             t_result = R_left @ t_right + t_left
+
+        参数:
+            other: 右侧外参
+
+        返回:
+            复合后的外参（使用左侧外参的euler_order）
+
+        示例:
+            >>> ext1 = ExtrinsicParam(euler=[10, 20, 30], translation=[1, 0, 0])
+            >>> ext2 = ExtrinsicParam(euler=[5, 10, 15], translation=[0, 1, 0])
+            >>> ext_combined = ext1 @ ext2
+        """
+        R_combined = self.rotation_matrix @ other.rotation_matrix
+        t_combined = self.rotation_matrix @ other.translation + self.translation
+        return ExtrinsicParam(rotation_matrix=R_combined, translation=t_combined, euler_order=self.euler_order)
+
+    def inverse(self) -> 'ExtrinsicParam':
+        """
+        计算外参的逆变换
+
+        对于齐次变换矩阵:
+            T = [ R  t ]
+                [ 0  1 ]
+
+        其逆矩阵为:
+            T^-1 = [ R^T  -R^T·t ]
+                   [ 0      1     ]
+
+        返回:
+            逆变换的外参对象（保持相同的euler_order）
+
+        示例:
+            >>> ext = ExtrinsicParam(euler=[30, 45, 60], translation=[1, 2, 3])
+            >>> ext_inv = ext.inverse()
+            >>> result = ext @ ext_inv  # 应该接近单位变换
+        """
+        inv_rotation = self.rotation_matrix.T  # R^T
+        inv_translation = -inv_rotation @ self.translation  # -R^T·t
+        return ExtrinsicParam(rotation_matrix=inv_rotation, translation=inv_translation, euler_order=self.euler_order)
+
+    def transform_point(self, point: Union[list, np.ndarray]) -> np.ndarray:
+        """
+        坐标前向变换: P_out = R * P_in + T
+
+        参数:
+            point: 输入点坐标 [x, y, z]
+
+        返回:
+            变换后的点坐标,shape (3,)
+
+        示例:
+            >>> ext = ExtrinsicParam(euler=[0, 0, 90], translation=[1, 0, 0])
+            >>> point_in = [1, 0, 0]
+            >>> point_out = ext.transform_point(point_in)
+        """
+        point = np.array(point, dtype=float)
+        return self.rotation_matrix @ point + self.translation
+
+    def inverse_transform_point(self, point: Union[list, np.ndarray]) -> np.ndarray:
+        """
+        坐标逆变换: P_in = R^T * (P_out - T)
+
+        参数:
+            point: 输出点坐标 [x', y', z']
+
+        返回:
+            逆变换后的点坐标,shape (3,)
+
+        示例:
+            >>> ext = ExtrinsicParam(euler=[0, 0, 90], translation=[1, 0, 0])
+            >>> point_out = [1, 1, 0]
+            >>> point_in = ext.inverse_transform_point(point_out)
+        """
+        point = np.array(point, dtype=float)
+        return self.rotation_matrix.T @ (point - self.translation)
+
+    def get_homogeneous_matrix(self) -> np.ndarray:
+        """
+        获取4x4齐次变换矩阵
+
+        返回:
+            4x4齐次矩阵:
+            [[R11, R12, R13, tx],
+             [R21, R22, R23, ty],
+             [R31, R32, R33, tz],
+             [  0,   0,   0,  1]]
+
+        示例:
+            >>> ext = ExtrinsicParam(euler=[30, 45, 60], translation=[1, 2, 3])
+            >>> T = ext.get_homogeneous_matrix()
+            >>> print(T.shape)  # (4, 4)
+        """
+        T = np.eye(4)
+        T[:3, :3] = self.rotation_matrix
+        T[:3, 3] = self.translation
+        return T
+
+    def get_axis_angle(self) -> Tuple[np.ndarray, float]:
+        """
+        获取角轴表示
+
+        返回:
+            axis: 旋转轴单位向量,shape (3,)
+            angle: 旋转角度,单位弧度
+
+        示例:
+            >>> ext = ExtrinsicParam(euler=[30, 0, 0], translation=[0, 0, 0])
+            >>> axis, angle = ext.get_axis_angle()
+            >>> print(f"旋转轴: {axis}, 旋转角: {np.rad2deg(angle)}度")
+        """
+        return self.axis, self.angle
+
+    def get_axis_angle_degrees(self) -> Tuple[np.ndarray, float]:
+        """
+        获取角轴表示(角度单位为度)
+
+        返回:
+            axis: 旋转轴单位向量,shape (3,)
+            angle: 旋转角度,单位度,范围[-180, 180]
+
+        示例:
+            >>> ext = ExtrinsicParam(euler=[30, 0, 0], translation=[0, 0, 0])
+            >>> axis, angle = ext.get_axis_angle_degrees()
+            >>> print(f"旋转轴: {axis}, 旋转角: {angle}度")
+        """
+        angle_deg = np.rad2deg(self.angle)
+        angle_deg = normalize_angle(angle_deg)
+        return self.axis, angle_deg
+
+    def get_quaternion(self) -> np.ndarray:
+        """
+        获取四元数表示 [x, y, z, w]
+
+        返回:
+            四元数 [x, y, z, w],shape (4,)
+
+        示例:
+            >>> ext = ExtrinsicParam(euler=[30, 45, 60], translation=[0, 0, 0])
+            >>> quat = ext.get_quaternion()
+            >>> print(f"四元数: {quat}")
+        """
+        return self.quaternion
+
+    def get_standard_euler(self, order: Optional[str] = None) -> np.ndarray:
+        """
+        获取标准欧拉角
+
+        参数:
+            order: 旋转顺序,如果为None则使用self.euler_order,否则使用指定的order
+
+        返回:
+            欧拉角 [roll, pitch, yaw],单位度,范围[-180, 180]
+
+        示例:
+            >>> ext = ExtrinsicParam(quaternion=[0, 0, 0, 1], translation=[0, 0, 0])
+            >>> euler = ext.get_standard_euler()
+            >>> print(f"标准欧拉角(RPY): {euler}")
+            >>> euler_xyz = ext.get_standard_euler(order='XYZ')
+            >>> print(f"标准欧拉角(XYZ顺序): {euler_xyz}")
+        """
+        if order is None:
+            return self.standard_euler
+        else:
+            return np.array(rotation_matrix_to_standard_euler(self.rotation_matrix, order))
+
+    def __repr__(self) -> str:
+        """
+        字符串表示
+
+        返回:
+            对象的字符串描述
+        """
+        return (f"ExtrinsicParam(\n"
+                f"  euler_order='{self.euler_order}',\n"
+                f"  standard_euler(RPY)={self.standard_euler},\n"
+                f"  translation={self.translation}\n"
+                f")")

transform_base-0.0.2/transform_base.egg-info/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: transform-base
+Version: 0.0.2
+Summary: 欧拉角、旋转矩阵、四元数、角轴及外参变换基础库，支持多种旋转顺序
+License-Expression: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.20
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+
+# transform-base
+
+欧拉角、旋转矩阵、四元数、角轴及外参变换基础库，支持多种旋转顺序（XYZ/XZY/YXZ/YZX/ZXY/ZYX）。
+
+## 安装
+
+```bash
+pip install transform-base
+```
+
+## 功能特性
+
+- **角度归一化**：`normalize_angle` 将角度归一化到 [-180, 180]
+- **欧拉角 ↔ 旋转矩阵**：支持 6 种旋转顺序（order），默认 ZYX
+- **旋转矩阵 ↔ 四元数**：`[x, y, z, w]` 格式
+- **旋转矩阵 ↔ 角轴**：Rodrigues 公式
+- **外参类 ExtrinsicParam**：欧拉/旋转矩阵/四元数/角轴多种初始化，齐次矩阵、点变换、复合与逆
+
+## 快速开始
+
+```python
+from transform_base import (
+    normalize_angle,
+    standard_euler_to_rotation_matrix,
+    rotation_matrix_to_standard_euler,
+    ExtrinsicParam,
+)
+
+# 欧拉角 -> 旋转矩阵 -> 欧拉角
+euler = [10.0, 20.0, 30.0]  # roll, pitch, yaw (度)
+R = standard_euler_to_rotation_matrix(*euler, order="ZYX")
+euler_back = rotation_matrix_to_standard_euler(R, order="ZYX")
+
+# 外参：欧拉角 + 平移
+ext = ExtrinsicParam(euler=[0, 0, 90], translation=[1, 0, 0])
+p_out = ext.transform_point([1, 0, 0])
+ext_inv = ext.inverse()
+```
+
+## 依赖
+
+- Python >= 3.10
+- numpy >= 1.20
+
+## License
+
+MIT

transform_base-0.0.2/transform_base.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+MANIFEST.in
+README.md
+pyproject.toml
+transform_base/__init__.py
+transform_base/transform.py
+transform_base.egg-info/PKG-INFO
+transform_base.egg-info/SOURCES.txt
+transform_base.egg-info/dependency_links.txt
+transform_base.egg-info/requires.txt
+transform_base.egg-info/top_level.txt

transform_base-0.0.2/transform_base.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

transform_base-0.0.2/transform_base.egg-info/requires.txt

@@ -0,0 +1,6 @@
+numpy>=1.20
+
+[dev]
+pytest
+build
+twine

transform_base-0.0.2/transform_base.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+dist
+transform_base