solve-rigid-point-set-rt 0.1.0__tar.gz

solve_rigid_point_set_rt-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 GGN_2015
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

solve_rigid_point_set_rt-0.1.0/PKG-INFO

@@ -0,0 +1,69 @@
+Metadata-Version: 2.4
+Name: solve-rigid-point-set-rt
+Version: 0.1.0
+Summary: Solve the transform vector and rotation matrix of a rigid point set.
+License: MIT
+License-File: LICENSE
+Author: GGN_2015
+Author-email: neko@jlulug.org
+Requires-Python: >=3.10
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: numpy
+Description-Content-Type: text/markdown
+
+# solve_rigid_point_set_rt
+Solve the transform vector and rotation matrix of a rigid point set.
+
+## Installation
+
+```bash
+pip install solve_rigid_point_set_rt
+```
+
+## Usage
+
+```python
+from solve_rigid_point_set_rt import compute_best_rigid_transform
+from solve_rigid_point_set_rt import apply_transform
+from solve_rigid_point_set_rt import calculate_error
+import numpy as np
+
+P = np.array([
+    [ 20.606943,  -0.005458,  0.040331],
+    [ -4.885081, -26.211561, -0.023027],
+    [ 12.012958,  20.049110, -0.035819],
+    [-27.734814,   6.167912,  0.018507]
+])
+
+Q = np.array([
+    [-132.94031926182967, 137.4289669332182, 782.6069181107938],
+    [-164.12739196778332, 120.93405919807722, 791.4971644346351],
+    [-115.37230320753432, 126.89401508498568, 790.1637162115628],
+    [-137.8636773243661, 96.44871350623225, 808.1944560570211]
+])
+
+# 2. Compute optimal rotation and translation
+R_est, t_est = compute_best_rigid_transform(P, Q)
+
+# 3. Apply transformation and calculate error
+P_transformed = apply_transform(P, R_est, t_est)
+rmse, mean_dist, _ = calculate_error(P_transformed, Q)
+
+# 4. Print results
+print("="*50)
+print("Optimal Rotation Matrix R:")
+print(R_est)
+print("\nOptimal Translation Vector t:")
+print(t_est)
+print("\nRegistration Accuracy:")
+print(f"Root Mean Square Error (RMSE): {rmse:.6f}")
+print(f"Mean Euclidean Distance: {mean_dist:.6f}")
+print("="*50)
+```
+

solve_rigid_point_set_rt-0.1.0/README.md

@@ -0,0 +1,49 @@
+# solve_rigid_point_set_rt
+Solve the transform vector and rotation matrix of a rigid point set.
+
+## Installation
+
+```bash
+pip install solve_rigid_point_set_rt
+```
+
+## Usage
+
+```python
+from solve_rigid_point_set_rt import compute_best_rigid_transform
+from solve_rigid_point_set_rt import apply_transform
+from solve_rigid_point_set_rt import calculate_error
+import numpy as np
+
+P = np.array([
+    [ 20.606943,  -0.005458,  0.040331],
+    [ -4.885081, -26.211561, -0.023027],
+    [ 12.012958,  20.049110, -0.035819],
+    [-27.734814,   6.167912,  0.018507]
+])
+
+Q = np.array([
+    [-132.94031926182967, 137.4289669332182, 782.6069181107938],
+    [-164.12739196778332, 120.93405919807722, 791.4971644346351],
+    [-115.37230320753432, 126.89401508498568, 790.1637162115628],
+    [-137.8636773243661, 96.44871350623225, 808.1944560570211]
+])
+
+# 2. Compute optimal rotation and translation
+R_est, t_est = compute_best_rigid_transform(P, Q)
+
+# 3. Apply transformation and calculate error
+P_transformed = apply_transform(P, R_est, t_est)
+rmse, mean_dist, _ = calculate_error(P_transformed, Q)
+
+# 4. Print results
+print("="*50)
+print("Optimal Rotation Matrix R:")
+print(R_est)
+print("\nOptimal Translation Vector t:")
+print(t_est)
+print("\nRegistration Accuracy:")
+print(f"Root Mean Square Error (RMSE): {rmse:.6f}")
+print(f"Mean Euclidean Distance: {mean_dist:.6f}")
+print("="*50)
+```

solve_rigid_point_set_rt-0.1.0/pyproject.toml

@@ -0,0 +1,18 @@
+[project]
+name = "solve-rigid-point-set-rt"
+version = "0.1.0"
+description = "Solve the transform vector and rotation matrix of a rigid point set."
+authors = [
+    {name = "GGN_2015",email = "neko@jlulug.org"}
+]
+license = {text = "MIT"}
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "numpy"
+]
+
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"

solve_rigid_point_set_rt-0.1.0/solve_rigid_point_set_rt/__init__.py

@@ -0,0 +1,9 @@
+from .main import compute_best_rigid_transform
+from .main import apply_transform
+from .main import calculate_error
+
+__all__ = [
+    "compute_best_rigid_transform",
+    "apply_transform",
+    "calculate_error"
+]

solve_rigid_point_set_rt-0.1.0/solve_rigid_point_set_rt/main.py

@@ -0,0 +1,55 @@
+import numpy as np
+
+def compute_best_rigid_transform(P: np.ndarray, Q: np.ndarray, assume_p_center_zero:bool=False):
+    """
+    Compute the optimal 3D rotation matrix R and translation vector t
+    that satisfies: Q = R @ P + t (minimum mean square error)
+    Parameters:
+        P: Source point set, shape (N, 3), N is the number of points
+        Q: Target point set, shape (N, 3), in one-to-one correspondence with P
+    Returns:
+        R: 3x3 optimal rotation matrix
+        t: 3x1 optimal translation vector
+    """
+    # 1. Validate input
+    assert P.shape == Q.shape, "The number and dimensions of the two point sets must be identical!"
+    assert P.shape[1] == 3, "Must be 3D point coordinates (x,y,z)"
+    
+    # 2. Compute centroids of the two point sets
+    if assume_p_center_zero:
+        centroid_P = np.array([0, 0, 0])
+    else:
+        centroid_P = np.mean(P, axis=0)
+    centroid_Q = np.mean(Q, axis=0)
+    
+    # 3. Center the points (subtract centroids to eliminate translation effect)
+    P_centered = P - centroid_P
+    Q_centered = Q - centroid_Q
+    
+    # 4. Compute covariance matrix H (3x3)
+    H = P_centered.T @ Q_centered
+    
+    # 5. Perform SVD to solve for optimal rotation
+    U, S, Vt = np.linalg.svd(H)
+    R = Vt.T @ U.T
+    
+    # Correction: Ensure rotation matrix is right-handed (avoid reflection transformation)
+    if np.linalg.det(R) < 0:
+        Vt[-1, :] *= -1
+        R = Vt.T @ U.T
+    
+    # 6. Compute optimal translation vector
+    t = centroid_Q - R @ centroid_P
+    
+    return R, t
+
+def apply_transform(P: np.ndarray, R: np.ndarray, t: np.ndarray):
+    """Apply rotation and translation to the source point set to get transformed points"""
+    return (R @ P.T).T + t
+
+def calculate_error(transformed_P: np.ndarray, Q: np.ndarray):
+    """Calculate Root Mean Square Error (RMSE) and mean distance to evaluate registration accuracy"""
+    errors = np.linalg.norm(transformed_P - Q, axis=1)  # Euclidean distance for each point
+    rmse = np.sqrt(np.mean(errors ** 2))
+    mean_dist = np.mean(errors)
+    return rmse, mean_dist, errors