Rhapso 0.1.92__py3-none-any.whl

Rhapso/pipelines/ray/interest_point_detection.py

@@ -0,0 +1,137 @@
+from Rhapso.data_prep.xml_to_dataframe import XMLToDataFrame
+from Rhapso.detection.view_transform_models import ViewTransformModels
+from Rhapso.detection.overlap_detection import OverlapDetection
+from Rhapso.detection.metadata_builder import MetadataBuilder
+from Rhapso.detection.image_reader import ImageReader
+from Rhapso.detection.difference_of_gaussian import DifferenceOfGaussian
+from Rhapso.detection.advanced_refinement import AdvancedRefinement
+from Rhapso.detection.points_validation import PointsValidation
+from Rhapso.detection.save_interest_points import SaveInterestPoints
+import boto3
+import ray
+
+# This class implements the interest point detection pipeline
+
+class InterestPointDetection:
+    def __init__(self, dsxy, dsz, min_intensity, max_intensity, sigma, threshold, file_type, xml_file_path, 
+                 image_file_prefix, xml_output_file_path, n5_output_file_prefix, combine_distance, chunks_per_bound, run_type, 
+                 max_spots, median_filter):
+        self.dsxy = dsxy
+        self.dsz = dsz
+        self.min_intensity = min_intensity
+        self.max_intensity = max_intensity
+        self.sigma = sigma
+        self.threshold = threshold
+        self.file_type = file_type
+        self.xml_file_path = xml_file_path
+        self.image_file_prefix = image_file_prefix
+        self.xml_output_file_path = xml_output_file_path
+        self.n5_output_file_prefix = n5_output_file_prefix
+        self.combine_distance = combine_distance
+        self.chunks_per_bound = chunks_per_bound
+        self.run_type = run_type
+        self.max_spots = max_spots
+        self.median_filter = median_filter
+
+    def detection(self):
+        # Get XML file
+        if self.xml_file_path.startswith("s3://"):
+            no_scheme = self.xml_file_path.replace("s3://", "", 1)
+            bucket, key = no_scheme.split("/", 1)
+            s3 = boto3.client("s3")
+            response = s3.get_object(Bucket=bucket, Key=key)
+            xml_file = response["Body"].read().decode("utf-8")
+
+        else:  
+            with open(self.xml_file_path, "r", encoding="utf-8") as f:
+                xml_file = f.read()
+
+        # Load XML data into dataframes         
+        processor = XMLToDataFrame(xml_file)
+        dataframes = processor.run()
+        print("XML loaded")
+
+        # Create view transform matrices 
+        create_models = ViewTransformModels(dataframes)
+        view_transform_matrices = create_models.run()
+        print("Transforms models have been created")
+
+        # Use view transform matrices to find areas of overlap
+        overlap_detection = OverlapDetection(view_transform_matrices, dataframes, self.dsxy, self.dsz, self.image_file_prefix, self.file_type)
+        overlapping_area, new_dsxy, new_dsz, level, max_interval_size, mip_map_downsample = overlap_detection.run()
+        print("Overlap detection is done")
+
+        # Implement image chunking strategy as list of metadata 
+        metadata_loader = MetadataBuilder(dataframes, overlapping_area, self.image_file_prefix, self.file_type, new_dsxy, new_dsz, 
+                                          self.chunks_per_bound, self.sigma, self.run_type, level)
+        image_chunk_metadata = metadata_loader.run()
+        print("Metadata has loaded")
+
+        # Use Ray to distribute peak detection to image chunking metadata 
+        @ray.remote
+        def process_peak_detection_task(chunk_metadata, new_dsxy, new_dsz, min_intensity, max_intensity, sigma, threshold,
+                                        median_filter, mip_map_downsample):
+            try:
+                difference_of_gaussian = DifferenceOfGaussian(min_intensity, max_intensity, sigma, threshold, median_filter, mip_map_downsample)
+                image_fetcher = ImageReader(self.file_type)
+                view_id, interval, image_chunk, offset, lb = image_fetcher.run(chunk_metadata, new_dsxy, new_dsz)
+                interest_points = difference_of_gaussian.run(image_chunk, offset, lb)
+
+                return {
+                    'view_id': view_id,
+                    'interval_key': interval,
+                    'interest_points': interest_points['interest_points'],
+                    'intensities': interest_points['intensities']
+                }
+            except Exception as e:
+                return {'error': str(e), 'view_id': chunk_metadata.get('view_id', 'unknown')}
+
+        # Submit tasks to Ray
+        futures = [process_peak_detection_task.remote(chunk_metadata, new_dsxy, new_dsz, self.min_intensity, self.max_intensity, 
+                                                      self.sigma, self.threshold, self.median_filter, mip_map_downsample)
+            for chunk_metadata in image_chunk_metadata
+        ]
+
+        # Gather and process results
+        results = ray.get(futures)
+        final_peaks = [r for r in results if 'error' not in r]
+        print("Peak detection is done")
+
+        # Consolidate points and filter overlap duplicates using kd tree
+        advanced_refinement = AdvancedRefinement(final_peaks, self.combine_distance, dataframes, overlapping_area, max_interval_size, self.max_spots)
+        consolidated_data = advanced_refinement.run()
+        print("Advanced refinement is done")
+
+        # Print points metrics / validation tools
+        points_validation = PointsValidation(consolidated_data)
+        points_validation.run()
+        print("Points metrics printed")
+
+        # Save final interest points
+        save_interest_points = SaveInterestPoints(dataframes, consolidated_data, self.xml_file_path, self.xml_output_file_path, self.n5_output_file_prefix, 
+                                                  self.dsxy, self.dsz, self.min_intensity, self.max_intensity, self.sigma, self.threshold)
+        save_interest_points.run()
+        print("Interest points saved")
+    
+    def run(self):
+        self.detection()
+
+
+
+# DEBUG - to step through DOG
+# final_peaks = []
+# for chunk_metadata in image_chunk_metadata:
+#     difference_of_gaussian = DifferenceOfGaussian(
+#         self.min_intensity, self.max_intensity, self.sigma, self.threshold, self.median_filter, mip_map_downsample
+#     )
+#     image_fetcher = ImageReader(self.file_type)
+
+#     view_id, interval, image_chunk, offset, lb = image_fetcher.run(chunk_metadata, new_dsxy, new_dsz)
+#     interest_points = difference_of_gaussian.run(image_chunk, offset, lb)
+
+#     final_peaks.append({
+#         'view_id': view_id,
+#         'interval_key': interval,
+#         'interest_points': interest_points['interest_points'],
+#         'intensities': interest_points['intensities'],
+#     })

Rhapso/pipelines/ray/interest_point_matching.py

@@ -0,0 +1,110 @@
+from Rhapso.matching.xml_parser import XMLParserMatching
+from Rhapso.matching.load_and_transform_points import LoadAndTransformPoints
+from Rhapso.matching.ransac_matching import RansacMatching
+from Rhapso.matching.save_matches import SaveMatches
+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, 
+                 regularization_weight, image_file_prefix):
+        self.xml_input_path = xml_input_path
+        self.n5_output_path = n5_output_path
+        self.input_type = input_type
+        self.match_type = match_type              
+        self.num_neighbors = num_neighbors
+        self.redundancy = redundancy
+        self.significance = significance                 
+        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.num_iterations = num_iterations
+        self.regularization_weight = regularization_weight
+        self.image_file_prefix = image_file_prefix
+
+    def match(self):
+        # Load XML
+        parser = XMLParserMatching(self.xml_input_path, self.input_type)
+        data_global = parser.run()
+        print("XML loaded and parsed")
+
+        # Load and transform points
+        data_loader = LoadAndTransformPoints(data_global, self.xml_input_path, self.n5_output_path, self.match_type)
+        process_pairs, view_registrations = data_loader.run()
+        print("Points loaded and transformed into global space")
+
+        # 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,
+                       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,
+                                     input_type, image_file_prefix)
+            
+            pointsA, pointsB = matcher.filter_for_overlapping_points(pointsA, pointsB, viewA_str, viewB_str)
+
+            if len(pointsA) == 0 or len(pointsB) == 0:
+                return []
+            
+            candidates = matcher.get_candidates(pointsA, pointsB, viewA_str, viewB_str, label)
+            inliers, regularized_model = matcher.compute_ransac(candidates)
+            filtered_inliers = matcher.filter_inliers(inliers, regularized_model)
+
+            percent = 100.0 * len(filtered_inliers) / len(candidates) if candidates else 0
+            print(f"✅ RANSAC inlier percentage: {percent:.1f}% ({len(filtered_inliers)} of {len(candidates)} for {viewA_str}), {viewB_str}")
+
+            if len(filtered_inliers) < self.model_min_matches:
+                return []
+
+            return filtered_inliers if filtered_inliers else []
+
+        # --- 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.search_radius, view_registrations, self.input_type, self.image_file_prefix)
+            for pointsA, pointsB, viewA_str, viewB_str, label in process_pairs
+        ]
+
+        # --- Collect ---
+        results = ray.get(futures)
+        all_results = [inlier for sublist in results for inlier in sublist]
+
+        # --- Save ---
+        saver = SaveMatches(all_results, self.n5_output_path, data_global, self.match_type)
+        saver.run()
+        print("Matches Saved as N5")
+
+        print("Interest point matching is done")
+    
+    def run(self):
+        self.match()
+
+
+# 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,
+#                              self.input_type, self.image_file_prefix)
+    
+#     pointsA, pointsB = matcher.filter_for_overlapping_points(pointsA, pointsB, viewA_str, viewB_str)
+
+#     if len(pointsA) == 0 or len(pointsB) == 0:
+#         continue
+    
+#     candidates = matcher.get_candidates(pointsA, pointsB, viewA_str, viewB_str, label)
+#     inliers, regularized_model = matcher.compute_ransac(candidates)
+#     filtered_inliers = matcher.filter_inliers(inliers, regularized_model)
+
+#     percent = 100.0 * len(filtered_inliers) / len(candidates) if candidates else 0
+#     print(f"✅ RANSAC inlier percentage: {percent:.1f}% ({len(filtered_inliers)} of {len(candidates)} for {viewA_str}), {viewB_str}")
+
+#     if len(filtered_inliers) < self.model_min_matches:
+#         continue
+
+#     all_results.append(filtered_inliers)

Rhapso/pipelines/ray/local/alignment_pipeline.py

@@ -0,0 +1,167 @@
+from Rhapso.pipelines.ray.interest_point_detection import InterestPointDetection
+from Rhapso.pipelines.ray.interest_point_matching import InterestPointMatching
+from Rhapso.pipelines.ray.solver import Solver
+from Rhapso.pipelines.ray.split_dataset import SplitDataset
+import yaml
+import ray
+
+# Initialize Ray
+ray.init()
+
+# Point to param file
+with open("Rhapso/pipelines/ray/param/dev/zarr_s3_sean.yml", "r") as file:
+    config = yaml.safe_load(file)
+
+# -- INITIALIZE EACH COMPONENT --
+
+# INTEREST POINT DETECTION
+interest_point_detection = InterestPointDetection(
+    dsxy=config['dsxy'],
+    dsz=config['dsz'],
+    min_intensity=config['min_intensity'],
+    max_intensity=config['max_intensity'],
+    sigma=config['sigma'],
+    threshold=config['threshold'],
+    file_type=config['file_type'],
+    xml_file_path=config['xml_file_path_detection'],
+    image_file_prefix=config['image_file_prefix'],
+    xml_output_file_path=config['xml_output_file_path'],
+    n5_output_file_prefix=config['n5_output_file_prefix'],
+    combine_distance=config['combine_distance'],
+    chunks_per_bound=config['chunks_per_bound'],
+    run_type=config['detection_run_type'],
+    max_spots=config['max_spots'],
+    median_filter=config['median_filter'],
+)
+
+# INTEREST POINT MATCHING RIGID
+interest_point_matching_rigid = InterestPointMatching(
+    xml_input_path=config['xml_file_path_matching_rigid'],
+    n5_output_path=config['n5_matching_output_path'],
+    input_type = config['input_type'],
+    match_type=config['match_type_rigid'],
+    num_neighbors=config['num_neighbors_rigid'],
+    redundancy=config['redundancy_rigid'],
+    significance=config['significance_rigid'],
+    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'],
+    num_iterations=config['num_iterations_rigid'],
+    regularization_weight=config['regularization_weight_rigid'],
+    image_file_prefix=config['image_file_prefix'],
+)             
+
+# INTEREST POINT MATCHING AFFINE
+interest_point_matching_affine = InterestPointMatching(
+    xml_input_path=config['xml_file_path_matching_affine'],
+    n5_output_path=config['n5_matching_output_path'],
+    input_type = config['input_type'],
+    match_type=config['match_type_affine'],
+    num_neighbors=config['num_neighbors_affine'],
+    redundancy=config['redundancy_affine'],
+    significance=config['significance_affine'],
+    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'],
+    num_iterations=config['num_iterations_affine'],
+    regularization_weight=config['regularization_weight_affine'],
+    image_file_prefix=config['image_file_prefix'],
+)
+
+# INTEREST POINT MATCHING SPLIT AFFINE
+interest_point_matching_split_affine = InterestPointMatching(
+    xml_input_path=config['xml_file_path_matching_split_affine'],
+    n5_output_path=config['n5_matching_output_path'],
+    input_type = config['input_type'],
+    match_type=config['match_type_split_affine'],
+    num_neighbors=config['num_neighbors_split_affine'],
+    redundancy=config['redundancy_split_affine'],
+    significance=config['significance_split_affine'],
+    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'],
+    num_iterations=config['num_iterations_split_affine'],
+    regularization_weight=config['regularization_weight_split_affine'],
+    image_file_prefix=config['image_file_prefix'],
+)
+
+# SOLVER RIGID
+solver_rigid = Solver(
+    xml_file_path_output=config['xml_file_path_output_rigid'],
+    n5_input_path=config['n5_input_path'],
+    xml_file_path=config['xml_file_path_solver_rigid'],
+    run_type=config['run_type_solver_rigid'],   
+    relative_threshold=config['relative_threshold'],
+    absolute_threshold=config['absolute_threshold'],
+    min_matches=config['min_matches'],
+    damp=config['damp'],
+    max_iterations=config['max_iterations'],
+    max_allowed_error=config['max_allowed_error'],
+    max_plateauwidth=config['max_plateauwidth'],
+    metrics_output_path=config['metrics_output_path'],
+    fixed_tile=config['fixed_tile']
+)
+
+# SOLVER AFFINE
+solver_affine = Solver(
+    xml_file_path_output=config['xml_file_path_output_affine'],
+    n5_input_path=config['n5_input_path'],
+    xml_file_path=config['xml_file_path_solver_affine'],
+    run_type=config['run_type_solver_affine'],  
+    relative_threshold=config['relative_threshold'],
+    absolute_threshold=config['absolute_threshold'],
+    min_matches=config['min_matches'],
+    damp=config['damp'],
+    max_iterations=config['max_iterations'],
+    max_allowed_error=config['max_allowed_error'],
+    max_plateauwidth=config['max_plateauwidth'],
+    metrics_output_path=config['metrics_output_path'],
+    fixed_tile=config['fixed_tile']
+)
+
+# SOLVER SPLIT AFFINE
+solver_split_affine = Solver(
+    xml_file_path_output=config['xml_file_path_output_split_affine'],
+    n5_input_path=config['n5_input_path'],
+    xml_file_path=config['xml_file_path_solver_split_affine'],
+    run_type=config['run_type_solver_split_affine'],  
+    relative_threshold=config['relative_threshold'],
+    absolute_threshold=config['absolute_threshold'],
+    min_matches=config['min_matches'],
+    damp=config['damp'],
+    max_iterations=config['max_iterations'],
+    max_allowed_error=config['max_allowed_error'],
+    max_plateauwidth=config['max_plateauwidth'],
+    metrics_output_path=config['metrics_output_path'],
+    fixed_tile=config['fixed_tile']
+)
+
+# SPLIT DATASETS
+split_dataset = SplitDataset(
+    xml_file_path=config['xml_file_path_split'],
+    xml_output_file_path=config['xml_output_file_path_split'],
+    n5_path=config['n5_path_split'],
+    point_density=config['point_density'],
+    min_points=config['min_points'],
+    max_points=config['max_points'],
+    error=config['error'],
+    exclude_radius=config['exclude_radius'], 
+    target_image_size=config['target_image_size'],
+    target_overlap=config['target_overlap'],
+)
+
+# -- ALIGNMENT PIPELINE --
+# 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()

Rhapso/pipelines/ray/matching_stats.py

@@ -0,0 +1,104 @@
+import numpy as np
+from Rhapso.evaluation.alignment_threshold import AlignmentThreshold
+from Rhapso.evaluation.match_retrieval import MatchProcessor
+from Rhapso.evaluation.matching_KDE import MatchingKDE
+from Rhapso.evaluation.matching_descriptors import DescriptiveStatsMatching
+from Rhapso.evaluation.matching_voxel_vis import VoxelVis
+from Rhapso.evaluation.matching_voxelization import Voxelizer
+from Rhapso.evaluation.save_metrics import JSONFileHandler
+from Rhapso.evaluation.threshold import Threshold
+from Rhapso.evaluation.total_ips import DetectionOutput
+
+class StatsPipeline:
+    def __init__(self, args, xml_file, base_path, metrics_output_path, file_source, xml_bucket_name, KDE_type, bandwidth, view_id, pair, plot,
+                 thresholding, min_alignment, max_alignment, minimum_points, maximum_points, minimum_total_matches, maximum_total_matches, max_kde, min_kde, max_cv, min_cv ):
+        self.args = args
+        self.xml_file = xml_file
+        self.base_path = base_path
+        self.metrics_output_path = metrics_output_path
+        self.file_source = file_source
+        self.xml_bucket_name = xml_bucket_name
+        self.thresholding = thresholding
+
+        # KDE parameters
+        self.KDE_type = KDE_type
+        self.bandwidth = bandwidth
+        self.view_id = view_id
+        self.pair = pair
+        self.plot = plot
+
+        self.min_alignment = min_alignment
+        self.max_alignment = max_alignment
+        self.minimum_points = minimum_points
+        self.maximum_points = maximum_points
+        self.minimum_total_matches = minimum_total_matches
+        self.maximum_total_matches = maximum_total_matches
+        self.max_kde = max_kde
+        self.min_kde = min_kde
+        self.max_cv = max_cv
+        self.min_cv = min_cv
+
+    def run(self):
+        # Detection Output
+        detection_output = DetectionOutput(self.base_path, self.xml_file, self.metrics_output_path)
+        detection_output.run()
+        print("Detection output complete")
+
+        # Match Processing
+        processor = MatchProcessor(self.base_path, self.xml_file)
+        matches, total_matches = processor.run()
+
+        # Matching Descriptive Statistics
+        descriptive_stats = DescriptiveStatsMatching(matches, total_matches)
+        saveJSON = JSONFileHandler(self.metrics_output_path)
+        points = descriptive_stats.get_matches()
+        results = descriptive_stats.results()
+        saveJSON.update("Descriptive stats", results)
+        print("Descriptive statistics complete")
+
+        # Voxelization
+        if self.args["voxel"]:
+            voxelization = Voxelizer(points, 10)
+            voxel_info = voxelization.compute_statistics()
+            saveJSON.update("Voxelization stats", voxel_info)
+            print("Voxel statistics complete")
+
+        # Voxel Visualization
+        if self.args["voxel_vis"]:
+            voxel_vis = VoxelVis(("30", "0"), matches)
+            voxel_vis.run_voxel_vis()
+            print("Voxel visualization complete")
+
+        # KDE Analysis
+        if self.args["KDE"]:
+            kde = MatchingKDE(matches, self.KDE_type, self.bandwidth, self.view_id, self.pair, self.plot)
+            kde_result = kde.get_data()
+            saveJSON.update("KDE", kde_result)
+            print("KDE computation complete")
+
+        # Thresholding (Optional)
+        if self.thresholding:
+            threshold = Threshold(
+                    self.minimum_points,
+                    self.maximum_points,
+                    self.minimum_total_matches,
+                    self.maximum_total_matches,
+                    self.max_kde,
+                    self.min_kde,
+                    self.max_cv,
+                    self.min_cv,
+                    self.metrics_output_path,
+                )
+
+            threshold.get_metric_json()
+            threshold.run_threshold_checks()
+            # Will error out if solve has not already been ran
+            # alignmentThreshold = AlignmentThreshold(
+            #     min_alignment, max_alignment, metrics_output_path
+            # )
+            # alignmentThreshold.check_alignment()
+            print("Thresholding complete")
+
+        print("All requested metrics are complete")
+
+

Rhapso/pipelines/ray/solver.py

@@ -0,0 +1,120 @@
+from Rhapso.solver.xml_to_dataframe_solver import XMLToDataFrameSolver
+from Rhapso.solver.global_optimization import GlobalOptimization
+from Rhapso.solver.view_transforms import ViewTransformModels
+from Rhapso.solver.data_prep import DataPrep
+from Rhapso.solver.model_and_tile_setup import ModelAndTileSetup
+from Rhapso.solver.compute_tiles import ComputeTiles
+from Rhapso.solver.pre_align_tiles import PreAlignTiles
+from Rhapso.solver.connected_graphs import ConnectedGraphs
+from Rhapso.solver.concatenate_models import ConcatenateModels
+from Rhapso.solver.save_results import SaveResults
+import boto3
+
+"""
+This class implements the Solver pipeline for rigid, affine, and split-affine optimizations
+"""
+
+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):
+        self.xml_file_path_output = xml_file_path_output
+        self.n5_input_path = n5_input_path
+        self.xml_file_path = xml_file_path
+        self.run_type = run_type
+        self.relative_threshold = relative_threshold
+        self.absolute_threshold = absolute_threshold
+        self.min_matches = min_matches
+        self.damp = damp
+        self.max_iterations = max_iterations
+        self.max_allowed_error = max_allowed_error
+        self.max_plateauwidth = max_plateauwidth
+        self.metrics_output_path = metrics_output_path
+        self.fixed_tile = fixed_tile
+        self.groups = None
+        self.s3 = boto3.client('s3')
+
+    def solve(self):
+        # Get XML file
+        if self.xml_file_path.startswith("s3://"):
+            no_scheme = self.xml_file_path.replace("s3://", "", 1)
+            bucket, key = no_scheme.split("/", 1)
+            s3 = boto3.client("s3")
+            response = s3.get_object(Bucket=bucket, Key=key)
+            xml_file = response["Body"].read().decode("utf-8")
+        else:  
+            with open(self.xml_file_path, "r", encoding="utf-8") as f:
+                xml_file = f.read()
+
+        # Load XML data into dataframes         
+        processor = XMLToDataFrameSolver(xml_file)
+        dataframes = processor.run()
+        print("XML loaded")
+
+        # Get affine matrices from view registration dataframe
+        create_models = ViewTransformModels(dataframes)
+        view_transform_matrices = create_models.run()
+        print("Transforms models have been created")
+
+        # Get data from n5 folders
+        data_prep = DataPrep(dataframes['view_interest_points'], view_transform_matrices, self.xml_file_path,
+                             self.n5_input_path)
+        connected_views, corresponding_interest_points, interest_points, label_map_global, view_id_set = data_prep.run()
+        print("Data prep is complete")
+
+        # Create models, tiles, and point matches
+        model_and_tile_setup = ModelAndTileSetup(connected_views, corresponding_interest_points, interest_points, 
+                                                view_transform_matrices, view_id_set, label_map_global)
+        pmc = model_and_tile_setup.run()
+        print("Models and tiles created")    
+            
+        # Find point matches and save to each tile
+        compute_tiles = ComputeTiles(pmc, view_id_set, self.groups, dataframes, self.run_type)
+        tiles, view_map = compute_tiles.run()
+        print("Tiles are computed")
+
+        # Use matches to update transformation matrices to represent rough alignment
+        pre_align_tiles = PreAlignTiles(self.min_matches, self.run_type, self.fixed_tile)
+        tc = pre_align_tiles.run(tiles)
+        print("Tiles are pre-aligned")
+
+        # 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)
+        tiles, validation_stats = global_optimization.run()
+        print("Global optimization complete")
+        
+        if(self.run_type == "split-affine"):
+            
+            # Combine splits into groups
+            connected_graphs = ConnectedGraphs(tiles, dataframes)
+            wlpmc, groups = connected_graphs.run()
+            print("Tiles have been grouped")
+
+            # Find point matches and save to each tile
+            compute_tiles = ComputeTiles(wlpmc, view_id_set, groups, dataframes, self.run_type)
+            tiles_round_2, view_map = compute_tiles.run()
+            print("Tiles are computed")
+
+            # Use matches to update transformation matrices to represent rough alignment
+            pre_align_tiles = PreAlignTiles(self.min_matches, self.run_type, self.fixed_tile)
+            tc = pre_align_tiles.run(tiles_round_2)
+            print("Tiles are pre-aligned")
+
+            # 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)
+            tiles_round_2, validation_stats_round_2 = global_optimization.run()
+            print("Global optimization complete")
+
+            # Combine models/metrics for round 1 and 2 
+            concatenate_models = ConcatenateModels(tiles, tiles_round_2, groups, validation_stats, validation_stats_round_2, view_map)
+            tiles, validation_stats = concatenate_models.run()
+            print("Models and metrics have been combined")
+
+        # Save results to xml - one new affine matrix per view registration
+        save_results = SaveResults(tiles, xml_file, self.xml_file_path_output, self.run_type, validation_stats, self.n5_input_path)
+        save_results.run()
+        print("Results have been saved")
+    
+    def run(self):
+        self.solve()