Rhapso 0.1.991__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',

Rhapso/split_dataset/save_xml.py

@@ -1,6 +1,7 @@
 import numpy as np
 import boto3
 import re
+import copy
 from xml.etree import ElementTree as ET
 
 class SaveXML:
@@ -11,44 +12,357 @@ class SaveXML:
         self.xml_file = xml_file
         self.xml_output_path = xml_output_path
     
+    def save_tile_attributes_to_xml(self, xml):
+        """
+        Ensure the *last* <ViewSetups> (the outer split one) has:
+        - <Attributes name="illumination"> old_tile_0..N </Attributes>
+        - <Attributes name="channel"> ... </Attributes>
+        - <Attributes name="tile"> with locations from Image Splitting </Attributes>
+        - <Attributes name="angle"><Angle id=0 name=0/></Attributes>
+        """
+        root = ET.fromstring(xml)
+
+        def tagname(el):
+            return el.tag.split('}')[-1]
+
+        def find_one(tag):
+            el = root.find(f'.//{{*}}{tag}')
+            if el is None:
+                el = root.find(tag)
+            return el
+
+        def _norm_id(raw):
+            if isinstance(raw, (tuple, list)):
+                return int(raw[1] if len(raw) > 1 else raw[0])
+            return int(raw)
+
+        # --- find ALL ViewSetups blocks ---
+        view_setups_all = root.findall('.//{*}ViewSetups')
+        if not view_setups_all:
+            return xml  # nothing to do
+
+        # Outer split ViewSetups = last, inner original = first non-outer
+        outer_vs = view_setups_all[-1]
+        inner_vs = None
+        for vs in view_setups_all:
+            if vs is not outer_vs:
+                inner_vs = vs
+                break
+
+        # --- collect existing Attributes on OUTER ---
+        children = list(outer_vs)
+        attr_by_name = {}
+        for ch in children:
+            if tagname(ch) == 'Attributes':
+                nm = ch.get('name')
+                if nm:
+                    attr_by_name[nm] = ch
+
+        # --- ensure CHANNEL attributes (can still be cloned from inner) ---
+        if 'channel' not in attr_by_name and inner_vs is not None:
+            for ch in list(inner_vs):
+                if tagname(ch) != 'Attributes':
+                    continue
+                nm = ch.get('name')
+                if nm == 'channel':
+                    cloned = copy.deepcopy(ch)
+                    outer_vs.append(cloned)
+                    attr_by_name['channel'] = cloned
+                    break
+
+        # --- build/overwrite ILLUMINATION attributes: old_tile_0..N ---
+        illum_attrs = attr_by_name.get('illumination')
+        if illum_attrs is None:
+            illum_attrs = ET.Element('Attributes', {'name': 'illumination'})
+            outer_vs.append(illum_attrs)
+            attr_by_name['illumination'] = illum_attrs
+        else:
+            # clear existing <Illumination> entries
+            for ch in list(illum_attrs):
+                illum_attrs.remove(ch)
+
+        # unique original tile ids from old_view
+        orig_tile_ids = sorted({_norm_id(v['old_view']) for v in self.self_definition})
+
+        for tid in orig_tile_ids:
+            illum_el = ET.SubElement(illum_attrs, 'Illumination')
+            ET.SubElement(illum_el, 'id').text = str(tid)
+            ET.SubElement(illum_el, 'name').text = f"old_tile_{tid}"
+
+        # --- ensure ANGLE attributes: a single Angle id=0/name=0 ---
+        angle_attrs = attr_by_name.get('angle')
+        if angle_attrs is None:
+            # try clone from inner if it exists
+            if inner_vs is not None:
+                for ch in list(inner_vs):
+                    if tagname(ch) == 'Attributes' and ch.get('name') == 'angle':
+                        angle_attrs = copy.deepcopy(ch)
+                        outer_vs.append(angle_attrs)
+                        break
+            # if no inner angle, synthesize default
+            if angle_attrs is None:
+                angle_attrs = ET.Element('Attributes', {'name': 'angle'})
+                angle_el = ET.SubElement(angle_attrs, 'Angle')
+                ET.SubElement(angle_el, 'id').text = "0"
+                ET.SubElement(angle_el, 'name').text = "0"
+                outer_vs.append(angle_attrs)
+        else:
+            # if it exists but has no <Angle>, make one
+            has_angle = any(tagname(ch) == 'Angle' for ch in angle_attrs)
+            if not has_angle:
+                angle_el = ET.SubElement(angle_attrs, 'Angle')
+                ET.SubElement(angle_el, 'id').text = "0"
+                ET.SubElement(angle_el, 'name').text = "0"
+
+        attr_by_name['angle'] = angle_attrs
+
+        # ---- find or create <Attributes name="tile"> under OUTER <ViewSetups> ----
+        children = list(outer_vs)
+        tile_attrs = None
+        insert_idx = len(children)  # default: append at end
+
+        for i, ch in enumerate(children):
+            if tagname(ch) == 'Attributes':
+                name_attr = ch.get('name')
+                # remember existing tile attributes if present
+                if name_attr == 'tile':
+                    tile_attrs = ch
+                # prefer to insert tile after channel attributes if we create it
+                if name_attr == 'channel':
+                    insert_idx = i + 1
+
+        if tile_attrs is None:
+            tile_attrs = ET.Element('Attributes', {'name': 'tile'})
+            outer_vs.insert(insert_idx, tile_attrs)
+
+        # ---- figure out which tile ids (new_view ids) we care about ----
+        target_ids = {_norm_id(v['new_view']) for v in self.self_definition}
+
+        # Remove existing Tile entries for those ids (so we can rewrite cleanly)
+        for child in list(tile_attrs):
+            if tagname(child) != 'Tile':
+                continue
+            id_el = child.find('id') or child.find('{*}id')
+            if id_el is None or not id_el.text:
+                continue
+            try:
+                if int(id_el.text.strip()) in target_ids:
+                    tile_attrs.remove(child)
+            except Exception:
+                pass
+
+        # ---- build a map: setup_id -> (tx, ty, tz) from 'Image Splitting' ----
+        view_regs = find_one('ViewRegistrations')
+        tile_locations = {}
+
+        if view_regs is not None:
+            # iterate over ViewRegistration elements, namespace-agnostic
+            for vr in view_regs.findall('.//{*}ViewRegistration'):
+                setup_attr = vr.get('setup')
+                if setup_attr is None:
+                    continue
+                try:
+                    setup_id = int(setup_attr)
+                except ValueError:
+                    continue
+
+                if setup_id not in target_ids:
+                    continue
+
+                # find the Image Splitting transform
+                for vt in vr.findall('./{*}ViewTransform'):
+                    name_el = vt.find('Name') or vt.find('{*}Name')
+                    if name_el is None:
+                        continue
+                    if (name_el.text or '').strip().lower() != 'image splitting':
+                        continue
+
+                    aff_el = vt.find('affine') or vt.find('{*}affine')
+                    if aff_el is None or not aff_el.text:
+                        continue
+
+                    nums = re.findall(
+                        r'[-+]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][-+]?\d+)?',
+                        aff_el.text
+                    )
+
+                    # 3x4 affine: we expect at least 12 numbers
+                    if len(nums) >= 12:
+                        tx, ty, tz = map(float, (nums[3], nums[7], nums[11]))
+                    elif len(nums) >= 3:
+                        # fallback: last 3 numbers
+                        tx, ty, tz = map(float, nums[-3:])
+                    else:
+                        tx = ty = tz = 0.0
+
+                    tile_locations[setup_id] = (tx, ty, tz)
+                    break  # stop after first 'Image Splitting' for this VR
+
+        # ---- create Tile entries for each new_view ----
+        for view in self.self_definition:
+            new_id = _norm_id(view['new_view'])
+
+            if new_id in tile_locations:
+                loc = tile_locations[new_id]
+            else:
+                # Fallback: use min bound of interval if we didn't find an image splitting transform
+                mins = np.array(view['interval'][0], dtype=float)
+                loc = (float(mins[0]), float(mins[1]), float(mins[2]))
+
+            tile_el = ET.SubElement(tile_attrs, 'Tile')
+            ET.SubElement(tile_el, 'id').text = str(new_id)
+            ET.SubElement(tile_el, 'name').text = str(new_id)
+            ET.SubElement(tile_el, 'location').text = f"{loc[0]:.1f} {loc[1]:.1f} {loc[2]:.1f}"
+
+        # ---- reorder children in OUTER <ViewSetups>:
+        # all <ViewSetup> first, then <Attributes> in illumination, channel, tile, angle order ----
+        children = list(outer_vs)
+
+        viewsetup_children = [ch for ch in children if tagname(ch) == 'ViewSetup']
+        attr_children = [ch for ch in children if tagname(ch) == 'Attributes']
+        other_children = [ch for ch in children if tagname(ch) not in ('ViewSetup', 'Attributes')]
+
+        # desired attributes order
+        attr_order = {'illumination': 0, 'channel': 1, 'tile': 2, 'angle': 3}
+
+        def _attr_sort_key(el):
+            name = el.get('name', '')
+            return attr_order.get(name, 99)
+
+        attr_children.sort(key=_attr_sort_key)
+
+        # Clear existing children and re-append in desired order
+        for ch in children:
+            outer_vs.remove(ch)
+
+        for ch in viewsetup_children + attr_children + other_children:
+            outer_vs.append(ch)
+
+        try:
+            ET.indent(root, space="  ")
+        except Exception:
+            pass
+
+        return ET.tostring(root, encoding='unicode')
+
     def wrap_image_loader_for_split(self, xml: str) -> str:
+        """
+        Wrap the top-level ImageLoader in <ImageLoader format="split.viewerimgloader">
+        and move the ORIGINAL ViewSetups/Timepoints/MissingViews into an inner
+        <SequenceDescription> inside that wrapper.
+
+        Resulting structure:
+
+        <SpimData>
+          <BasePath/>
+          <SequenceDescription>
+            <ImageLoader format="split.viewerimgloader">
+              <ImageLoader format="bdv.multimg.zarr"> ... </ImageLoader>
+              <SequenceDescription>
+                <ViewSetups>  (ORIGINAL)  </ViewSetups>
+                <Timepoints>  (ORIGINAL)  </Timepoints>
+                <MissingViews/>
+              </SequenceDescription>
+              <!-- SetupIds (for split tiles) will be added later -->
+            </ImageLoader>
+            <!-- NEW ViewSetups/Timepoints/MissingViews for split views are added later -->
+          </SequenceDescription>
+          <ViewRegistrations> ... </ViewRegistrations>
+        </SpimData>
+        """
         root = ET.fromstring(xml)
 
-        def tn(el): return el.tag.split('}')[-1]
+        def tn(el):
+            return el.tag.split('}')[-1]
+
         def find_one(tag):
             el = root.find(f'.//{{*}}{tag}')
             return el if el is not None else root.find(tag)
 
-        seq = find_one('SequenceDescription')
+        seq = None
+        # Prefer the top-level SequenceDescription (direct child of root)
+        for ch in list(root):
+            if tn(ch) == 'SequenceDescription':
+                seq = ch
+                break
+        if seq is None:
+            seq = find_one('SequenceDescription')
         if seq is None:
-            return xml  
-
-        # find the first immediate ImageLoader under SequenceDescription
-        loaders = [ch for ch in list(seq) if tn(ch) == 'ImageLoader']
-        if not loaders:
             return xml
 
-        inner = loaders[0]
+        children = list(seq)
 
-        fmt = (inner.get('format') or '').lower()
-        if fmt == 'split.viewerimgloader':
+        # Find the first immediate ImageLoader under SequenceDescription
+        base_loader = None
+        base_loader_idx = None
+        for i, ch in enumerate(children):
+            if tn(ch) == 'ImageLoader':
+                base_loader = ch
+                base_loader_idx = i
+                break
+
+        if base_loader is None:
             return xml
-        
-        # handle the case where the *outer* wrapper already exists
-        if any(tn(ch) == 'ImageLoader' for ch in list(inner)) and fmt.startswith('bdv'):
+
+        fmt = (base_loader.get('format') or '').lower()
+        # Already wrapped; assume layout is correct and do nothing
+        if fmt == 'split.viewerimgloader':
             return xml
 
-        # wrap the current loader
-        idx = list(seq).index(inner)
-        seq.remove(inner)
+        # Collect any other ImageLoader siblings (other sources)
+        other_imageloaders = []
+        # Collect ORIGINAL ViewSetups / Timepoints / MissingViews that are siblings
+        orig_viewsetups = None
+        orig_timepoints = None
+        orig_missingviews = None
+
+        for ch in children[base_loader_idx + 1:]:
+            name = tn(ch)
+            if name == 'ImageLoader':
+                other_imageloaders.append(ch)
+            elif name == 'ViewSetups':
+                orig_viewsetups = ch
+            elif name == 'Timepoints':
+                orig_timepoints = ch
+            elif name == 'MissingViews':
+                orig_missingviews = ch
+            
+
+        # Remove them from the outer SequenceDescription
+        for node in (orig_viewsetups, orig_timepoints, orig_missingviews, *other_imageloaders):
+            if node is not None and node in seq:
+                seq.remove(node)
+
+        # Remove the original loader from seq
+        seq.remove(base_loader)
+
+        # Build wrapper <ImageLoader format="split.viewerimgloader">
         wrapper = ET.Element('ImageLoader', {'format': 'split.viewerimgloader'})
-        wrapper.append(inner)
-        seq.insert(idx, wrapper)
+        # First child: original loader
+        wrapper.append(base_loader)
+        for other_loader in other_imageloaders:
+            wrapper.append(other_loader)
+
+        # Inner <SequenceDescription> that holds the original ViewSetups/Timepoints/MissingViews
+        inner_seq = ET.Element('SequenceDescription')
+
+        if orig_viewsetups is not None:
+            inner_seq.append(orig_viewsetups)
+        if orig_timepoints is not None:
+            inner_seq.append(orig_timepoints)
+        if orig_missingviews is not None:
+            inner_seq.append(orig_missingviews)
+
+        wrapper.append(inner_seq)
+
+        # Insert wrapper where the original loader was
+        seq.insert(base_loader_idx, wrapper)
 
         try:
             ET.indent(root, space="  ")
         except Exception:
             pass
+
         return ET.tostring(root, encoding='unicode')
     
     def save_view_interest_points(self, xml):
@@ -202,46 +516,66 @@ class SaveXML:
         return ET.tostring(root, encoding='unicode')
 
     def save_setup_id_to_xml(self, xml):
+        """
+        Create/overwrite the OUTER <ViewSetups> (split tiles) and ensure outer
+        <Timepoints> and <MissingViews> exist under the top-level SequenceDescription.
+
+        Outer layout target:
+
+        <SpimData>
+          <BasePath/>
+          <SequenceDescription>
+            <ImageLoader format="split.viewerimgloader">
+              ...
+              <SequenceDescription>  (original)  </SequenceDescription>
+              <SetupIds> ... </SetupIds>        (from save_setup_id_definition_to_xml)
+            </ImageLoader>
+            <ViewSetups>            <-- created here (ids 0..499)
+              <ViewSetup>...</ViewSetup>
+              ...
+              <Attributes ...>...</Attributes>
+            </ViewSetups>
+            <Timepoints type="pattern">
+              <integerpattern>0</integerpattern>
+            </Timepoints>
+            <MissingViews/>
+          </SequenceDescription>
+          <ViewRegistrations>...</ViewRegistrations>
+        </SpimData>
+        """
         root = ET.fromstring(xml)
 
-        def tagname(el): 
+        def tn(el):
             return el.tag.split('}')[-1]
 
-        def find_one(tag):
-            el = root.find(f'.//{{*}}{tag}')
-            if el is None:
-                el = root.find(tag)
-            return el
-
-        seq  = find_one('SequenceDescription')
-        regs = find_one('ViewRegistrations')
-        setup_ids = find_one('SetupIds')
-        if setup_ids is None:
-            setup_ids = ET.Element('SetupIds')
-            kids = list(root)
-            insert_idx = len(kids)
-            if regs is not None and regs in kids:
-                insert_idx = kids.index(regs)
-            elif seq is not None and seq in kids:
-                insert_idx = kids.index(seq) + 1
-            root.insert(insert_idx, setup_ids)
+        # Find top-level SequenceDescription
+        outer_seq = None
+        for ch in list(root):
+            if tn(ch) == 'SequenceDescription':
+                outer_seq = ch
+                break
+        if outer_seq is None:
+            outer_seq = root.find('.//{*}SequenceDescription')
+        if outer_seq is None:
+            return xml
 
+        # Find or create OUTER <ViewSetups> under SequenceDescription
         view_setups = None
-        for ch in list(root):
-            if tagname(ch) == 'ViewSetups':
+        for ch in list(outer_seq):
+            if tn(ch) == 'ViewSetups':
                 view_setups = ch
                 break
-        if view_setups is None:
-            view_setups = find_one('ViewSetups')
+
         if view_setups is None:
             view_setups = ET.Element('ViewSetups')
-            kids = list(root)
-            after_idx = -1
-            for i, ch in enumerate(kids):
-                if tagname(ch) in ('ImageLoader', 'SequenceDescription'):
-                    after_idx = i
-            root.insert(after_idx + 1 if after_idx >= 0 else len(kids), view_setups)
-
+            children = list(outer_seq)
+            insert_idx = len(children)
+            for i, ch in enumerate(children):
+                if tn(ch) == 'ImageLoader':
+                    insert_idx = i + 1
+            outer_seq.insert(insert_idx, view_setups)
+
+        # Helper to normalize ids
         def _norm_id(raw):
             if isinstance(raw, (tuple, list)):
                 if len(raw) >= 2:
@@ -249,11 +583,11 @@ class SaveXML:
                 return int(raw[0])
             return int(raw)
 
-        target_ids = set(_norm_id(v['new_view']) for v in self.self_definition)
+        target_ids = {_norm_id(v['new_view']) for v in self.self_definition}
 
-        # ViewSetup cleanup
+        # Remove any existing ViewSetup with those ids (outer only)
         for child in list(view_setups):
-            if tagname(child) != 'ViewSetup':
+            if tn(child) != 'ViewSetup':
                 continue
             id_el = child.find('id') or child.find('{*}id')
             if id_el is not None and id_el.text:
@@ -263,40 +597,22 @@ class SaveXML:
                 except Exception:
                     pass
 
-        # SetupIdDefinition cleanup
-        for sid in list(setup_ids):
-            if tagname(sid) != 'SetupIdDefinition':
-                continue
-            nid_el = sid.find('NewId') or sid.find('{*}NewId')
-            if nid_el is not None and nid_el.text:
-                try:
-                    if int(nid_el.text.strip()) in target_ids:
-                        setup_ids.remove(sid)
-                except Exception:
-                    pass
-
+        # (Re)build ViewSetups for each new split view
         for view in self.self_definition:
             new_id = _norm_id(view['new_view'])
-            old_id = _norm_id(view['old_view'])
-            angle  = view['angle']
-            channel = view['channel']
+            # old_id = _norm_id(view['old_view'])   # not strictly needed here
+
+            angle       = view['angle']
+            channel     = view['channel']
             illumination = view['illumination']
-            tile = new_id
-            voxel_unit = view['voxel_unit']
-            voxel_size = view['voxel_dim'] 
+            tile        = new_id
+            voxel_unit  = view['voxel_unit']
+            voxel_size  = view['voxel_dim']
 
             mins = np.array(view["interval"][0], dtype=np.int64)
             maxs = np.array(view["interval"][1], dtype=np.int64)
             size = (maxs - mins + 1).tolist()
 
-            # <SetupIds>/<SetupIdDefinition>
-            def_el = ET.SubElement(setup_ids, 'SetupIdDefinition')
-            ET.SubElement(def_el, 'NewId').text = str(new_id)
-            ET.SubElement(def_el, 'OldId').text = str(old_id)
-            ET.SubElement(def_el, 'min').text   = f"{int(mins[0])} {int(mins[1])} {int(mins[2])}"
-            ET.SubElement(def_el, 'max').text   = f"{int(maxs[0])} {int(maxs[1])} {int(maxs[2])}"
-
-            # <ViewSetups>/<ViewSetup>
             vs = ET.SubElement(view_setups, 'ViewSetup')
             ET.SubElement(vs, 'id').text   = str(new_id)
             ET.SubElement(vs, 'size').text = f"{int(size[0])} {int(size[1])} {int(size[2])}"
@@ -314,6 +630,31 @@ class SaveXML:
             ET.SubElement(attrs, 'tile').text         = str(int(tile))
             ET.SubElement(attrs, 'angle').text        = str(int(angle))
 
+        # Ensure outer <Timepoints> exists
+        outer_timepoints = None
+        for ch in list(outer_seq):
+            if tn(ch) == 'Timepoints':
+                outer_timepoints = ch
+                break
+        if outer_timepoints is None:
+            outer_timepoints = ET.Element('Timepoints', {'type': 'pattern'})
+            ip = ET.SubElement(outer_timepoints, 'integerpattern')
+            ip.text = "0"
+            # place right after ViewSetups
+            children = list(outer_seq)
+            insert_idx = children.index(view_setups) + 1 if view_setups in children else len(children)
+            outer_seq.insert(insert_idx, outer_timepoints)
+
+        # Ensure outer <MissingViews> exists
+        outer_missing = None
+        for ch in list(outer_seq):
+            if tn(ch) == 'MissingViews':
+                outer_missing = ch
+                break
+        if outer_missing is None:
+            outer_missing = ET.Element('MissingViews')
+            outer_seq.append(outer_missing)
+
         try:
             ET.indent(root, space="  ")
         except Exception:
@@ -322,38 +663,92 @@ class SaveXML:
         return ET.tostring(root, encoding='unicode')
     
     def save_setup_id_definition_to_xml(self, xml):
+        """
+        Create/overwrite <SetupIds> for the split views.
+
+        In the desired final layout, SetupIds lives inside:
+          <SequenceDescription>
+            <ImageLoader format="split.viewerimgloader">
+              ...
+              <SequenceDescription> ... </SequenceDescription>
+              <SetupIds> ... </SetupIds>   <-- here
+            </ImageLoader>
+            ...
+          </SequenceDescription>
+        """
         root = ET.fromstring(xml)
 
-        # find existing nodes (namespace-agnostic)
-        def tagname(el): return el.tag.split('}')[-1]
-        children = list(root)
-        regs_idx = next((i for i, ch in enumerate(children) if tagname(ch) == 'ViewRegistrations'), None)
-        seq_idx  = next((i for i, ch in enumerate(children) if tagname(ch) == 'SequenceDescription'), None)
-        setup_ids = next((ch for ch in children if tagname(ch) == 'SetupIds'), None)
+        def tn(el):
+            return el.tag.split('}')[-1]
+
+        # Find top-level SequenceDescription
+        outer_seq = None
+        for ch in list(root):
+            if tn(ch) == 'SequenceDescription':
+                outer_seq = ch
+                break
+        if outer_seq is None:
+            outer_seq = root.find('.//{*}SequenceDescription')
+        if outer_seq is None:
+            return xml
+
+        # Find the wrapper ImageLoader format="split.viewerimgloader"
+        wrapper = None
+        for ch in list(outer_seq):
+            if tn(ch) == 'ImageLoader' and (ch.get('format') or '').lower() == 'split.viewerimgloader':
+                wrapper = ch
+                break
+
+        # If wrapper not found, fall back to old behavior (root-level SetupIds)
+        parent_for_setupids = wrapper if wrapper is not None else root
+        children = list(parent_for_setupids)
+
+        # Locate existing <SetupIds> under the chosen parent
+        setup_ids = None
+        for ch in children:
+            if tn(ch) == 'SetupIds':
+                setup_ids = ch
+                break
 
-        # create/position <SetupIds>
         if setup_ids is None:
             setup_ids = ET.Element('SetupIds')
-            insert_idx = regs_idx if regs_idx is not None else ((seq_idx + 1) if seq_idx is not None else len(children))
-            root.insert(insert_idx, setup_ids)
+            if wrapper is not None:
+                # Under wrapper: insert after inner SequenceDescription if present
+                inner_children = list(wrapper)
+                inner_seq = None
+                for ich in inner_children:
+                    if tn(ich) == 'SequenceDescription':
+                        inner_seq = ich
+                        break
+                insert_idx = inner_children.index(inner_seq) + 1 if inner_seq is not None else len(inner_children)
+                wrapper.insert(insert_idx, setup_ids)
+            else:
+                # Root-level fallback: put before <ViewRegistrations> if present
+                root_children = list(root)
+                regs_idx = next((i for i, ch in enumerate(root_children) if tn(ch) == 'ViewRegistrations'), None)
+                insert_idx = regs_idx if regs_idx is not None else len(root_children)
+                root.insert(insert_idx, setup_ids)
         else:
-            setup_ids.clear()  
+            # Clear existing definitions so we can rewrite
+            setup_ids.clear()
 
+        # Now populate SetupIdDefinition from self.self_definition
         for view in self.self_definition:
             new_id = view['new_view']
             old_id = view['old_view']
             min_bound = view['interval'][0]
             max_bound = view['interval'][1]
-            
+
+            # Normalize IDs (can be int or (tp, setup))
             nid = int(new_id[1] if isinstance(new_id, (tuple, list)) else new_id)
             oid = int(old_id[1] if isinstance(old_id, (tuple, list)) else old_id)
 
             def_el = ET.SubElement(setup_ids, 'SetupIdDefinition')
             ET.SubElement(def_el, 'NewId').text = str(nid)
             ET.SubElement(def_el, 'OldId').text = str(oid)
-            ET.SubElement(def_el, 'min').text   = f"{int(min_bound[0])} {int(min_bound[1])} {int(min_bound[2])}"
-            ET.SubElement(def_el, 'max').text   = f"{int(max_bound[0])} {int(max_bound[1])} {int(max_bound[2])}"
-        
+            ET.SubElement(def_el, 'min').text = f"{int(min_bound[0])} {int(min_bound[1])} {int(min_bound[2])}"
+            ET.SubElement(def_el, 'max').text = f"{int(max_bound[0])} {int(max_bound[1])} {int(max_bound[2])}"
+
         try:
             ET.indent(root, space="  ")
         except Exception:
@@ -362,11 +757,13 @@ class SaveXML:
         return ET.tostring(root, encoding='unicode')
 
     def run(self):
-        xml = self.save_setup_id_definition_to_xml(self.xml_file)
+        xml = self.xml_file
+        xml = self.wrap_image_loader_for_split(xml)
+        xml = self.save_setup_id_definition_to_xml(xml)
         xml = self.save_setup_id_to_xml(xml)
         xml = self.save_view_registrations_to_xml(xml)
+        xml = self.save_tile_attributes_to_xml(xml)
         xml = self.save_view_interest_points(xml)
-        xml = self.wrap_image_loader_for_split(xml)
 
         if self.xml_output_path:
             if self.xml_output_path.startswith("s3://"):

{rhapso-0.1.991.dist-info → rhapso-0.1.993.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Rhapso
-Version: 0.1.991
+Version: 0.1.993
 Summary: A python package for aligning and stitching light sheet fluorescence microscopy images
 Author: ND
 Author-email: sean.fite@alleninstitute.org
@@ -9,13 +9,9 @@ Project-URL: Roadmap, https://github.com/AllenNeuralDynamics/Rhapso/issues
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Natural Language :: English
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.7
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pandas
@@ -33,6 +29,7 @@ Requires-Dist: matplotlib==3.10.0
 Requires-Dist: memory-profiler==0.61.0
 Requires-Dist: s3fs==2024.12.0
 Requires-Dist: scikit-learn
+Requires-Dist: click==8.2.1
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
@@ -414,25 +411,26 @@ python Rhapso/pipelines/ray/aws/alignment_pipeline.py
 | Parameter                     | Feature / step       | What it does                                                      | Typical range  |
 | :---------------------------- | :------------------- | :---------------------------------------------------------------- | :------------- |
 | `model_min_matches`           | RANSAC               | Minimum correspondences to estimate a rigid transform             | 18 – 32        |
-| `inlier_factor`               | RANSAC               | Inlier tolerance scaling; larger = looser inlier threshold        | 30 – 100       |
-| `lambda_value`                | RANSAC               | Regularization strength during model fitting                      | 0.1 – 0.05     |
+| `inlier_threshold`            | RANSAC               | Inlier tolerance scaling; larger = looser inlier threshold        | 50 – 100       |
+| `min_inlier_ratio`            | RANSAC               | Regularization strength during model fitting                      | 0.1 – 0.05     |
 | `num_iterations`              | RANSAC               | Number of RANSAC trials; higher = more robust, slower             | 10,0000        |
-| `regularization_weight`       | RANSAC               | Weight applied to the regularization term                         | 1.0            |
+| `regularization_weight`       | RANSAC               | Weight applied to the regularization term                         | 0.05 - 1.0     |
 
 ```
 <br>
 
 ### Solver
 ```
-| Parameter            | Feature / step | What it does                                                       | Typical range       |
-| :------------------- | :------------- | :----------------------------------------------------------------- | :------------------ |
-| `relative_threshold` | Graph pruning  | Reject edges with residuals above dataset-relative cutoff          | 3.5                 |
-| `absolute_threshold` | Graph pruning  | Reject edges above an absolute error bound (detection-space units) | 7.0                 |
-| `min_matches`        | Graph pruning  | Minimum matches required to retain an edge between tiles           | 3                   |
-| `damp`               | Optimization   | Damping for iterative solver; higher can stabilize tough cases     | 1.0                 |
-| `max_iterations`     | Optimization   | Upper bound on solver iterations                                   | 10,0000             |
-| `max_allowed_error`  | Optimization   | Overall error cap; `inf` disables hard stop by error               | `inf`               |
-| `max_plateauwidth`   | Early stopping | Stagnation window before stopping on no improvement                | 200                 |
+| Parameter                | Feature / step | What it does                                                       | Typical range       |
+| :----------------------- | :------------- | :----------------------------------------------------------------- | :------------------ |
+| `relative_threshold`     | Graph pruning  | Reject edges with residuals above dataset-relative cutoff          | 3.5                 |
+| `absolute_threshold`     | Graph pruning  | Reject edges above an absolute error bound (detection-space units) | 7.0                 |
+| `min_matches`            | Graph pruning  | Minimum matches required to retain an edge between tiles           | 3                   |
+| `damp`                   | Optimization   | Damping for iterative solver; higher can stabilize tough cases     | 1.0                 |
+| `max_iterations`         | Optimization   | Upper bound on solver iterations                                   | 10,0000             |
+| `max_allowed_error`      | Optimization   | Overall error cap; `inf` disables hard stop by error               | `inf`               |
+| `max_plateauwidth`       | Early stopping | Stagnation window before stopping on no improvement                | 200                 |
+| `regularization_weight`  | RANSAC         | Weight applied to the regularization term                          | 0.05 - 1.0          |
 
 ```
 

{rhapso-0.1.991.dist-info → rhapso-0.1.993.dist-info}/RECORD

@@ -56,29 +56,29 @@ Rhapso/fusion/neuroglancer_link_gen/utils/transfer.py,sha256=8hFBM8lmCV3TsEEVXZk
 Rhapso/fusion/neuroglancer_link_gen/utils/utils.py,sha256=Q0jKPGI39ScCHDgVEoWbrZrBrEluCjm69z28T3JScTc,7322
 Rhapso/matching/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 Rhapso/matching/load_and_transform_points.py,sha256=UEV9gnWyl2z4zAUR2Z_ewX1_TWoS-IpXPL-qRB1_Ms8,16416
-Rhapso/matching/ransac_matching.py,sha256=PH9JpWqCrWcZoDvwG_Zs2FSk2cCdIX9be_6y2ix-3RI,20031
+Rhapso/matching/ransac_matching.py,sha256=BWSRmckG2GiA49RuGnja4le-Xo5o9aY53Yawes9P-_E,20268
 Rhapso/matching/save_matches.py,sha256=OYHzzGoF9-PTVfQZBJ7HaJ9JYB_Q8ZazH-f3HljxzLQ,4720
 Rhapso/matching/xml_parser.py,sha256=nP_jA_jEfAFPzt6Al91NpwWEk-Klk8P5QzNINJYVksU,11527
 Rhapso/pipelines/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 Rhapso/pipelines/ray/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 Rhapso/pipelines/ray/evaluation.py,sha256=k05e72WKu9UkptJkjk_rkScjn1zGOhIG1rTOLkxkOLI,2610
 Rhapso/pipelines/ray/interest_point_detection.py,sha256=NZ2Egm81KPC1dFncz_6srW0TYhBTpKqy80nEk0DigEU,6595
-Rhapso/pipelines/ray/interest_point_matching.py,sha256=aM-83D3JJUrkiWT0hogpcyxUw7h78kKegYtUFKMQu3s,5697
+Rhapso/pipelines/ray/interest_point_matching.py,sha256=0wdCxcz-PeNSrxLIZpHpUyJLOvp7tM8S6LH2k1t2woA,5746
 Rhapso/pipelines/ray/matching_stats.py,sha256=7NZ4rQPTKMwzJBrPXkVbiWkzIeH4h9PfDozqrUo8TKU,4199
-Rhapso/pipelines/ray/solver.py,sha256=JqNZPyd_0tliM3mu8voDNcQuhkgwMKF5fBMzfjVMCy8,6198
+Rhapso/pipelines/ray/solver.py,sha256=FK02ttFOvVRHTvlsBJ_kJ4GdwLHfIa3ljZ6VhE8FxS0,6458
 Rhapso/pipelines/ray/split_dataset.py,sha256=JVMd3qYw17Em-rQDvufSAaqaPWw5kf9yWpf5ShSh97M,2943
 Rhapso/pipelines/ray/aws/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-Rhapso/pipelines/ray/aws/alignment_pipeline.py,sha256=JvSB08mIskgqzc-U-6vOprl5k7i9UN5yOgDOKtimIJ0,9716
+Rhapso/pipelines/ray/aws/alignment_pipeline.py,sha256=c_UUw_90xnoAJ5zYuU5OD0Uzr1cPOqsZ6aXHOQauYCI,10015
 Rhapso/pipelines/ray/aws/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 Rhapso/pipelines/ray/local/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-Rhapso/pipelines/ray/local/alignment_pipeline.py,sha256=OFdns9kILtAQD8KNU7MoLXQeZba1q4YV9LiLVSo8fi0,6712
+Rhapso/pipelines/ray/local/alignment_pipeline.py,sha256=EV2e0Kfx7uSHaIVMTKId-NG8f6B4TCWnI5yqSRrmuFE,6989
 Rhapso/pipelines/ray/param/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 Rhapso/solver/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 Rhapso/solver/compute_tiles.py,sha256=-7QFrZZfh1iW1nDdlBORlcqOGf7urJmgjWOj6DfDdHQ,20471
 Rhapso/solver/concatenate_models.py,sha256=-763cwYyyHM6b7E5RkHMRtykFrVjeVeB1l0jFeoLfnI,4472
 Rhapso/solver/connected_graphs.py,sha256=wKxOOKRNd4MctYRX677hiFIYHLAg3GinkpqDqO0ad50,3603
 Rhapso/solver/data_prep.py,sha256=nS96_4MJ0TcHyFMsGDS82n0R-aUm8J99g8d_MrWpsik,7753
-Rhapso/solver/global_optimization.py,sha256=6qYXHmJRCTf-4gSwFgmy9IBUBUp7SuL1kMOER8cTx6A,13614
+Rhapso/solver/global_optimization.py,sha256=Yl9_GlZDVLHtYtmlRY7qS0CX7c3c4zYxexIaGJVtsGY,13720
 Rhapso/solver/model_and_tile_setup.py,sha256=WqCK9_sSMJ5MFmvIYi1_x1Sx_9giYORpCfcirZsMNOI,4889
 Rhapso/solver/pre_align_tiles.py,sha256=BccXMr5cZILM8U0ZzhUyflQYx_WUQzvNDdX-S_u4Roo,11100
 Rhapso/solver/save_results.py,sha256=dIkQ3SiGNlKx5z-6k_o_O4WjANxKYLJQ059URnuxVJw,3985
@@ -87,15 +87,15 @@ Rhapso/solver/xml_to_dataframe_solver.py,sha256=u96DPnZNDa-TgimsPqyZlIvHk4A1e8yZ
 Rhapso/split_dataset/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 Rhapso/split_dataset/compute_grid_rules.py,sha256=dCAuNs4D7SaCfTXp54lchgttZVSgLH5f1tQWtkwr_ws,3028
 Rhapso/split_dataset/save_points.py,sha256=k-jH-slmxkbrxDl-uJvDkwOedi6cg7md3kg_a0NdL24,3713
-Rhapso/split_dataset/save_xml.py,sha256=Iq1UdFa8sdnWGygfIpDi4F5In-SCWggpl7lnuDTxkHE,14280
+Rhapso/split_dataset/save_xml.py,sha256=55NdzfHPGAhpR1QYaDwXPZQlZlP6T9fymhJaOwTuZh0,29561
 Rhapso/split_dataset/split_images.py,sha256=2RzAi0btV1tmh4le9QotRif1IYUU6_4pLcGGpFBM9zk,22434
 Rhapso/split_dataset/xml_to_dataframe_split.py,sha256=ByaLzJ4sqT417UiCQU31_CS_V4Jms7pjMbBl0ZdSNNA,8570
-rhapso-0.1.991.dist-info/licenses/LICENSE,sha256=U0Y7B3gZJHXpjJVLgTQjM8e_c8w4JJpLgGhIdsoFR1Y,1092
+rhapso-0.1.993.dist-info/licenses/LICENSE,sha256=U0Y7B3gZJHXpjJVLgTQjM8e_c8w4JJpLgGhIdsoFR1Y,1092
 tests/__init__.py,sha256=LYf6ZGyYRcduFFSaOLmnw3rTyfS3XLib0dsTHDWH0jo,37
 tests/test_detection.py,sha256=NtFYR_du9cbKrclQcNiJYsKzyqly6ivF61pw6_NICcM,440
 tests/test_matching.py,sha256=QX0ekSdyIkPpAsXHfSMqJUUlNZg09caSlhhUM63MduM,697
 tests/test_solving.py,sha256=t8I9XPV_4ZFM-DJpgvdYXxkG2_4DQgqs-FFyE5w8Nfg,695
-rhapso-0.1.991.dist-info/METADATA,sha256=QjjEf8EIF1t2I1mvBmN22MSawRvJNQLWV_pnh08YlZ0,19294
-rhapso-0.1.991.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
-rhapso-0.1.991.dist-info/top_level.txt,sha256=NXvsrsTfdowWbM7MxEjkDZE2Jo74lmq7ruWkp70JjSw,13
-rhapso-0.1.991.dist-info/RECORD,,
+rhapso-0.1.993.dist-info/METADATA,sha256=U_wnul9wYKBsJqbjbs2FluO8uiAbaFTqm5ntyUxfzps,19298
+rhapso-0.1.993.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
+rhapso-0.1.993.dist-info/top_level.txt,sha256=NXvsrsTfdowWbM7MxEjkDZE2Jo74lmq7ruWkp70JjSw,13
+rhapso-0.1.993.dist-info/RECORD,,