Rhapso 0.1.92__py3-none-any.whl

Rhapso/matching/xml_parser.py

@@ -0,0 +1,302 @@
+import xml.etree.ElementTree as ET
+import boto3
+
+"""
+XML Parser Matching parses xml content into memory
+"""
+
+class XMLParserMatching:
+    def __init__(self, xml_input_path, input_type):
+        self.xml_input_path = xml_input_path  
+        self.input_type = input_type
+        self.data_global = None
+    
+    def check_labels(self, root):
+        """
+        Verifies the presence of required XML labels including bounding boxes, point spread functions, 
+        stitching results, and intensity adjustments.
+        """
+        labels = True
+        if root.find(".//BoundingBoxes") is None:
+            labels = False
+        if root.find(".//PointSpreadFunctions") is None:
+            labels = False
+        if root.find(".//StitchingResults") is None:
+            labels = False
+        if root.find(".//IntensityAdjustments") is None:
+            labels = False
+
+        return labels
+
+    def check_length(self, root):
+        """
+        Validates that the count of elements within the XML structure aligns with expected relationships
+        between file mappings, view setups, and view registrations.
+        """
+        length = True
+        if len(root.findall(".//ImageLoader/files/FileMapping")) != len(root.findall(".//ViewRegistration")) or \
+            len(root.findall(".//ViewSetup")) != len(root.findall(".//ViewRegistration")) * (1 / 2):
+            length = False  
+        return length
+
+    def parse_view_setup(self, root):
+        timepoints = set()
+
+        # Zarr loader 
+        for zg in root.findall(".//ImageLoader/zgroups/zgroup"):
+            tp_attr = zg.get("tp") or zg.get("timepoint") or "0"
+            try:
+                timepoints.add(int(tp_attr))
+            except ValueError:
+                pass
+
+        # Tiff loader 
+        for fm in root.findall(".//ImageLoader/files/FileMapping"):
+            tp_attr = fm.get("timepoint") or "0"
+            try:
+                timepoints.add(int(tp_attr))
+            except ValueError:
+                pass
+
+        if not timepoints:
+            timepoints = {0}
+
+        # Parse ViewSetups
+        by_id = {}
+        for vs in root.findall(".//ViewSetups/ViewSetup"):
+            sid = int(vs.findtext("id"))
+            name = (vs.findtext("name") or "").strip()
+
+            size_txt = (vs.findtext("size") or "").strip()
+            try:
+                sx, sy, sz = [int(x) for x in size_txt.split()]
+            except Exception:
+                sx = sy = sz = None
+
+            vox_txt = (vs.findtext("voxelSize/size") or "").strip()
+            try:
+                vx, vy, vz = [float(x) for x in vox_txt.split()]
+            except Exception:
+                vx = vy = vz = None
+
+            attrs = {}
+            attrs_node = vs.find("attributes")
+            if attrs_node is not None:
+                for child in list(attrs_node):
+                    txt = (child.text or "").strip()
+                    try:
+                        attrs[child.tag] = int(txt)
+                    except ValueError:
+                        attrs[child.tag] = txt
+
+            by_id[sid] = {
+                "id": sid,
+                "name": name,
+                "size": (sx, sy, sz),
+                "voxelSize": (vx, vy, vz),
+                "attributes": attrs,
+            }
+
+        viewSizes = {}
+        viewVoxelSizes = {}
+        for tp in sorted(timepoints):
+            for sid, meta in by_id.items():
+                if meta["size"] != (None, None, None):
+                    viewSizes[(tp, sid)] = meta["size"]
+                if meta["voxelSize"] != (None, None, None):
+                    viewVoxelSizes[(tp, sid)] = meta["voxelSize"]
+
+        return {
+            "byId": by_id,
+            "viewSizes": viewSizes,
+            "viewVoxelSizes": viewVoxelSizes,
+        }
+    
+    def parse_image_loader(self, root):
+        image_loader_data = []
+        
+        if self.input_type == "zarr":       
+            for il in root.findall(".//ImageLoader/zgroups/zgroup"):
+                view_setup = il.get("setup")
+                timepoint = il.get('timepoint') if 'timepoint' in il else il.get('tp')
+                file_path = (il.get("path") or il.findtext("path") or "").strip()
+                channel = file_path.split("_ch_", 1)[1].split(".ome.zarr", 1)[0]
+
+                image_loader_data.append(
+                    {
+                        "view_setup": view_setup,
+                        "timepoint": timepoint,
+                        "series": 1,
+                        "channel": channel,
+                        "file_path": file_path,
+                    }
+                )
+                
+        elif self.input_type == "tiff":
+            if not root.findall(".//ImageLoader/files/FileMapping"):
+                raise Exception("There are no files in this XML")
+            
+            if not self.check_labels(root):
+                raise Exception("Required labels do not exist")
+
+            if not self.check_length(root):
+                raise Exception(
+                    "The amount of view setups, view registrations, and tiles do not match"
+                )
+
+            # Iterate over each file mapping in the XML
+            for fm in root.findall(".//ImageLoader/files/FileMapping"):
+                view_setup = fm.get("view_setup")
+                timepoint = fm.get("timepoint")
+                series = fm.get("series")
+                channel = fm.get("channel")
+                file_path = fm.find("file").text if fm.find("file") is not None else None
+                full_path = self.xml_input_path.replace("dataset-detection.xml", "") + file_path
+                image_loader_data.append(
+                    {
+                        "view_setup": view_setup,
+                        "timepoint": timepoint,
+                        "series": series,
+                        "channel": channel,
+                        "file_path": full_path,
+                    }
+                )
+
+        return image_loader_data
+
+    def parse(self, xml_content):
+        """
+        Parse XML file or string and create complete dataset object
+        """
+        try:
+            # Check if the input is a string containing XML content
+            if str(xml_content).lstrip().startswith('<') or xml_content.strip().startswith('<?xml') or self.xml_input_path.strip().startswith('<'):
+                root = ET.fromstring(xml_content)
+            else:
+                tree = ET.parse(xml_content)
+                root = tree.getroot()
+            
+            self.data_global = {
+                'basePathURI': root.find(".//BasePath").text if root.find(".//BasePath") is not None else "",
+                'viewRegistrations': self._parse_view_registrations(root),
+                'viewsInterestPoints': self._parse_view_paths(root),
+                'imageLoader': self.parse_image_loader(root),
+                'viewSetup': self.parse_view_setup(root)
+            }
+            return self.data_global
+            
+        except Exception as e:
+            print(f"❌ Error parsing XML content: {e}")
+            raise
+
+    def _parse_view_registrations(self, root):
+        """
+        Parse ViewRegistration entries from XML
+        """
+        view_registrations = {}
+        
+        # Find all ViewRegistration elements
+        for view_reg in root.findall(".//ViewRegistration"):
+            try:
+                # Extract timepoint and setup
+                timepoint = int(view_reg.get('timepoint'))
+                setup = int(view_reg.get('setup'))
+                view_id = (timepoint, setup)
+                
+                # Parse all ViewTransform elements for this view
+                transforms = []
+                for transform_elem in view_reg.findall("ViewTransform"):
+                    transform_type = transform_elem.get('type', 'unknown')
+                    
+                    # Extract the Name element
+                    name_elem = transform_elem.find('Name')
+                    transform_name = name_elem.text.strip() if name_elem is not None and name_elem.text else f"Unnamed_{transform_type}"
+                    
+                    # Extract the affine transformation matrix
+                    affine_elem = transform_elem.find('affine')
+                    if affine_elem is not None and affine_elem.text:
+                        affine_text = affine_elem.text.strip()
+                        
+                        transform_data = {
+                            'type': transform_type,
+                            'name': transform_name,
+                            'affine': affine_text
+                        }
+                        transforms.append(transform_data)
+                    else:
+                        print(f"  ⚠️ No affine data found for transform type='{transform_type}', name='{transform_name}'")
+                        pass
+                
+                if transforms:
+                    view_registrations[view_id] = transforms
+                else:
+                    print(f"⚠️ No valid transforms found for view {view_id}")
+                    pass
+                    
+            except Exception as e:
+                print(f"❌ Error parsing ViewRegistration: {e}")
+                continue
+        
+        return view_registrations
+
+    def _parse_view_paths(self, root):
+        """Parse view interest point file paths"""
+        view_paths = {}
+        for vip in root.findall(".//ViewInterestPointsFile"):
+            setup_id = int(vip.attrib['setup']) 
+            timepoint = int(vip.attrib['timepoint'])
+            label = vip.attrib.get('label', 'beads') 
+            params = vip.attrib.get('params', '')
+            path = (vip.text or '').strip().split('/', 1)[0]
+            
+            key = (timepoint, setup_id)
+            
+            if key in view_paths and label not in view_paths[key]['label']:
+                view_paths[key]['label'].append(label)
+            else:
+                view_paths[key] = {
+                    'timepoint': timepoint, 
+                    'setup': setup_id,
+                    'label': [label],
+                    'params': params,
+                    'path': path
+                }
+            
+        return view_paths
+    
+    def fetch_local_xml(self, file_path):
+        try:
+            with open(file_path, "r", encoding="utf-8") as file:
+                return file.read()
+        except FileNotFoundError:
+            print(f"pipeline failed, could not find xml file located at '{file_path}'")
+            return None
+        except Exception as e:
+            print(f"pipeline failed, error while parsing xml file at '{file_path}': {e}")
+            return None
+    
+    def get_xml_content(self):
+        if self.xml_input_path.startswith('s3://'):
+            s3_path = self.xml_input_path[5:]  
+            parts = s3_path.split('/', 1)
+            bucket_name = parts[0]
+            file_key = parts[1]
+            s3_client = boto3.client('s3')
+            response = s3_client.get_object(Bucket=bucket_name, Key=file_key)
+            xml_content = response["Body"].read().decode("utf-8")
+            
+        else:
+            xml_content = self.fetch_local_xml(self.xml_input_path)
+            if xml_content is None:
+                return None, None
+        
+        return xml_content
+    
+    def run(self):
+        """
+        Executes the entry point of the script.
+        """
+        xml_content = self.get_xml_content()
+        data_global = self.parse(xml_content)
+        return data_global
+

Rhapso/pipelines/ray/aws/alignment_pipeline.py

@@ -0,0 +1,227 @@
+from Rhapso.pipelines.ray.solver import Solver
+import yaml
+import subprocess
+import json
+import base64, json
+from pathlib import Path
+
+with open("Rhapso/pipelines/ray/param/dev/zarr_s3_sean.yml", "r") as file:
+    config = yaml.safe_load(file)
+
+serialized_config = base64.b64encode(json.dumps(config).encode()).decode()
+
+# Detection run command
+detection_cmd = (
+    "bash -lc \""
+    "python3 - <<\\\"PY\\\"\n"
+    "import sys, json, base64\n"
+    "from Rhapso.pipelines.ray.interest_point_detection import InterestPointDetection\n"
+    f"cfg = json.loads(base64.b64decode(\\\"{serialized_config}\\\").decode())\n"
+    "ipd = InterestPointDetection(\n"
+    "    dsxy=cfg[\\\"dsxy\\\"], dsz=cfg[\\\"dsz\\\"],\n"
+    "    min_intensity=cfg[\\\"min_intensity\\\"], max_intensity=cfg[\\\"max_intensity\\\"],\n"
+    "    sigma=cfg[\\\"sigma\\\"], threshold=cfg[\\\"threshold\\\"], file_type=cfg[\\\"file_type\\\"],\n"
+    "    xml_file_path=cfg[\\\"xml_file_path_detection\\\"],\n"
+    "    image_file_prefix=cfg[\\\"image_file_prefix\\\"],\n"
+    "    xml_output_file_path=cfg[\\\"xml_output_file_path\\\"], n5_output_file_prefix=cfg[\\\"n5_output_file_prefix\\\"],\n"
+    "    combine_distance=cfg[\\\"combine_distance\\\"],\n"
+    "    chunks_per_bound=cfg[\\\"chunks_per_bound\\\"], run_type=cfg[\\\"detection_run_type\\\"],\n"
+    "    max_spots=cfg[\\\"max_spots\\\"], median_filter=cfg[\\\"median_filter\\\"],\n"
+    ")\n"
+    "ipd.run()\n"
+    "PY\n"
+    "\""
+)
+
+# Rigid Matching run command
+matching_cmd_rigid = (
+    "bash -lc \""
+    "python3 - <<\\\"PY\\\"\n"
+    "import json, base64\n"
+    "from Rhapso.pipelines.ray.interest_point_matching import InterestPointMatching\n"
+    f"cfg = json.loads(base64.b64decode(\\\"{serialized_config}\\\").decode())\n"
+    "ipm = InterestPointMatching(\n"
+    "    xml_input_path=cfg[\\\"xml_file_path_matching_rigid\\\"],\n"
+    "    n5_output_path=cfg[\\\"n5_matching_output_path\\\"],\n"
+    "    input_type=cfg[\\\"input_type\\\"],\n"
+    "    match_type=cfg[\\\"match_type_rigid\\\"],\n"
+    "    num_neighbors=cfg[\\\"num_neighbors_rigid\\\"],\n"
+    "    redundancy=cfg[\\\"redundancy_rigid\\\"],\n"
+    "    significance=cfg[\\\"significance_rigid\\\"],\n"
+    "    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"
+    "    num_iterations=cfg[\\\"num_iterations_rigid\\\"],\n"
+    "    regularization_weight=cfg[\\\"regularization_weight_rigid\\\"],\n"
+    "    image_file_prefix=cfg[\\\"image_file_prefix\\\"]\n"
+    ")\n"
+    "ipm.run()\n"
+    "PY\n"
+    "\""
+)
+
+# Affine matching run command
+matching_cmd_affine = (
+    "bash -lc \""
+    "python3 - <<\\\"PY\\\"\n"
+    "import json, base64\n"
+    "from Rhapso.pipelines.ray.interest_point_matching import InterestPointMatching\n"
+    f"cfg = json.loads(base64.b64decode(\\\"{serialized_config}\\\").decode())\n"
+    "ipm = InterestPointMatching(\n"
+    "    xml_input_path=cfg[\\\"xml_file_path_matching_affine\\\"],\n"
+    "    n5_output_path=cfg[\\\"n5_matching_output_path\\\"],\n"
+    "    input_type=cfg[\\\"input_type\\\"],\n"
+    "    match_type=cfg[\\\"match_type_affine\\\"],\n"
+    "    num_neighbors=cfg[\\\"num_neighbors_affine\\\"],\n"
+    "    redundancy=cfg[\\\"redundancy_affine\\\"],\n"
+    "    significance=cfg[\\\"significance_affine\\\"],\n"
+    "    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"
+    "    num_iterations=cfg[\\\"num_iterations_affine\\\"],\n"
+    "    regularization_weight=cfg[\\\"regularization_weight_affine\\\"],\n"
+    "    image_file_prefix=cfg[\\\"image_file_prefix\\\"]\n"
+    ")\n"
+    "ipm.run()\n"
+    "PY\n"
+    "\""
+)
+
+# Split affine matching run command
+matching_cmd_split_affine = (
+    "bash -lc \""
+    "python3 - <<\\\"PY\\\"\n"
+    "import json, base64\n"
+    "from Rhapso.pipelines.ray.interest_point_matching import InterestPointMatching\n"
+    f"cfg = json.loads(base64.b64decode(\\\"{serialized_config}\\\").decode())\n"
+    "ipm = InterestPointMatching(\n"
+    "    xml_input_path=cfg[\\\"xml_file_path_matching_split_affine\\\"],\n"
+    "    n5_output_path=cfg[\\\"n5_matching_output_path\\\"],\n"
+    "    input_type=cfg[\\\"input_type\\\"],\n"
+    "    match_type=cfg[\\\"match_type_split_affine\\\"],\n"
+    "    num_neighbors=cfg[\\\"num_neighbors_split_affine\\\"],\n"
+    "    redundancy=cfg[\\\"redundancy_split_affine\\\"],\n"
+    "    significance=cfg[\\\"significance_split_affine\\\"],\n"
+    "    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"
+    "    num_iterations=cfg[\\\"num_iterations_split_affine\\\"],\n"
+    "    regularization_weight=cfg[\\\"regularization_weight_split_affine\\\"],\n"
+    "    image_file_prefix=cfg[\\\"image_file_prefix\\\"]\n"
+    ")\n"
+    "ipm.run()\n"
+    "PY\n"
+    "\""
+)
+
+# Split run command
+split_cmd = (
+    "bash -lc \""
+    "python3 - <<\\\"PY\\\"\n"
+    "import sys, json, base64\n"
+    "from Rhapso.pipelines.ray.split_dataset import SplitDataset\n"
+    f"cfg = json.loads(base64.b64decode(\\\"{serialized_config}\\\").decode())\n"
+    "split = SplitDataset(\n"
+    "    xml_file_path=cfg[\\\"xml_file_path_split\\\"],\n"
+    "    xml_output_file_path=cfg[\\\"xml_output_file_path_split\\\"],\n"
+    "    n5_path=cfg[\\\"n5_path_split\\\"], point_density=cfg[\\\"point_density\\\"], min_points=cfg[\\\"min_points\\\"],\n"
+    "    max_points=cfg[\\\"max_points\\\"],\n"
+    "    error=cfg[\\\"error\\\"],\n"
+    "    exclude_radius=cfg[\\\"exclude_radius\\\"], target_image_size=cfg[\\\"target_image_size\\\"],\n"
+    "    target_overlap=cfg[\\\"target_overlap\\\"],\n"
+    ")\n"
+    "split.run()\n"
+    "PY\n"
+    "\""
+)
+
+# Rigid solver run command
+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']
+)
+
+# Affine solver run command
+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']
+)
+
+prefix = (Path(__file__).resolve().parent / "config/dev").as_posix()
+unified_yml = "alignment_cluster_sean.yml"
+
+def exec_on_cluster(name, yml, cmd, cwd):
+    print(f"\n=== {name} ===")
+    print("$", " ".join(["ray", "exec", yml, cmd]))
+    subprocess.run(["ray", "exec", yml, cmd], check=True, cwd=cwd)
+
+print("\n=== Start cluster ===")
+print("$", " ".join(["ray", "up", unified_yml, "-y"]))
+subprocess.run(["ray", "up", unified_yml, "-y"], check=True, cwd=prefix)
+
+try:
+    exec_on_cluster("Detection", unified_yml, detection_cmd, prefix)
+    exec_on_cluster("Matching (rigid)", unified_yml, matching_cmd_rigid, prefix)
+    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.")
+
+except subprocess.CalledProcessError as e:
+    print(f"❌ Pipeline error: {e}")
+    raise
+
+finally:
+    print("\n=== Tear down cluster ===")
+    print("$", " ".join(["ray", "down", unified_yml, "-y"]))
+    subprocess.run(["ray", "down", unified_yml, "-y"], cwd=prefix)
+
+print("\n✅ Pipeline complete.")

Rhapso/pipelines/ray/evaluation.py

@@ -0,0 +1,71 @@
+import json
+
+class MetricReviewCLI:
+    def __init__(self, file_path, matching_affine, solve_affine, matching_rigid, solve_rigid):
+        self.file_path = file_path
+        self.data = {}
+        self.matching_affine = matching_affine
+        self.solve_affine = solve_affine
+        self.matching_rigid = matching_rigid
+        self.solve_rigid = solve_rigid
+
+    def retrieve_data(self):
+        try:
+            with open(self.file_path, 'r') as file:
+                self.data = json.load(file)
+        except: 
+            return "Data cannot be retrieved"
+
+    def descriptive_stats(self):
+        print("Retrieving statistics")
+        return self.data.get("Descriptive stats", {})
+
+    def voxel_stats(self):
+        print("Retrieving statistics")
+        return self.data.get("Voxelization stats", {})
+
+    def kde_stats(self):
+        print("Retrieving statistics")
+        return self.data.get("KDE", {})
+
+    def alignment(self):
+        print("Retrieving statistics")
+        return self.data.get("alignment errors", "Solve has not been ran yet or no tiles were compared.")
+
+    def review_data(self, step_name, method_func):
+        while True:
+            print(f"\n--- Reviewing {step_name} ---")
+            result = method_func()
+            print("Data:", result)
+
+            while True:
+                choice = input("Options: [r]erun, [c]ontinue, [q]quit: ").strip().lower()
+                if choice == "r":
+                    choice2 = input("Options: rerun [a]ffine, [r]igid, go [b]ack to review: ").strip().lower()
+                    if choice2 == "a":
+                        self.matching_affine.run()
+                        self.solve_affine.run()
+                        self.run()
+                        return
+                    elif choice2 == "r":
+                        self.matching_rigid.run()
+                        self.solve_rigid.run()
+                        self.run()
+                        return
+                    elif choice2 == "b":
+                        break
+                elif choice == "c":
+                    return
+                elif choice == "q":
+                    print("Exiting CLI.")
+                    exit()
+                else:
+                    print("Invalid choice. Please try again.")
+
+    def run(self):
+        self.retrieve_data()
+        self.review_data("Base statistics", self.descriptive_stats)
+        self.review_data("Voxelization", self.voxel_stats)
+        self.review_data("KDE stats", self.kde_stats)
+        self.review_data("Alignment Statistic", self.alignment)
+        print("\nAll steps completed.")