Rhapso 0.1.92__py3-none-any.whl

Rhapso/solver/xml_to_dataframe_solver.py

@@ -0,0 +1,213 @@
+import pandas as pd
+import xml.etree.ElementTree as ET
+
+"""
+XML to Dataframe Solver is a Solver specific XML parsing tool
+"""
+
+class XMLToDataFrameSolver:
+    def __init__(self, xml_file):
+        self.xml_content = xml_file
+
+    def parse_image_loader_zarr(self, root):
+        """
+        Parses image loader configuration from a Zarr file's XML structure and constructs a DataFrame containing the 
+        metadata for each image group.
+        """
+        image_loader_data = []
+
+        for il in root.findall(".//ImageLoader/zgroups/zgroup"):
+            view_setup = il.get("setup")
+            timepoint = il.get("timepoint")
+            file_path = il.find("path").text if il.find("path") is not None else None
+
+            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,
+                }
+            )
+
+        return pd.DataFrame(image_loader_data)
+
+    def parse_image_loader_tiff(self, root):
+        """
+        Parses image loader configuration from a TIFF file's XML structure and constructs a DataFrame containing 
+        metadata for each image group.
+        """
+        image_loader_data = []
+
+        # Ensure that file mappings are present in the XML
+        if not root.findall(".//ImageLoader/files/FileMapping"):
+            raise Exception("There are no files in this XML")
+        
+        # Check for required labels in the XML
+        if not self.check_labels(root):
+            raise Exception("Required labels do not exist")
+
+        # Validate that the lengths of view setups, registrations, and tiles match
+        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
+
+            image_loader_data.append(
+                {
+                    "view_setup": view_setup,
+                    "timepoint": timepoint,
+                    "series": series,
+                    "channel": channel,
+                    "file_path": file_path,
+                }
+            )
+
+        # Convert the list to a DataFrame and return
+        return pd.DataFrame(image_loader_data)
+    
+    def parse_image_loader_split_zarr(self):
+        pass
+
+    def route_image_loader(self, root):
+        """
+        Directs the XML parsing process based on the image loader format specified in the XML.
+        """
+        format_node = root.find(".//ImageLoader")
+        format_type = format_node.get("format")
+
+        if "filemap" in format_type:
+            return self.parse_image_loader_tiff(root)
+        else:
+            return self.parse_image_loader_zarr(root)
+
+    def parse_view_setups(self, root):
+        """
+        Parses the view setups from an XML structure and constructs a DataFrame containing metadata for each view setup.
+        """
+        viewsetups_data = []
+
+        for vs in root.findall(".//ViewSetup"):
+            id_ = vs.find("id").text
+            # name = vs.find("name").text
+            name = vs.findtext("name")
+            size = vs.find("size").text
+            voxel_unit = vs.find(".//voxelSize/unit").text
+            voxel_size = " ".join(vs.find(".//voxelSize/size").text.split())
+            attributes = {attr.tag: attr.text for attr in vs.find("attributes")}
+            viewsetups_data.append(
+                {
+                    "id": id_,
+                    "name": name,
+                    "size": size,
+                    "voxel_unit": voxel_unit,
+                    "voxel_size": voxel_size,
+                    **attributes,
+                }
+            )
+        return pd.DataFrame(viewsetups_data)
+
+    def parse_view_registrations(self, root):
+        """
+        Parses view registrations from an XML structure and constructs a DataFrame containing registration metadata 
+        for each view.
+        """
+        viewregistrations_data = []
+        for vr in root.findall(".//ViewRegistration"):
+            timepoint = vr.get("timepoint")
+            setup = vr.get("setup")
+
+            for vt in vr.findall(".//ViewTransform"):
+                affine_text = (
+                    vt.find("affine").text.replace("\n", "").replace(" ", ", ")
+                )
+                viewregistrations_data.append(
+                    {
+                        "timepoint": timepoint,
+                        "setup": setup,
+                        "type": vt.get("type"),
+                        "name": vt.find("Name").text.strip(),
+                        "affine": affine_text,
+                    }
+                )
+        return pd.DataFrame(viewregistrations_data)
+
+    def parse_view_interest_points(self, root):
+        """
+        Parses interest points data from an XML structure and constructs a DataFrame containing metadata and paths 
+        for each set of interest points.
+        """
+        view_interest_points_data = []
+
+        for vip in root.findall(".//ViewInterestPointsFile"):
+            timepoint = vip.get("timepoint")
+            setup = vip.get("setup")
+            label = vip.get("label")
+            params = vip.get("params")
+            path = vip.text.strip() if vip.text is not None else None
+            view_interest_points_data.append(
+                {
+                    "timepoint": timepoint,
+                    "setup": setup,
+                    "label": label,
+                    "params": params,
+                    "path": path,
+                }
+            )
+        return pd.DataFrame(view_interest_points_data)
+
+    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 run(self):
+        """
+        Executes the entry point of the script.
+        """
+        root = ET.fromstring(self.xml_content)
+        image_loader_df = self.route_image_loader(root)
+        view_setups_df = self.parse_view_setups(root)
+        view_registrations_df = self.parse_view_registrations(root)
+        view_interest_points_df = self.parse_view_interest_points(root)
+
+        return {
+            "image_loader": image_loader_df,
+            "view_setups": view_setups_df,
+            "view_registrations": view_registrations_df,
+            "view_interest_points": view_interest_points_df,
+        }

Rhapso/split_dataset/compute_grid_rules.py

@@ -0,0 +1,78 @@
+import math
+
+"""
+Compute Grid Rules calculates grid-safe values that align with the datasets coarsest resolution. It computes a minimal per-axis step size, 
+validates that resolutions are effectively integers, then rounds each target size/overlap up to the nearest multiple of that step.
+"""
+
+class ComputeGridRules:
+    def __init__(self, data_global, target_image_size, target_overlap):
+        self.view_setups_df = data_global['view_setups']
+        self.target_image_size = target_image_size
+        self.target_overlap = target_overlap
+
+    def closest_larger_long_divisible_by(self, a, b):
+        """
+        Find the smallest integer ≥ a that is divisible by b
+        """
+        if b <= 0:
+            raise ValueError("b must be > 0")
+        
+        if a == b or a == 0 or a % b == 0:
+            return int(a)
+        
+        return int(a + b - (a % b))
+    
+    def find_min_step_size(self):
+        """
+        Compute the minimal integer step size per axis (X,Y,Z) that is compatible with the chosen lowest resolution
+        """
+        lowest_resolution=(64.0, 64.0, 64.0)
+        min_step_size = [1, 1, 1]
+        
+        for d, r in enumerate(lowest_resolution):
+            frac = abs(r % 1.0)
+            
+            if frac > 1e-3 and (1.0 - frac) > 1e-3:
+                raise RuntimeError("Downsampling has a fraction > 0.001; cannot split dataset.")
+            
+            min_step_size[d] = math.lcm(min_step_size[d], int(round(r)))
+        
+        return min_step_size
+
+    def collect_image_sizes(self):
+        """
+        Tally how many times each raw size string appears in view setups and compute the per-axis minimum dimensions 
+        across all rows
+        """
+        sizes = {}
+        min_size = None
+        
+        for _, row in self.view_setups_df.iterrows():
+            dims = row['size']
+            sizes[dims] = sizes.get(dims, 0) + 1
+            dims = [int(x) for x in dims.split()]  
+            if min_size is None:
+                min_size = dims[:]             
+            else:
+                for d in range(len(dims)):
+                    min_size[d] = min(min_size[d], dims[d])
+        
+        return (sizes, min_size)
+
+    def run(self):
+        """
+        Executes the entry point of the script.
+        """
+        # image_sizes, min_size = self.collect_image_sizes()
+        min_step_size = self.find_min_step_size()
+        
+        sx = self.closest_larger_long_divisible_by(self.target_image_size[0], min_step_size[0])
+        sy = self.closest_larger_long_divisible_by(self.target_image_size[1], min_step_size[1])
+        sz = self.closest_larger_long_divisible_by(self.target_image_size[2], min_step_size[2])
+
+        ox = self.closest_larger_long_divisible_by(self.target_overlap[0], min_step_size[0])
+        oy = self.closest_larger_long_divisible_by(self.target_overlap[1], min_step_size[1])
+        oz = self.closest_larger_long_divisible_by(self.target_overlap[2], min_step_size[2])
+
+        return (sx, sy, sz), (ox, oy, oz), min_step_size

Rhapso/split_dataset/save_points.py

@@ -0,0 +1,101 @@
+import zarr
+import s3fs
+import numpy as np
+import boto3
+import json
+
+class SavePoints:
+    def __init__(self, label_entries, n5_prefix):
+        self.label_entries = label_entries
+        self.n5_prefix = n5_prefix
+        self.s3_filesystem = s3fs.S3FileSystem()
+        self.default_block_size = 300000
+
+    def write_json_to_s3(self, id_dataset_path, loc_dataset_path, attributes):
+        """
+        Write attributes file into both the ID and LOC dataset directories on S3
+        """
+        bucket, key = id_dataset_path.replace("s3://", "", 1).split("/", 1)
+        json_path = key + '/attributes.json'
+        json_bytes = json.dumps(attributes).encode('utf-8')
+        s3 = boto3.client('s3')
+        s3.put_object(Bucket=bucket, Key=json_path, Body=json_bytes)
+
+        bucket, key = loc_dataset_path.replace("s3://", "", 1).split("/", 1)
+        json_path = key + '/attributes.json'
+        json_bytes = json.dumps(attributes).encode('utf-8')
+        s3 = boto3.client('s3')
+        s3.put_object(Bucket=bucket, Key=json_path, Body=json_bytes)
+
+    def save_interest_points_to_n5(self):
+        for label_entry in self.label_entries:
+            n5_path = label_entry['ip_list']['n5_path']    
+            
+            if self.n5_prefix.startswith("s3://"):
+                output_path = self.n5_prefix + n5_path + "/interestpoints"
+                store = s3fs.S3Map(root=output_path, s3=self.s3_filesystem, check=False)
+                root = zarr.group(store=store, overwrite=False)
+            else:
+                output_path = self.n5_prefix + n5_path + "/interestpoints"
+                store = zarr.N5Store(output_path)
+                root = zarr.group(store, overwrite=False)
+
+            id_dataset = "id"
+            loc_dataset = "loc"
+
+            if self.n5_prefix.startswith("s3://"):
+                id_path = f"{output_path}/id"
+                loc_path = f"{output_path}/loc"
+                attrs_dict = dict(root.attrs)
+                self.write_json_to_s3(id_path, loc_path, attrs_dict)
+
+            interest_points = [point[1] for point in label_entry['ip_list']['interest_points']]
+            interest_point_ids = np.arange(len(interest_points), dtype=np.uint64).reshape(-1, 1)
+            n = 3
+
+            if len(interest_points) > 0:
+                if id_dataset in root:
+                    del root[id_dataset]
+                root.create_dataset(
+                    id_dataset,
+                    data=interest_point_ids,
+                    dtype='u8',
+                    chunks=(self.default_block_size,),
+                    compressor=zarr.GZip()
+                )
+
+                if loc_dataset in root:
+                    del root[loc_dataset]
+                root.create_dataset(
+                    loc_dataset,
+                    data=interest_points,
+                    dtype='f8',
+                    chunks=(self.default_block_size, n),
+                    compressor=zarr.GZip()
+                )
+
+            # save as empty lists
+            else:
+                if id_dataset in root:
+                    del root[id_dataset]
+                root.create_dataset(
+                    id_dataset,
+                    shape=(0,),
+                    dtype='u8',
+                    chunks=(1,),
+                    compressor=zarr.GZip()
+                )
+
+                if loc_dataset in root:
+                    del root[loc_dataset]
+                root.create_dataset(
+                    loc_dataset,
+                    shape=(0,),
+                    dtype='f8',
+                    chunks=(1,),
+                    compressor=zarr.GZip()
+                )
+
+    def run(self):
+        self.save_interest_points_to_n5()
+        return 1