Rhapso 0.1.99__py3-none-any.whl → 0.1.993__py3-none-any.whl

Rhapso/matching/ransac_matching.py

@@ -27,7 +27,7 @@ class CustomBioImage(BioImage):
 
 class RansacMatching:
     def __init__(self, data_global, num_neighbors, redundancy, significance, num_required_neighbors, match_type, 
-                 max_epsilon, min_inlier_ratio, num_iterations, model_min_matches, regularization_weight, 
+                 inlier_threshold, min_inlier_ratio, num_iterations, model_min_matches, regularization_weight, 
                  search_radius, view_registrations, input_type, image_file_prefix):
         self.data_global = data_global
         self.num_neighbors = num_neighbors
@@ -35,7 +35,7 @@ class RansacMatching:
         self.significance = significance
         self.num_required_neighbors = num_required_neighbors
         self.match_type = match_type
-        self.max_epsilon = max_epsilon
+        self.inlier_threshold = inlier_threshold
         self.min_inlier_ratio = min_inlier_ratio
         self.num_iterations = num_iterations
         self.model_min_matches = model_min_matches
@@ -66,7 +66,7 @@ class RansacMatching:
             errors = []
             for match in temp:
                 p1 = np.array(match[1])
-                p2 = np.array(match[4])
+                p2 = np.array(match[5])
                 p1_h = np.append(p1, 1.0)
                 p1_trans = model_copy @ p1_h
                 error = np.linalg.norm(p1_trans[:3] - p2)
@@ -137,60 +137,55 @@ class RansacMatching:
         rigid_matrix[:3, 3] = t
 
         return rigid_matrix
-
+    
     def fit_affine_model(self, matches):
-        matches = np.array(matches)    # shape (N, 2, 3)
-        P = matches[:, 0]              # source points
-        Q = matches[:, 1]              # target points
-        weights = np.ones(P.shape[0])  # uniform weights
+        """
+        Fit a 3x4 affine transform such that:
+            Q ≈ M @ P + t
+        where P, Q are 3D column vectors (but stored here as row vectors).
+        """
+        matches = np.asarray(matches)          # shape (N, 2, 3)
+        P = matches[:, 0]                      # source points, shape (N, 3)
+        Q = matches[:, 1]                      # target points, shape (N, 3)
 
-        ws = np.sum(weights)
+        # Uniform weights for now (kept in case you add non-uniform later)
+        weights = np.ones(P.shape[0], dtype=float)
 
+        # Weighted centroids
         pc = np.average(P, axis=0, weights=weights)
         qc = np.average(Q, axis=0, weights=weights)
 
+        # Centered coordinates
         P_centered = P - pc
         Q_centered = Q - qc
 
-        A = np.zeros((3, 3))
-        B = np.zeros((3, 3))
-        
-        for i in range(P.shape[0]):
-            w = weights[i]
-            p = P_centered[i]
-            q = Q_centered[i]
-
-            A += w * np.outer(p, p)
-            B += w * np.outer(p, q)
+        # Weighted least squares: scale rows by sqrt(weight)
+        sqrt_w = np.sqrt(weights)[:, None]           # (N, 1)
+        P_w = P_centered * sqrt_w                    # (N, 3)
+        Q_w = Q_centered * sqrt_w                    # (N, 3)
 
-        det = np.linalg.det(A)
-        if det == 0:
-            raise ValueError("Ill-defined data points (det=0)")
+        # Solve P_w @ M^T ≈ Q_w  → M_T is 3x3, then transpose
+        M_T, *_ = np.linalg.lstsq(P_w, Q_w, rcond=None)
+        M = M_T.T
 
-        try:
-            A_inv = np.linalg.inv(A)
-        except np.linalg.LinAlgError:
-            # If A is not invertible, use the pseudo-inverse
-            A_inv = np.linalg.pinv(A)
+        # Translation so that M @ pc ≈ qc
+        t = qc - M @ pc
 
-        M = A_inv @ B  # 3x3 transformation matrix
-
-        t = qc - M @ pc  # translation
-
-        affine_matrix = np.eye(4)
+        # Pack into 4x4 affine matrix
+        affine_matrix = np.eye(4, dtype=float)
         affine_matrix[:3, :3] = M
         affine_matrix[:3, 3] = t
 
         return affine_matrix
     
-    def test(self, candidates, model, max_epsilon, min_inlier_ratio, min_num_inliers):
+    def test(self, candidates, model, inlier_threshold, min_inlier_ratio, min_num_inliers):
         inliers = []
         for idxA, pointA, view_a, label_a, idxB, pointB, view_b, label_b in candidates:
             p1_hom = np.append(pointA, 1.0)            
             transformed = model @ p1_hom                       
             distance = np.linalg.norm(transformed[:3] - pointB)
 
-            if distance < max_epsilon:
+            if distance < inlier_threshold:
                 inliers.append((idxA, pointA, view_a, label_a, idxB, pointB, view_b, label_b))
         
         ir = len(inliers) / len(candidates)
@@ -251,15 +246,16 @@ class RansacMatching:
                 regularized_model = self.model_regularization(point_pairs)
             except Exception as e:
                 print(e)
+                continue
 
             num_inliers = 0
-            is_good, tmp_inliers = self.test(candidates, regularized_model, self.max_epsilon, self.min_inlier_ratio, self.model_min_matches)
+            is_good, tmp_inliers = self.test(candidates, regularized_model, self.inlier_threshold, self.min_inlier_ratio, self.model_min_matches)
 
             while is_good and num_inliers < len(tmp_inliers):
                 num_inliers = len(tmp_inliers)
                 point_pairs = [(i[1], i[5]) for i in tmp_inliers]
                 regularized_model = self.model_regularization(point_pairs)
-                is_good, tmp_inliers = self.test(candidates, regularized_model, self.max_epsilon, self.min_inlier_ratio, self.model_min_matches)
+                is_good, tmp_inliers = self.test(candidates, regularized_model, self.inlier_threshold, self.min_inlier_ratio, self.model_min_matches)
 
             if len(tmp_inliers) > max_inliers:
                 best_inliers = tmp_inliers

Rhapso/pipelines/ray/aws/alignment_pipeline.py

@@ -5,7 +5,7 @@ import json
 import base64, json
 from pathlib import Path
 
-with open("Rhapso/pipelines/ray/param/dev/zarr_s3_sean.yml", "r") as file:
+with open("Rhapso/pipelines/ray/param/exaSPIM_802450.yml", "r") as file:
     config = yaml.safe_load(file)
 
 serialized_config = base64.b64encode(json.dumps(config).encode()).decode()
@@ -51,10 +51,10 @@ matching_cmd_rigid = (
     "    search_radius=cfg[\\\"search_radius_rigid\\\"],\n"
     "    num_required_neighbors=cfg[\\\"num_required_neighbors_rigid\\\"],\n"
     "    model_min_matches=cfg[\\\"model_min_matches_rigid\\\"],\n"
-    "    inlier_factor=cfg[\\\"inlier_factor_rigid\\\"],\n"
-    "    lambda_value=cfg[\\\"lambda_value_rigid\\\"],\n"
+    "    inlier_threshold=cfg[\\\"inlier_threshold_rigid\\\"],\n"
+    "    min_inlier_ratio=cfg[\\\"min_inlier_ratio_rigid\\\"],\n"
     "    num_iterations=cfg[\\\"num_iterations_rigid\\\"],\n"
-    "    regularization_weight=cfg[\\\"regularization_weight_rigid\\\"],\n"
+    "    regularization_weight=cfg[\\\"regularization_weight_matching_rigid\\\"],\n"
     "    image_file_prefix=cfg[\\\"image_file_prefix\\\"]\n"
     ")\n"
     "ipm.run()\n"
@@ -80,10 +80,10 @@ matching_cmd_affine = (
     "    search_radius=cfg[\\\"search_radius_affine\\\"],\n"
     "    num_required_neighbors=cfg[\\\"num_required_neighbors_affine\\\"],\n"
     "    model_min_matches=cfg[\\\"model_min_matches_affine\\\"],\n"
-    "    inlier_factor=cfg[\\\"inlier_factor_affine\\\"],\n"
-    "    lambda_value=cfg[\\\"lambda_value_affine\\\"],\n"
+    "    inlier_threshold=cfg[\\\"inlier_threshold_affine\\\"],\n"
+    "    min_inlier_ratio=cfg[\\\"min_inlier_ratio_affine\\\"],\n"
     "    num_iterations=cfg[\\\"num_iterations_affine\\\"],\n"
-    "    regularization_weight=cfg[\\\"regularization_weight_affine\\\"],\n"
+    "    regularization_weight=cfg[\\\"regularization_weight_matching_affine\\\"],\n"
     "    image_file_prefix=cfg[\\\"image_file_prefix\\\"]\n"
     ")\n"
     "ipm.run()\n"
@@ -109,10 +109,10 @@ matching_cmd_split_affine = (
     "    search_radius=cfg[\\\"search_radius_split_affine\\\"],\n"
     "    num_required_neighbors=cfg[\\\"num_required_neighbors_split_affine\\\"],\n"
     "    model_min_matches=cfg[\\\"model_min_matches_split_affine\\\"],\n"
-    "    inlier_factor=cfg[\\\"inlier_factor_split_affine\\\"],\n"
-    "    lambda_value=cfg[\\\"lambda_value_split_affine\\\"],\n"
+    "    inlier_threshold=cfg[\\\"inlier_threshold_split_affine\\\"],\n"
+    "    min_inlier_ratio=cfg[\\\"min_inlier_ratio_split_affine\\\"],\n"
     "    num_iterations=cfg[\\\"num_iterations_split_affine\\\"],\n"
-    "    regularization_weight=cfg[\\\"regularization_weight_split_affine\\\"],\n"
+    "    regularization_weight=cfg[\\\"regularization_weight_matching_split_affine\\\"],\n"
     "    image_file_prefix=cfg[\\\"image_file_prefix\\\"]\n"
     ")\n"
     "ipm.run()\n"
@@ -151,6 +151,7 @@ solver_rigid = Solver(
     absolute_threshold=config['absolute_threshold'],
     min_matches=config['min_matches'],
     damp=config['damp'],
+    regularization_weight=config['regularization_weight_solver_rigid'],
     max_iterations=config['max_iterations'],
     max_allowed_error=config['max_allowed_error'],
     max_plateauwidth=config['max_plateauwidth'],
@@ -168,6 +169,7 @@ solver_affine = Solver(
     absolute_threshold=config['absolute_threshold'],
     min_matches=config['min_matches'],
     damp=config['damp'],
+    regularization_weight=config['regularization_weight_solver_affine'],
     max_iterations=config['max_iterations'],
     max_allowed_error=config['max_allowed_error'],
     max_plateauwidth=config['max_plateauwidth'],
@@ -185,6 +187,7 @@ solver_split_affine = Solver(
     absolute_threshold=config['absolute_threshold'],
     min_matches=config['min_matches'],
     damp=config['damp'],
+    regularization_weight=config['regularization_weight_solver_split_affine'],
     max_iterations=config['max_iterations'],
     max_allowed_error=config['max_allowed_error'],
     max_plateauwidth=config['max_plateauwidth'],
@@ -210,10 +213,10 @@ try:
     solver_rigid.run()
     exec_on_cluster("Matching (affine)", unified_yml, matching_cmd_affine, prefix)
     solver_affine.run()
-    exec_on_cluster("Split Dataset", unified_yml, split_cmd, prefix)
-    exec_on_cluster("Matching (split_affine)", unified_yml, matching_cmd_split_affine, prefix)
-    solver_split_affine.run()
-    print("\n✅ Pipeline complete.")
+    # exec_on_cluster("Split Dataset", unified_yml, split_cmd, prefix)
+    # exec_on_cluster("Matching (split_affine)", unified_yml, matching_cmd_split_affine, prefix)
+    # solver_split_affine.run()
+    # print("\n✅ Pipeline complete.")
 
 except subprocess.CalledProcessError as e:
     print(f"❌ Pipeline error: {e}")

Rhapso/pipelines/ray/interest_point_matching.py

@@ -6,7 +6,7 @@ import ray
 
 class InterestPointMatching:
     def __init__(self, xml_input_path, n5_output_path, input_type, match_type, num_neighbors, redundancy, significance, 
-                 search_radius, num_required_neighbors, model_min_matches, inlier_factor, lambda_value, num_iterations, 
+                 search_radius, num_required_neighbors, model_min_matches, inlier_threshold, min_inlier_ratio, num_iterations, 
                  regularization_weight, image_file_prefix):
         self.xml_input_path = xml_input_path
         self.n5_output_path = n5_output_path
@@ -18,8 +18,8 @@ class InterestPointMatching:
         self.search_radius = search_radius
         self.num_required_neighbors = num_required_neighbors
         self.model_min_matches = model_min_matches        
-        self.inlier_factor = inlier_factor          
-        self.lambda_value = lambda_value               
+        self.inlier_threshold = inlier_threshold          
+        self.min_inlier_ratio = min_inlier_ratio               
         self.num_iterations = num_iterations
         self.regularization_weight = regularization_weight
         self.image_file_prefix = image_file_prefix
@@ -38,11 +38,11 @@ class InterestPointMatching:
         # Distribute interest point matching with Ray
         @ray.remote
         def match_pair(pointsA, pointsB, viewA_str, viewB_str, label, num_neighbors, redundancy, significance, num_required_neighbors, 
-                       match_type, inlier_factor, lambda_value, num_iterations, model_min_matches, regularization_weight, search_radius,
+                       match_type, inlier_threshold, min_inlier_ratio, num_iterations, model_min_matches, regularization_weight, search_radius,
                        view_registrations, input_type, image_file_prefix): 
             
-            matcher = RansacMatching(data_global, num_neighbors, redundancy, significance, num_required_neighbors, match_type, inlier_factor, 
-                                     lambda_value, num_iterations, model_min_matches, regularization_weight, search_radius, view_registrations,
+            matcher = RansacMatching(data_global, num_neighbors, redundancy, significance, num_required_neighbors, match_type, inlier_threshold, 
+                                     min_inlier_ratio, num_iterations, model_min_matches, regularization_weight, search_radius, view_registrations,
                                      input_type, image_file_prefix)
             
             pointsA, pointsB = matcher.filter_for_overlapping_points(pointsA, pointsB, viewA_str, viewB_str)
@@ -65,7 +65,7 @@ class InterestPointMatching:
         # --- Distribute ---
         futures = [
             match_pair.remote(pointsA, pointsB, viewA_str, viewB_str, label, self.num_neighbors, self.redundancy, self.significance, self.num_required_neighbors,
-                            self.match_type, self.inlier_factor, self.lambda_value, self.num_iterations, self.model_min_matches, self.regularization_weight, 
+                            self.match_type, self.inlier_threshold, self.min_inlier_ratio, self.num_iterations, self.model_min_matches, self.regularization_weight, 
                             self.search_radius, view_registrations, self.input_type, self.image_file_prefix)
             for pointsA, pointsB, viewA_str, viewB_str, label in process_pairs
         ]
@@ -88,8 +88,8 @@ class InterestPointMatching:
 # DEBUG MATCHING
 # all_results = []
 # for pointsA, pointsB, viewA_str, viewB_str, label in process_pairs:
-#     matcher = RansacMatching(data_global, self.num_neighbors, self.redundancy, self.significance, self.num_required_neighbors, self.match_type, self.inlier_factor, 
-#                              self.lambda_value, self.num_iterations, self.model_min_matches, self.regularization_weight, self.search_radius, view_registrations,
+#     matcher = RansacMatching(data_global, self.num_neighbors, self.redundancy, self.significance, self.num_required_neighbors, self.match_type, self.inlier_threshold, 
+#                              self.min_inlier_ratio, self.num_iterations, self.model_min_matches, self.regularization_weight, self.search_radius, view_registrations,
 #                              self.input_type, self.image_file_prefix)
     
 #     pointsA, pointsB = matcher.filter_for_overlapping_points(pointsA, pointsB, viewA_str, viewB_str)

Rhapso/pipelines/ray/local/alignment_pipeline.py

@@ -9,7 +9,7 @@ import ray
 ray.init()
 
 # Point to param file
-with open("Rhapso/pipelines/ray/param/dev/zarr_s3_sean.yml", "r") as file:
+with open("Rhapso/pipelines/ray/param/exaSPIM_802450.yml", "r") as file:
     config = yaml.safe_load(file)
 
 # -- INITIALIZE EACH COMPONENT --
@@ -46,10 +46,10 @@ interest_point_matching_rigid = InterestPointMatching(
     search_radius=config['search_radius_rigid'],
     num_required_neighbors=config['num_required_neighbors_rigid'],
     model_min_matches=config['model_min_matches_rigid'],
-    inlier_factor=config['inlier_factor_rigid'],
-    lambda_value=config['lambda_value_rigid'],
+    inlier_threshold=config['inlier_threshold_rigid'],
+    min_inlier_ratio=config['min_inlier_ratio_rigid'],
     num_iterations=config['num_iterations_rigid'],
-    regularization_weight=config['regularization_weight_rigid'],
+    regularization_weight=config['regularization_weight_matching_rigid'],
     image_file_prefix=config['image_file_prefix'],
 )             
 
@@ -65,10 +65,10 @@ interest_point_matching_affine = InterestPointMatching(
     search_radius=config['search_radius_affine'],
     num_required_neighbors=config['num_required_neighbors_affine'],
     model_min_matches=config['model_min_matches_affine'],
-    inlier_factor=config['inlier_factor_affine'],
-    lambda_value=config['lambda_value_affine'],
+    inlier_threshold=config['inlier_threshold_affine'],
+    min_inlier_ratio=config['min_inlier_ratio_affine'],
     num_iterations=config['num_iterations_affine'],
-    regularization_weight=config['regularization_weight_affine'],
+    regularization_weight=config['regularization_weight_matching_affine'],
     image_file_prefix=config['image_file_prefix'],
 )
 
@@ -84,10 +84,10 @@ interest_point_matching_split_affine = InterestPointMatching(
     search_radius=config['search_radius_split_affine'],
     num_required_neighbors=config['num_required_neighbors_split_affine'],
     model_min_matches=config['model_min_matches_split_affine'],
-    inlier_factor=config['inlier_factor_split_affine'],
-    lambda_value=config['lambda_value_split_affine'],
+    inlier_threshold=config['inlier_threshold_split_affine'],
+    min_inlier_ratio=config['min_inlier_ratio_split_affine'],
     num_iterations=config['num_iterations_split_affine'],
-    regularization_weight=config['regularization_weight_split_affine'],
+    regularization_weight=config['regularization_weight_matching_split_affine'],
     image_file_prefix=config['image_file_prefix'],
 )
 
@@ -101,6 +101,7 @@ solver_rigid = Solver(
     absolute_threshold=config['absolute_threshold'],
     min_matches=config['min_matches'],
     damp=config['damp'],
+    regularization_weight=config['regularization_weight_solver_rigid'],
     max_iterations=config['max_iterations'],
     max_allowed_error=config['max_allowed_error'],
     max_plateauwidth=config['max_plateauwidth'],
@@ -118,6 +119,7 @@ solver_affine = Solver(
     absolute_threshold=config['absolute_threshold'],
     min_matches=config['min_matches'],
     damp=config['damp'],
+    regularization_weight=config['regularization_weight_solver_affine'],
     max_iterations=config['max_iterations'],
     max_allowed_error=config['max_allowed_error'],
     max_plateauwidth=config['max_plateauwidth'],
@@ -135,6 +137,7 @@ solver_split_affine = Solver(
     absolute_threshold=config['absolute_threshold'],
     min_matches=config['min_matches'],
     damp=config['damp'],
+    regularization_weight=config['regularization_weight_solver_split_affine'],
     max_iterations=config['max_iterations'],
     max_allowed_error=config['max_allowed_error'],
     max_plateauwidth=config['max_plateauwidth'],
@@ -157,11 +160,11 @@ split_dataset = SplitDataset(
 )
 
 # -- ALIGNMENT PIPELINE --
-# interest_point_detection.run()
-# interest_point_matching_rigid.run()
+interest_point_detection.run()
+interest_point_matching_rigid.run()
 solver_rigid.run()
-# interest_point_matching_affine.run()
-# solver_affine.run()
-# split_dataset.run()
-# interest_point_matching_split_affine.run()
-# solver_split_affine.run()
+interest_point_matching_affine.run()
+solver_affine.run()
+split_dataset.run()
+interest_point_matching_split_affine.run()
+solver_split_affine.run()

Rhapso/pipelines/ray/solver.py

@@ -16,7 +16,8 @@ This class implements the Solver pipeline for rigid, affine, and split-affine op
 
 class Solver:
     def __init__(self, xml_file_path_output, n5_input_path, xml_file_path, run_type, relative_threshold, absolute_threshold, 
-                 min_matches, damp, max_iterations, max_allowed_error, max_plateauwidth, metrics_output_path, fixed_tile):
+                 min_matches, damp, regularization_weight, max_iterations, max_allowed_error, max_plateauwidth, metrics_output_path, 
+                 fixed_tile):
         self.xml_file_path_output = xml_file_path_output
         self.n5_input_path = n5_input_path
         self.xml_file_path = xml_file_path
@@ -25,6 +26,7 @@ class Solver:
         self.absolute_threshold = absolute_threshold
         self.min_matches = min_matches
         self.damp = damp
+        self.regularization_weight = regularization_weight
         self.max_iterations = max_iterations
         self.max_allowed_error = max_allowed_error
         self.max_plateauwidth = max_plateauwidth
@@ -79,7 +81,8 @@ class Solver:
 
         # Update all points with transform models and iterate through all tiles (views) and optimize alignment
         global_optimization = GlobalOptimization(tc, self.relative_threshold, self.absolute_threshold, self.min_matches, self.damp, 
-                                                self.max_iterations, self.max_allowed_error, self.max_plateauwidth, self.run_type, self.metrics_output_path)
+                                                 self.regularization_weight, self.max_iterations, self.max_allowed_error, 
+                                                 self.max_plateauwidth, self.run_type, self.metrics_output_path)
         tiles, validation_stats = global_optimization.run()
         print("Global optimization complete")
         
@@ -102,7 +105,8 @@ class Solver:
 
             # Update all points with transform models and iterate through all tiles (views) and optimize alignment
             global_optimization = GlobalOptimization(tc, self.relative_threshold, self.absolute_threshold, self.min_matches, self.damp, 
-                                                    self.max_iterations, self.max_allowed_error, self.max_plateauwidth, self.run_type, self.metrics_output_path)
+                                                    self.regularization_weight, self.max_iterations, self.max_allowed_error, 
+                                                    self.max_plateauwidth, self.run_type, self.metrics_output_path)
             tiles_round_2, validation_stats_round_2 = global_optimization.run()
             print("Global optimization complete")
 

Rhapso/solver/global_optimization.py

@@ -7,13 +7,14 @@ GlobalOptimization iteratively refines per-tile transforms to achieve sub-pixel
 """
 
 class GlobalOptimization:
-    def __init__(self, tiles, relative_threshold, absolute_threshold, min_matches, 
-                 damp, max_iterations, max_allowed_error, max_plateauwidth, run_type, metrics_output_path):
+    def __init__(self, tiles, relative_threshold, absolute_threshold, min_matches, damp, regularization_weight, 
+                 max_iterations, max_allowed_error, max_plateauwidth, run_type, metrics_output_path):
         self.tiles = tiles
         self.relative_threshold = relative_threshold
         self.absolute_threshold = absolute_threshold
         self.min_matches = min_matches
         self.damp = damp
+        self.regularization_weight = regularization_weight
         self.max_iterations = max_iterations
         self.max_allowed_error = max_allowed_error
         self.max_plateauwidth = max_plateauwidth
@@ -307,8 +308,7 @@ class GlobalOptimization:
         return affine_model
     
     def regularize_models(self, affine, rigid):
-        alpha=0.1
-        l1 = 1.0 - alpha
+        l1 = 1.0 - self.regularization_weight
 
         def to_array(model):
             return [
@@ -320,7 +320,7 @@ class GlobalOptimization:
         afs = to_array(affine)
         bfs = to_array(rigid)
 
-        rfs = [l1 * a + alpha * b for a, b in zip(afs, bfs)]
+        rfs = [l1 * a + self.regularization_weight * b for a, b in zip(afs, bfs)]
 
         keys = [
             'm00', 'm01', 'm02', 'm03',