transform-base 0.0.2__tar.gz → 0.0.3__tar.gz

transform_base-0.0.3/PKG-INFO

@@ -0,0 +1,93 @@
+Metadata-Version: 2.4
+Name: transform-base
+Version: 0.0.3
+Summary: 欧拉角、旋转矩阵、四元数、角轴及多格式矩阵计算基础库
+License-Expression: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.20
+Requires-Dist: PyYAML>=6.0
+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），并提供多输入格式解析、矩阵乘法/求逆/比较/方程求解的通用 API。
+
+## 安装
+
+```bash
+pip install transform-base
+```
+
+## 功能特性
+
+- **角度归一化**：`normalize_angle` 将角度归一化到 [-180, 180]
+- **欧拉角 ↔ 旋转矩阵**：支持 6 种旋转顺序（order），默认 ZYX
+- **旋转矩阵 ↔ 四元数**：`[x, y, z, w]` 格式
+- **旋转矩阵 ↔ 角轴**：Rodrigues 公式
+- **外参类 ExtrinsicParam**：欧拉/旋转矩阵/四元数/角轴多种初始化，齐次矩阵、点变换、复合与逆
+- **多格式输入解析**：支持旋转矩阵+平移、四元数+平移、欧拉角+平移、4x4 齐次矩阵、JSON/proto/flex 四元数格式
+- **矩阵计算**：支持统一格式输出、矩阵比较、`A = C @ B` / `A = B @ D` 求解
+
+## 快速开始
+
+```python
+from transform_base import (
+    normalize_angle,
+    standard_euler_to_rotation_matrix,
+    rotation_matrix_to_standard_euler,
+    ExtrinsicParam,
+    parse_transform_input,
+    transform_from_input,
+    transform_to_all_formats,
+    compare_transforms,
+    solve_transform_equations,
+)
+
+# 欧拉角 -> 旋转矩阵 -> 欧拉角
+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()
+
+# 多格式输入 -> 外参
+raw = '''
+"translation": {"x": 1, "y": 2, "z": 3},
+"rotation": {"qx": 0.0, "qy": 0.0, "qz": 0.70710678, "qw": 0.70710678}
+'''
+parsed = parse_transform_input(raw, format_name="json_rotation_translation_qxyzw")
+ext_from_input = transform_from_input(raw, format_name="json_rotation_translation_qxyzw")
+all_formats = transform_to_all_formats(ext_from_input)
+
+# 比较与方程求解
+cmp_result = compare_transforms(ext, ext_inv.inverse())
+solve_result = solve_transform_equations(ext, ext_from_input)
+```
+
+## 依赖
+
+- Python >= 3.10
+- numpy >= 1.20
+- PyYAML >= 6.0
+
+## 支持的输入格式
+
+- `rotation_matrix_translation`
+- `quaternion_translation`
+- `euler_degree_translation`
+- `homogeneous_matrix_4x4`
+- `json_rotation_translation`
+- `json_rotation_translation_qxyzw`
+- `translation_rotation_quaternion`
+- `rotation_translation_flex`
+
+## License
+
+MIT

transform_base-0.0.3/README.md

@@ -0,0 +1,79 @@
+# transform-base
+
+欧拉角、旋转矩阵、四元数、角轴及外参变换基础库，支持多种旋转顺序（XYZ/XZY/YXZ/YZX/ZXY/ZYX），并提供多输入格式解析、矩阵乘法/求逆/比较/方程求解的通用 API。
+
+## 安装
+
+```bash
+pip install transform-base
+```
+
+## 功能特性
+
+- **角度归一化**：`normalize_angle` 将角度归一化到 [-180, 180]
+- **欧拉角 ↔ 旋转矩阵**：支持 6 种旋转顺序（order），默认 ZYX
+- **旋转矩阵 ↔ 四元数**：`[x, y, z, w]` 格式
+- **旋转矩阵 ↔ 角轴**：Rodrigues 公式
+- **外参类 ExtrinsicParam**：欧拉/旋转矩阵/四元数/角轴多种初始化，齐次矩阵、点变换、复合与逆
+- **多格式输入解析**：支持旋转矩阵+平移、四元数+平移、欧拉角+平移、4x4 齐次矩阵、JSON/proto/flex 四元数格式
+- **矩阵计算**：支持统一格式输出、矩阵比较、`A = C @ B` / `A = B @ D` 求解
+
+## 快速开始
+
+```python
+from transform_base import (
+    normalize_angle,
+    standard_euler_to_rotation_matrix,
+    rotation_matrix_to_standard_euler,
+    ExtrinsicParam,
+    parse_transform_input,
+    transform_from_input,
+    transform_to_all_formats,
+    compare_transforms,
+    solve_transform_equations,
+)
+
+# 欧拉角 -> 旋转矩阵 -> 欧拉角
+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()
+
+# 多格式输入 -> 外参
+raw = '''
+"translation": {"x": 1, "y": 2, "z": 3},
+"rotation": {"qx": 0.0, "qy": 0.0, "qz": 0.70710678, "qw": 0.70710678}
+'''
+parsed = parse_transform_input(raw, format_name="json_rotation_translation_qxyzw")
+ext_from_input = transform_from_input(raw, format_name="json_rotation_translation_qxyzw")
+all_formats = transform_to_all_formats(ext_from_input)
+
+# 比较与方程求解
+cmp_result = compare_transforms(ext, ext_inv.inverse())
+solve_result = solve_transform_equations(ext, ext_from_input)
+```
+
+## 依赖
+
+- Python >= 3.10
+- numpy >= 1.20
+- PyYAML >= 6.0
+
+## 支持的输入格式
+
+- `rotation_matrix_translation`
+- `quaternion_translation`
+- `euler_degree_translation`
+- `homogeneous_matrix_4x4`
+- `json_rotation_translation`
+- `json_rotation_translation_qxyzw`
+- `translation_rotation_quaternion`
+- `rotation_translation_flex`
+
+## License
+
+MIT

{transform_base-0.0.2 → transform_base-0.0.3}/pyproject.toml

@@ -4,13 +4,14 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "transform-base"
-version = "0.0.2"
-description = "欧拉角、旋转矩阵、四元数、角轴及外参变换基础库，支持多种旋转顺序"
+version = "0.0.3"
+description = "欧拉角、旋转矩阵、四元数、角轴及多格式矩阵计算基础库"
 readme = "README.md"
 license = "MIT"
 requires-python = ">=3.10"
 dependencies = [
     "numpy>=1.20",
+    "PyYAML>=6.0",
 ]
 
 [project.optional-dependencies]

{transform_base-0.0.2 → transform_base-0.0.3}/transform_base/__init__.py

@@ -13,6 +13,16 @@ from transform_base.transform import (
     axis_angle_to_standard_euler,
     ExtrinsicParam,
 )
+from transform_base.matrix_ops import (
+    SUPPORTED_INPUT_FORMATS,
+    compare_transforms,
+    detect_transform_input_format,
+    parse_transform_input,
+    solve_transform_equations,
+    transform_from_data,
+    transform_from_input,
+    transform_to_all_formats,
+)
 
 __all__ = [
     "normalize_angle",
@@ -27,4 +37,12 @@ __all__ = [
     "standard_euler_to_axis_angle",
     "axis_angle_to_standard_euler",
     "ExtrinsicParam",
+    "SUPPORTED_INPUT_FORMATS",
+    "detect_transform_input_format",
+    "parse_transform_input",
+    "transform_from_data",
+    "transform_from_input",
+    "transform_to_all_formats",
+    "compare_transforms",
+    "solve_transform_equations",
 ]

transform_base-0.0.3/transform_base/matrix_ops.py

@@ -0,0 +1,534 @@
+from __future__ import annotations
+
+import json
+import re
+from typing import Any, Callable, Dict, Iterable, Tuple
+
+import numpy as np
+import yaml
+
+from .transform import ExtrinsicParam, normalize_angle
+
+
+SUPPORTED_INPUT_FORMATS: tuple[str, ...] = (
+    "rotation_matrix_translation",
+    "quaternion_translation",
+    "euler_degree_translation",
+    "homogeneous_matrix_4x4",
+    "json_rotation_translation",
+    "json_rotation_translation_qxyzw",
+    "translation_rotation_quaternion",
+    "rotation_translation_flex",
+)
+
+
+_FLOAT_RE = r"([-\d.eE+]+)"
+
+
+def compact_whitespace(text: str) -> str:
+    """Collapse whitespace outside of quoted strings."""
+    result: list[str] = []
+    in_string = False
+    escape = False
+    quote = ""
+    for c in text:
+        if escape:
+            result.append(c)
+            escape = False
+            continue
+        if c == "\\" and in_string:
+            result.append(c)
+            escape = True
+            continue
+        if c in ("'", '"'):
+            if not in_string:
+                in_string = True
+                quote = c
+            elif quote == c:
+                in_string = False
+                quote = ""
+            result.append(c)
+            continue
+        if in_string:
+            result.append(c)
+            continue
+        if c in " \t\r\n":
+            if result and result[-1] != " ":
+                result.append(" ")
+            continue
+        result.append(c)
+    return "".join(result).strip()
+
+
+def _prepare_text(raw: str, filter_mode: bool) -> str:
+    text = (raw or "").strip()
+    if not text:
+        return text
+    return compact_whitespace(text) if filter_mode else text
+
+
+def _coerce_float_list(value: Any, expected_len: int | None, field_name: str) -> list[float]:
+    if not isinstance(value, (list, tuple)):
+        raise ValueError(f"{field_name} must be a list/tuple")
+    out = [float(np.float64(item)) for item in value]
+    if expected_len is not None and len(out) != expected_len:
+        raise ValueError(f"{field_name} must contain {expected_len} values")
+    return out
+
+
+def _coerce_float_matrix(
+    value: Any,
+    rows: int,
+    cols: int,
+    field_name: str,
+) -> list[list[float]]:
+    if not isinstance(value, (list, tuple)) or len(value) != rows:
+        raise ValueError(f"{field_name} must be a {rows}x{cols} matrix")
+    out: list[list[float]] = []
+    for row in value:
+        if not isinstance(row, (list, tuple)) or len(row) != cols:
+            raise ValueError(f"{field_name} must be a {rows}x{cols} matrix")
+        out.append([float(np.float64(item)) for item in row])
+    return out
+
+
+def _find_first(data: Dict[str, Any], names: Iterable[str]) -> Any:
+    for name in names:
+        if name in data:
+            return data[name]
+    return None
+
+
+def _parse_yaml_object(raw: str, filter_mode: bool) -> Dict[str, Any]:
+    candidates: list[str] = []
+    stripped = (raw or "").strip()
+    if stripped:
+        candidates.append(stripped)
+    compacted = _prepare_text(raw, filter_mode)
+    if compacted and compacted not in candidates:
+        candidates.append(compacted)
+    if not candidates:
+        raise ValueError("input is empty")
+
+    last_error: Exception | None = None
+    for text in candidates:
+        try:
+            data = yaml.safe_load(text)
+        except yaml.YAMLError as exc:
+            last_error = exc
+            continue
+        if isinstance(data, dict):
+            return data
+        last_error = ValueError("input root must be a mapping")
+    raise ValueError(f"invalid YAML/JSON input: {last_error}")
+
+
+def _wrap_json_fragment(text: str) -> str:
+    s = text.strip()
+    if not s:
+        return "{}"
+    if s.startswith("{"):
+        return s
+    return "{" + s + "}"
+
+
+def _load_json_object(raw: str, filter_mode: bool) -> Dict[str, Any]:
+    text = _wrap_json_fragment(_prepare_text(raw, filter_mode))
+    try:
+        data = json.loads(text)
+    except json.JSONDecodeError as exc:
+        raise ValueError(f"invalid JSON input: {exc}") from exc
+    if not isinstance(data, dict):
+        raise ValueError("JSON root must be an object")
+    return data
+
+
+def _get_float(d: Dict[str, Any], key: str, default: float = 0.0) -> float:
+    if key not in d or d.get(key) is None:
+        return default
+    try:
+        value = float(np.float64(d[key]))
+    except (TypeError, ValueError) as exc:
+        raise ValueError(f"field {key} is not a valid float") from exc
+    if not np.isfinite(value):
+        raise ValueError(f"field {key} is not finite")
+    return value
+
+
+def _parse_rotation_matrix_translation(raw: str, filter_mode: bool) -> Dict[str, Any]:
+    try:
+        data = _parse_yaml_object(raw, filter_mode)
+        rotation = _find_first(data, ("rotation_matrix", "R", "rotation"))
+        translation = _find_first(data, ("translation", "t"))
+        if rotation is not None and translation is not None:
+            return {
+                "rotation_matrix": _coerce_float_matrix(rotation, 3, 3, "rotation_matrix"),
+                "translation": _coerce_float_list(translation, 3, "translation"),
+            }
+    except ValueError:
+        pass
+
+    row_pattern = re.compile(r"\[\s*([-\d.\s+eE]+)\s*\]")
+    r_match = re.search(r"\bR\s*:\s*", raw, re.IGNORECASE)
+    t_match = re.search(r"\bt\s*:\s*", raw, re.IGNORECASE)
+    if r_match is None or t_match is None or t_match.start() <= r_match.end():
+        raise ValueError("expected YAML/JSON rotation_matrix+translation or R:/t: matrix blocks")
+
+    r_block = raw[r_match.end():t_match.start()].strip()
+    t_block = raw[t_match.end():].strip()
+    r_rows = row_pattern.findall(r_block)
+    t_rows = row_pattern.findall(t_block)
+    if len(r_rows) != 3:
+        raise ValueError("R block must contain 3 rows")
+    rotation_matrix = [[float(np.float64(v)) for v in row.split()] for row in r_rows]
+    if any(len(row) != 3 for row in rotation_matrix):
+        raise ValueError("each R row must contain 3 values")
+    translation = [float(np.float64(v)) for row in t_rows for v in row.split()]
+    if len(translation) != 3:
+        raise ValueError("t block must contain 3 values")
+    return {"rotation_matrix": rotation_matrix, "translation": translation}
+
+
+def _parse_quaternion_translation(raw: str, filter_mode: bool) -> Dict[str, Any]:
+    data = _parse_yaml_object(raw, filter_mode)
+    quaternion = _find_first(data, ("quaternion_xyzw", "quaternion", "quat", "q"))
+    translation = _find_first(data, ("translation", "t"))
+    if quaternion is None or translation is None:
+        raise ValueError("expected quaternion_xyzw/quaternion/quat/q and translation/t")
+    return {
+        "quaternion_xyzw": _coerce_float_list(quaternion, 4, "quaternion_xyzw"),
+        "translation": _coerce_float_list(translation, 3, "translation"),
+    }
+
+
+def _parse_euler_degree_translation(raw: str, filter_mode: bool) -> Dict[str, Any]:
+    data = _parse_yaml_object(raw, filter_mode)
+    euler = _find_first(data, ("euler_degree_xyz", "euler_degree", "euler_deg"))
+    translation = _find_first(data, ("translation", "t"))
+    order = _find_first(data, ("euler_cal_order", "order", "euler_order")) or "ZYX"
+    if euler is None or translation is None:
+        raise ValueError("expected euler_degree_xyz/euler_degree/euler_deg and translation/t")
+    return {
+        "euler_degree_xyz": _coerce_float_list(euler, 3, "euler_degree_xyz"),
+        "translation": _coerce_float_list(translation, 3, "translation"),
+        "euler_cal_order": str(order),
+    }
+
+
+def _parse_homogeneous_matrix_4x4(raw: str, filter_mode: bool) -> Dict[str, Any]:
+    data = _parse_yaml_object(raw, filter_mode)
+    matrix = _find_first(data, ("homogeneous_matrix_4x4", "T", "extrinsic", "pose"))
+    if matrix is None:
+        raise ValueError("expected homogeneous_matrix_4x4/T/extrinsic/pose")
+    return {
+        "homogeneous_matrix_4x4": _coerce_float_matrix(matrix, 4, 4, "homogeneous_matrix_4x4"),
+    }
+
+
+def _translation_from_dict(trans: Dict[str, Any]) -> list[float]:
+    return [_get_float(trans, "x"), _get_float(trans, "y"), _get_float(trans, "z")]
+
+
+def _parse_json_rotation_translation(raw: str, filter_mode: bool) -> Dict[str, Any]:
+    obj = _load_json_object(raw, filter_mode)
+    rotation = obj.get("rotation")
+    translation = obj.get("translation")
+    if not isinstance(rotation, dict) or not isinstance(translation, dict):
+        raise ValueError("expected rotation and translation JSON objects")
+    if any(key in rotation for key in ("qx", "qy", "qz", "qw")):
+        raise ValueError("rotation uses qx/qy/qz/qw; use json_rotation_translation_qxyzw")
+    quat = [
+        _get_float(rotation, "x"),
+        _get_float(rotation, "y"),
+        _get_float(rotation, "z"),
+        _get_float(rotation, "w"),
+    ]
+    return {"quaternion_xyzw": quat, "translation": _translation_from_dict(translation)}
+
+
+def _parse_json_rotation_translation_qxyzw(raw: str, filter_mode: bool) -> Dict[str, Any]:
+    obj = _load_json_object(raw, filter_mode)
+    rotation = obj.get("rotation")
+    translation = obj.get("translation")
+    if not isinstance(rotation, dict) or not isinstance(translation, dict):
+        raise ValueError("expected rotation and translation JSON objects")
+    quat = [
+        _get_float(rotation, "qx"),
+        _get_float(rotation, "qy"),
+        _get_float(rotation, "qz"),
+        _get_float(rotation, "qw"),
+    ]
+    return {"quaternion_xyzw": quat, "translation": _translation_from_dict(translation)}
+
+
+def _extract_proto_translation(text: str) -> list[float] | None:
+    match = re.search(r"translation\s*\{([^}]+)\}", text, re.DOTALL | re.IGNORECASE)
+    if match is None:
+        return None
+    block = match.group(1)
+    x_match = re.search(r"x\s*:\s*" + _FLOAT_RE, block, re.IGNORECASE)
+    y_match = re.search(r"y\s*:\s*" + _FLOAT_RE, block, re.IGNORECASE)
+    z_match = re.search(r"z\s*:\s*" + _FLOAT_RE, block, re.IGNORECASE)
+    if not (x_match and y_match and z_match):
+        return None
+    return [
+        float(np.float64(x_match.group(1))),
+        float(np.float64(y_match.group(1))),
+        float(np.float64(z_match.group(1))),
+    ]
+
+
+def _extract_proto_rotation(text: str) -> list[float] | None:
+    match = re.search(r"rotation\s*\{([^}]+)\}", text, re.DOTALL | re.IGNORECASE)
+    if match is None:
+        return None
+    block = match.group(1)
+    qx_match = re.search(r"qx\s*:\s*" + _FLOAT_RE, block, re.IGNORECASE)
+    qy_match = re.search(r"qy\s*:\s*" + _FLOAT_RE, block, re.IGNORECASE)
+    qz_match = re.search(r"qz\s*:\s*" + _FLOAT_RE, block, re.IGNORECASE)
+    qw_match = re.search(r"qw\s*:\s*" + _FLOAT_RE, block, re.IGNORECASE)
+    if qx_match and qy_match and qz_match and qw_match:
+        return [
+            float(np.float64(qx_match.group(1))),
+            float(np.float64(qy_match.group(1))),
+            float(np.float64(qz_match.group(1))),
+            float(np.float64(qw_match.group(1))),
+        ]
+    w_match = re.search(r"w\s*:\s*" + _FLOAT_RE, block, re.IGNORECASE)
+    x_match = re.search(r"x\s*:\s*" + _FLOAT_RE, block, re.IGNORECASE)
+    y_match = re.search(r"y\s*:\s*" + _FLOAT_RE, block, re.IGNORECASE)
+    z_match = re.search(r"z\s*:\s*" + _FLOAT_RE, block, re.IGNORECASE)
+    if not (w_match and x_match and y_match and z_match):
+        return None
+    return [
+        float(np.float64(x_match.group(1))),
+        float(np.float64(y_match.group(1))),
+        float(np.float64(z_match.group(1))),
+        float(np.float64(w_match.group(1))),
+    ]
+
+
+def _parse_translation_rotation_quaternion(raw: str, filter_mode: bool) -> Dict[str, Any]:
+    text = _prepare_text(raw, filter_mode)
+    translation = _extract_proto_translation(text)
+    rotation = _extract_proto_rotation(text)
+    if translation is None or rotation is None:
+        raise ValueError("expected proto style translation {x,y,z} and rotation {qx,qy,qz,qw}")
+    return {"quaternion_xyzw": rotation, "translation": translation}
+
+
+def _parse_rotation_translation_flex(raw: str, filter_mode: bool) -> Dict[str, Any]:
+    try:
+        obj = _load_json_object(raw, filter_mode)
+        rotation = obj.get("rotation")
+        translation = obj.get("translation")
+        if isinstance(rotation, dict) and isinstance(translation, dict):
+            if any(key in rotation for key in ("qx", "qy", "qz", "qw")):
+                quat = [
+                    _get_float(rotation, "qx"),
+                    _get_float(rotation, "qy"),
+                    _get_float(rotation, "qz"),
+                    _get_float(rotation, "qw"),
+                ]
+            elif any(key in rotation for key in ("w", "x", "y", "z")):
+                quat = [
+                    _get_float(rotation, "x"),
+                    _get_float(rotation, "y"),
+                    _get_float(rotation, "z"),
+                    _get_float(rotation, "w"),
+                ]
+            else:
+                raise ValueError("rotation JSON object uses unsupported keys")
+            return {"quaternion_xyzw": quat, "translation": _translation_from_dict(translation)}
+    except ValueError:
+        pass
+    return _parse_translation_rotation_quaternion(raw, filter_mode)
+
+
+_PARSERS: dict[str, Callable[[str, bool], Dict[str, Any]]] = {
+    "rotation_matrix_translation": _parse_rotation_matrix_translation,
+    "quaternion_translation": _parse_quaternion_translation,
+    "euler_degree_translation": _parse_euler_degree_translation,
+    "homogeneous_matrix_4x4": _parse_homogeneous_matrix_4x4,
+    "json_rotation_translation": _parse_json_rotation_translation,
+    "json_rotation_translation_qxyzw": _parse_json_rotation_translation_qxyzw,
+    "translation_rotation_quaternion": _parse_translation_rotation_quaternion,
+    "rotation_translation_flex": _parse_rotation_translation_flex,
+}
+
+
+def detect_transform_input_format(raw: str, filter_mode: bool = True) -> str:
+    for format_name in SUPPORTED_INPUT_FORMATS:
+        try:
+            _PARSERS[format_name](raw, filter_mode)
+            return format_name
+        except ValueError:
+            continue
+    raise ValueError("unable to detect a supported input format")
+
+
+def parse_transform_input(
+    raw: str,
+    format_name: str | None = None,
+    filter_mode: bool = True,
+) -> Dict[str, Any]:
+    if format_name is None:
+        format_name = detect_transform_input_format(raw, filter_mode=filter_mode)
+    parser = _PARSERS.get(format_name)
+    if parser is None:
+        raise ValueError(
+            f"unsupported format_name: {format_name}. "
+            f"supported={', '.join(SUPPORTED_INPUT_FORMATS)}"
+        )
+    return parser(raw, filter_mode)
+
+
+def transform_from_data(
+    data: Dict[str, Any],
+    euler_order: str | None = None,
+) -> ExtrinsicParam:
+    translation = _find_first(data, ("translation", "t"))
+    translation_vec = (
+        _coerce_float_list(translation, 3, "translation") if translation is not None else [0.0, 0.0, 0.0]
+    )
+    resolved_order = str(
+        euler_order
+        or _find_first(data, ("euler_cal_order", "order", "euler_order"))
+        or "ZYX"
+    )
+
+    if _find_first(data, ("rotation_matrix", "R", "rotation")) is not None:
+        rotation_matrix = _coerce_float_matrix(
+            _find_first(data, ("rotation_matrix", "R", "rotation")),
+            3,
+            3,
+            "rotation_matrix",
+        )
+        return ExtrinsicParam(rotation_matrix=rotation_matrix, translation=translation_vec, euler_order=resolved_order)
+
+    if _find_first(data, ("quaternion_xyzw", "quaternion", "quat", "q")) is not None:
+        quaternion = _coerce_float_list(
+            _find_first(data, ("quaternion_xyzw", "quaternion", "quat", "q")),
+            4,
+            "quaternion_xyzw",
+        )
+        return ExtrinsicParam(quaternion=quaternion, translation=translation_vec, euler_order=resolved_order)
+
+    if _find_first(data, ("euler_degree_xyz", "euler_degree", "euler_deg")) is not None:
+        euler = _coerce_float_list(
+            _find_first(data, ("euler_degree_xyz", "euler_degree", "euler_deg")),
+            3,
+            "euler_degree_xyz",
+        )
+        return ExtrinsicParam(euler=euler, translation=translation_vec, euler_order=resolved_order)
+
+    if _find_first(data, ("homogeneous_matrix_4x4", "T", "extrinsic", "pose")) is not None:
+        matrix = _coerce_float_matrix(
+            _find_first(data, ("homogeneous_matrix_4x4", "T", "extrinsic", "pose")),
+            4,
+            4,
+            "homogeneous_matrix_4x4",
+        )
+        return ExtrinsicParam.from_homogeneous_matrix(np.array(matrix, dtype=float), euler_order=resolved_order)
+
+    raise ValueError("input data does not contain a supported transform representation")
+
+
+def transform_from_input(
+    raw: str,
+    format_name: str | None = None,
+    filter_mode: bool = True,
+    euler_order: str | None = None,
+) -> ExtrinsicParam:
+    data = parse_transform_input(raw, format_name=format_name, filter_mode=filter_mode)
+    return transform_from_data(data, euler_order=euler_order)
+
+
+def transform_to_all_formats(ext: ExtrinsicParam) -> Dict[str, Any]:
+    axis, angle_rad = ext.get_axis_angle()
+    return {
+        "rotation_matrix": ext.rotation_matrix.tolist(),
+        "quaternion_xyzw": ext.get_quaternion().tolist(),
+        "euler_degree_xyz": ext.get_standard_euler().tolist(),
+        "euler_cal_order": getattr(ext, "euler_order", "ZYX"),
+        "translation": ext.translation.tolist(),
+        "axis_angle": {
+            "axis": axis.tolist(),
+            "angle_rad": float(angle_rad),
+            "angle_deg": float(normalize_angle(np.rad2deg(angle_rad))),
+        },
+        "homogeneous_matrix_4x4": ext.get_homogeneous_matrix().tolist(),
+    }
+
+
+def compare_transforms(
+    a: ExtrinsicParam,
+    b: ExtrinsicParam,
+    tolerance: float = 1e-6,
+    rotation_angle_tolerance: float = 1e-6,
+) -> Dict[str, Any]:
+    r_rel = a.rotation_matrix @ b.rotation_matrix.T
+    trace_r = np.clip(np.trace(r_rel), -1.0, 3.0)
+    cos_theta = np.clip((trace_r - 1.0) / 2.0, -1.0, 1.0)
+    rotation_angle_diff_rad = float(np.arccos(cos_theta))
+    rotation_angle_diff_deg = float(np.rad2deg(rotation_angle_diff_rad))
+    rotation_element_max_diff = float(np.max(np.abs(a.rotation_matrix - b.rotation_matrix)))
+    translation_max_diff = float(np.max(np.abs(a.translation - b.translation)))
+    translation_norm = float(np.linalg.norm(a.translation))
+    translation_relative_diff = (
+        translation_max_diff / (translation_norm + 1e-10) if translation_norm > 1e-10 else 0.0
+    )
+    homogeneous_matrix_max_diff = float(
+        np.max(np.abs(a.get_homogeneous_matrix() - b.get_homogeneous_matrix()))
+    )
+    rotation_equal = rotation_angle_diff_rad <= rotation_angle_tolerance
+    translation_equal = translation_max_diff <= tolerance
+    return {
+        "is_equal": bool(rotation_equal and translation_equal),
+        "rotation_element_max_diff": rotation_element_max_diff,
+        "rotation_angle_diff_rad": rotation_angle_diff_rad,
+        "rotation_angle_diff_deg": rotation_angle_diff_deg,
+        "translation_max_diff": translation_max_diff,
+        "translation_relative_diff": float(translation_relative_diff),
+        "homogeneous_matrix_max_diff": homogeneous_matrix_max_diff,
+        "tolerance": float(tolerance),
+        "rotation_angle_tolerance_rad": float(rotation_angle_tolerance),
+        "rotation_equal": bool(rotation_equal),
+        "translation_equal": bool(translation_equal),
+    }
+
+
+def solve_transform_equations(
+    a: ExtrinsicParam,
+    b: ExtrinsicParam,
+    tolerance: float = 1e-6,
+    rotation_angle_tolerance: float = 1e-6,
+) -> Dict[str, Any]:
+    b_inverse = b.inverse()
+    c = a @ b_inverse
+    d = b_inverse @ a
+    verify_c = compare_transforms(c @ b, a, tolerance=tolerance, rotation_angle_tolerance=rotation_angle_tolerance)
+    verify_d = compare_transforms(b @ d, a, tolerance=tolerance, rotation_angle_tolerance=rotation_angle_tolerance)
+    return {
+        "b_inverse": transform_to_all_formats(b_inverse),
+        "equation_1": {
+            "formula": "A = C @ B",
+            "solution": "C = A @ B^-1",
+            "C_matrix": transform_to_all_formats(c),
+            "verification": {
+                "formula": "C @ B",
+                "equals_A": bool(verify_c["is_equal"]),
+                "details": verify_c,
+            },
+        },
+        "equation_2": {
+            "formula": "A = B @ D",
+            "solution": "D = B^-1 @ A",
+            "D_matrix": transform_to_all_formats(d),
+            "verification": {
+                "formula": "B @ D",
+                "equals_A": bool(verify_d["is_equal"]),
+                "details": verify_d,
+            },
+        },
+    }

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

@@ -0,0 +1,93 @@
+Metadata-Version: 2.4
+Name: transform-base
+Version: 0.0.3
+Summary: 欧拉角、旋转矩阵、四元数、角轴及多格式矩阵计算基础库
+License-Expression: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.20
+Requires-Dist: PyYAML>=6.0
+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），并提供多输入格式解析、矩阵乘法/求逆/比较/方程求解的通用 API。
+
+## 安装
+
+```bash
+pip install transform-base
+```
+
+## 功能特性
+
+- **角度归一化**：`normalize_angle` 将角度归一化到 [-180, 180]
+- **欧拉角 ↔ 旋转矩阵**：支持 6 种旋转顺序（order），默认 ZYX
+- **旋转矩阵 ↔ 四元数**：`[x, y, z, w]` 格式
+- **旋转矩阵 ↔ 角轴**：Rodrigues 公式
+- **外参类 ExtrinsicParam**：欧拉/旋转矩阵/四元数/角轴多种初始化，齐次矩阵、点变换、复合与逆
+- **多格式输入解析**：支持旋转矩阵+平移、四元数+平移、欧拉角+平移、4x4 齐次矩阵、JSON/proto/flex 四元数格式
+- **矩阵计算**：支持统一格式输出、矩阵比较、`A = C @ B` / `A = B @ D` 求解
+
+## 快速开始
+
+```python
+from transform_base import (
+    normalize_angle,
+    standard_euler_to_rotation_matrix,
+    rotation_matrix_to_standard_euler,
+    ExtrinsicParam,
+    parse_transform_input,
+    transform_from_input,
+    transform_to_all_formats,
+    compare_transforms,
+    solve_transform_equations,
+)
+
+# 欧拉角 -> 旋转矩阵 -> 欧拉角
+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()
+
+# 多格式输入 -> 外参
+raw = '''
+"translation": {"x": 1, "y": 2, "z": 3},
+"rotation": {"qx": 0.0, "qy": 0.0, "qz": 0.70710678, "qw": 0.70710678}
+'''
+parsed = parse_transform_input(raw, format_name="json_rotation_translation_qxyzw")
+ext_from_input = transform_from_input(raw, format_name="json_rotation_translation_qxyzw")
+all_formats = transform_to_all_formats(ext_from_input)
+
+# 比较与方程求解
+cmp_result = compare_transforms(ext, ext_inv.inverse())
+solve_result = solve_transform_equations(ext, ext_from_input)
+```
+
+## 依赖
+
+- Python >= 3.10
+- numpy >= 1.20
+- PyYAML >= 6.0
+
+## 支持的输入格式
+
+- `rotation_matrix_translation`
+- `quaternion_translation`
+- `euler_degree_translation`
+- `homogeneous_matrix_4x4`
+- `json_rotation_translation`
+- `json_rotation_translation_qxyzw`
+- `translation_rotation_quaternion`
+- `rotation_translation_flex`
+
+## License
+
+MIT

{transform_base-0.0.2 → transform_base-0.0.3}/transform_base.egg-info/SOURCES.txt

@@ -2,6 +2,7 @@ MANIFEST.in
 README.md
 pyproject.toml
 transform_base/__init__.py
+transform_base/matrix_ops.py
 transform_base/transform.py
 transform_base.egg-info/PKG-INFO
 transform_base.egg-info/SOURCES.txt

{transform_base-0.0.2 → transform_base-0.0.3}/transform_base.egg-info/requires.txt

@@ -1,4 +1,5 @@
 numpy>=1.20
+PyYAML>=6.0
 
 [dev]
 pytest

transform_base-0.0.2/PKG-INFO

@@ -1,60 +0,0 @@
-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

@@ -1,47 +0,0 @@
-# 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/PKG-INFO

@@ -1,60 +0,0 @@
-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