Rhapso 0.1.92__py3-none-any.whl

Rhapso/fusion/neuroglancer_link_gen/parsers.py

@@ -0,0 +1,336 @@
+"""Module for parsing dataset info."""
+
+from typing import Dict, List, OrderedDict, Tuple
+
+import numpy as np
+import xmltodict
+import zarr
+
+from . import link_utils
+
+
+class OmeZarrParser:
+    """Class for parsing OME-Zarr datasets."""
+
+    @staticmethod
+    def parse_transform(z, res) -> Dict[str, list]:
+        """
+        Parses scale and translation transformations for a resolution level
+        in an OME-Zarr dataset.
+
+        Parameters
+        ----------
+        z : zarr.core.Array
+            Zarr array representing a dataset.
+        res : str
+            Dataset resolution to parse.
+
+        Returns
+        -------
+        Dict[str, list] A dictionary containing scale and
+        translation data for the first dataset.
+        """
+
+        # Read the metadata from .zattrs
+        try:
+            metadata = z.attrs.asdict()
+        except KeyError:
+            raise ValueError("OME-Zarr metadata not found.")
+
+        # Extract transformations for the first dataset
+        transformations = {}
+        multiscales = metadata.get("multiscales", [])
+
+        if multiscales:
+            datasets = multiscales[0].get("datasets", [])
+            for ds in datasets:
+                if ds["path"] == res:
+                    coord_transforms = ds.get("coordinateTransformations", [])
+                    scale = next(
+                        (
+                            t["scale"]
+                            for t in coord_transforms
+                            if t["type"] == "scale"
+                        ),
+                        None,
+                    )
+                    translation = next(
+                        (
+                            t["translation"]
+                            for t in coord_transforms
+                            if t["type"] == "translation"
+                        ),
+                        None,
+                    )
+                    transformations = {
+                        "scale": scale,
+                        "translation": translation,
+                    }
+                    break
+
+        return transformations
+
+    @staticmethod
+    def extract_info(
+        s3_path: str,
+    ) -> Tuple[tuple, Dict[int, str], Dict[int, np.ndarray]]:
+        """
+        Extracts voxel sizes, tile paths, and tile offsets from a given
+        OME-Zarr path.
+
+        Parameters
+        ----------
+        s3_path : str
+            Path to the OME-Zarr dataset.
+
+        Returns
+        -------
+        Tuple[tuple, Dict[int, str], Dict[int, np.ndarray]]
+            A tuple containing voxel sizes, tile paths, and tile offsets.
+        """
+        vox_sizes: tuple[float, float, float] = (
+            OmeZarrParser.extract_tile_vox_size(s3_path)
+        )
+        tile_paths: dict[int, str] = OmeZarrParser.extract_tile_paths(s3_path)
+        net_transforms: dict[int, np.ndarray] = (
+            OmeZarrParser._get_identity_mats(s3_path)
+        )
+        return vox_sizes, tile_paths, net_transforms
+
+    @staticmethod
+    def extract_tile_paths(zarr_path: str) -> Dict[int, str]:
+        """
+        Extracts tile paths from a given Zarr dataset.
+
+        Parameters
+        ----------
+        zarr_path : str
+            Path to the Zarr dataset.
+
+        Returns
+        -------
+        Dict[int, str]
+            A dictionary mapping tile indices to their paths.
+        """
+        z = zarr.open(zarr_path, mode="r")
+        return {i: k for i, k in enumerate(sorted(z.keys()))}
+
+    @staticmethod
+    def extract_tile_vox_size(zarr_path: str) -> Tuple[float, float, float]:
+        """
+        Extracts the voxel size of tiles from a given Zarr dataset.
+
+        Parameters
+        ----------
+        zarr_path : str
+            Path to the Zarr dataset.
+
+        Returns
+        -------
+        Tuple[float, float, float]
+            A tuple representing the voxel size in the x, y, and z dimensions.
+        """
+        z = zarr.open(zarr_path, mode="r")
+        first_tile = z[next(iter(z.keys()))]
+
+        return tuple(
+            reversed(
+                OmeZarrParser.parse_transform(first_tile, "0")["scale"][2:]
+            )
+        )
+
+    @staticmethod
+    def _get_identity_mats(zarr_path: str) -> Dict[int, np.ndarray]:
+        """
+        Create a homogeneous identity matrix for each tile in the dataset.
+        We need to do this because neuroglancer expects the offset to be
+        encoded in the .zattrs. The transformation matrix in the viewer
+        state should do nothing.
+
+        Parameters
+        ----------
+        zarr_path : str
+            Path to the Zarr dataset.
+
+        Returns
+        -------
+        Dict[int, np.ndarray]
+            A dictionary mapping tile indices to their offset matrices.
+        """
+        z = zarr.open(zarr_path, mode="r")
+        tile_offsets = {}
+        for i in range(len(list(z.keys()))):
+            # Use the identity matrix since the offset is already encoded in
+            # the .zattrs
+            tile_offsets[i] = np.hstack((np.eye(3), np.zeros(3).reshape(3, 1)))
+        return tile_offsets
+
+
+class XmlParser:
+    """Class for parsing BigStitcher XML datasets."""
+
+    @staticmethod
+    def extract_dataset_path(xml_path: str) -> str:
+        """
+        Parses BDV XML and extracts the dataset path.
+
+        Parameters
+        ----------
+        xml_path : str
+            Path to the XML file.
+
+        Returns
+        -------
+        str
+            Path of the dataset extracted from the XML.
+        """
+
+        # view_paths: dict[int, str] = {}
+        with open(xml_path, "r") as file:
+            data: OrderedDict = xmltodict.parse(file.read())
+
+        dataset_path = data["SpimData"]["SequenceDescription"]["ImageLoader"][
+            "zarr"
+        ]
+
+        return dataset_path["#text"]
+
+    @staticmethod
+    def extract_tile_paths(xml_path: str) -> Dict[int, str]:
+        """
+        Parses BDV XML and extracts a map of setup IDs to tile paths.
+
+        Parameters
+        ----------
+        xml_path : str
+            Path to the XML file.
+
+        Returns
+        -------
+        Dict[int, str]
+            Dictionary mapping tile IDs to their paths.
+        """
+
+        view_paths: dict[int, str] = {}
+        with open(xml_path, "r") as file:
+            data: OrderedDict = xmltodict.parse(file.read())
+
+        for id, zgroup in enumerate(
+            data["SpimData"]["SequenceDescription"]["ImageLoader"]["zgroups"][
+                "zgroup"
+            ]
+        ):
+            view_paths[int(id)] = zgroup["path"]
+
+        return view_paths
+
+    @staticmethod
+    def extract_tile_vox_size(xml_path: str) -> Tuple[float, float, float]:
+        """
+        Parses BDV XML and extracts voxel sizes.
+
+        Parameters
+        ----------
+        xml_path : str
+            Path to the XML file.
+
+        Returns
+        -------
+        Tuple[float, float, float]
+            Tuple containing voxel sizes (x, y, z).
+        """
+
+        with open(xml_path, "r") as file:
+            data: OrderedDict = xmltodict.parse(file.read())
+
+        first_tile_metadata = data["SpimData"]["SequenceDescription"][
+            "ViewSetups"
+        ]["ViewSetup"][0]
+        vox_sizes: str = first_tile_metadata["voxelSize"]["size"]
+        return tuple(float(val) for val in vox_sizes.split(" "))
+
+    @staticmethod
+    def extract_tile_transforms(xml_path: str) -> Dict[int, List[dict]]:
+        """
+        Parses BDV XML and extracts a map of setup IDs to lists of
+        transformations.
+
+        Parameters
+        ----------
+        xml_path : str
+            Path to the XML file.
+
+        Returns
+        -------
+        Dict[int, List[dict]]
+            Dictionary mapping tile IDs to lists of transformations.
+        """
+
+        view_transforms: dict[int, list[dict]] = {}
+        with open(xml_path, "r") as file:
+            data: OrderedDict = xmltodict.parse(file.read())
+
+        for view_reg in data["SpimData"]["ViewRegistrations"][
+            "ViewRegistration"
+        ]:
+            tfm_stack = view_reg["ViewTransform"]
+            if not isinstance(tfm_stack, list):
+                tfm_stack = [tfm_stack]
+            view_transforms[int(view_reg["@setup"])] = tfm_stack
+
+        view_transforms = {
+            view: tfs[::-1] for view, tfs in view_transforms.items()
+        }
+
+        return view_transforms
+
+    @staticmethod
+    def extract_info(
+        xml_path: str,
+    ) -> Tuple[tuple, Dict[int, str], Dict[int, np.ndarray]]:
+        """
+        Extracts voxel sizes, tile paths, and tile transforms from a given
+        XML path.
+
+        Parameters
+        ----------
+        xml_path : str
+            Path to the BDV XML dataset.
+
+        Returns
+        -------
+        Tuple[tuple, Dict[int, str], Dict[int, np.ndarray]]
+            A tuple containing voxel sizes, tile paths, and tile offsets.
+        """
+        vox_sizes: tuple[float, float, float] = (
+            XmlParser.extract_tile_vox_size(xml_path)
+        )
+        tile_paths: dict[int, str] = XmlParser.extract_tile_paths(xml_path)
+        tile_transforms: dict[int, list[dict]] = (
+            XmlParser.extract_tile_transforms(xml_path)
+        )
+        XmlParser.omit_initial_offsets(tile_transforms)
+        net_transforms: dict[int, np.ndarray] = (
+            link_utils.calculate_net_transforms(tile_transforms)
+        )
+        return vox_sizes, tile_paths, net_transforms
+
+    @staticmethod
+    def omit_initial_offsets(view_transforms: dict[int, list[dict]]) -> None:
+        """
+        For OME-Zarr datasets, inital offsets are
+        already encoded in the metadata and extracted my neuroglancer.
+        This function removes the duplicate transform.
+
+        Parameters
+        ------------------------
+        view_transforms: dict[int, list[dict]]
+            Dictionary of tile ids to list of transforms.
+
+        Returns
+        ------------------------
+        None
+        """
+
+        for view, tfs in view_transforms.items():
+            tfs.pop(0)

Rhapso/fusion/neuroglancer_link_gen/raw_link.py

@@ -0,0 +1,116 @@
+"""
+Library for generating raw link for visualizing tiles in nominal position.
+"""
+import numpy as np
+from parsers import XmlParser
+from . import link_utils
+from ng_state import NgState
+
+
+def generate_raw_link(
+    xml_path: str,
+    s3_path: str,
+    max_dr: int = 200,
+    opacity: float = 1.0,
+    blend: str = "default",
+    output_json_path: str = ".",
+    bucket_path: str = "aind-open-data",
+) -> None:
+    """Creates an neuroglancer link to visualize
+    raw tile placements of one color channel defined in the input xml.
+
+    Parameters
+    ------------------------
+    xml_path: str
+        Path of xml outputted by BigStitcher.
+    s3_path: str
+        Path of s3 bucket where exaspim dataset is located.
+    output_json_path: str
+        Local path to write process_output.json file that nueroglancer reads.
+    bucket_path: str
+        S3 bucket name where the process_output.json will be uploaded.
+        Default is "aind-open-data".
+
+    Returns
+    ------------------------
+    None
+    """
+    # Gather xml info
+    vox_sizes: tuple[float, float, float] = XmlParser.extract_tile_vox_size(
+        xml_path
+    )
+    tile_paths: dict[int, str] = XmlParser.extract_tile_paths(xml_path)
+
+    # Reference Pathstring:
+    # "s3://aind-open-data/diSPIM_647459_2022-12-21_00-39-00/diSPIM.zarr"
+    tile_transforms: dict[int, list[dict]] = {}
+
+    s3_list = s3_path.split("/")
+    dataset_name = s3_list[4]
+    dataset_list = dataset_name.split(".")
+    dataset_type = dataset_list[0]
+
+    if dataset_type == "diSPIM":
+        tile_transforms: dict[
+            int, list[dict]
+        ] = XmlParser.extract_tile_transforms(xml_path)
+
+    net_transforms: dict[
+        int, np.ndarray
+    ] = link_utils.calculate_net_transforms(tile_transforms)
+
+    # Determine color
+    channel: int = link_utils.extract_channel_from_tile_path(tile_paths[0])
+    hex_val: int = link_utils.wavelength_to_hex(channel)
+    hex_str = f"#{str(hex(hex_val))[2:]}"
+
+    # Generate input config
+    layers = []  # Nueroglancer Tabs
+    input_config = {
+        "dimensions": {
+            "x": {"voxel_size": vox_sizes[0], "unit": "microns"},
+            "y": {"voxel_size": vox_sizes[1], "unit": "microns"},
+            "z": {"voxel_size": vox_sizes[2], "unit": "microns"},
+            "c'": {"voxel_size": 1, "unit": ""},
+            "t": {"voxel_size": 0.001, "unit": "seconds"},
+        },
+        "layers": layers,
+        "showScaleBar": False,
+        "showAxisLines": False,
+    }
+
+    sources = []  # Tiles within tabs
+    layers.append(
+        {
+            "type": "image",  # Optional
+            "source": sources,
+            "channel": 0,  # Optional
+            "shaderControls": {
+                "normalized": {"range": [0, max_dr]}
+            },  # Optional  # Exaspim has low HDR
+            "shader": {"color": hex_str, "emitter": "RGB", "vec": "vec3",},
+            "visible": True,  # Optional
+            "opacity": opacity,
+            "name": f"CH_{channel}",
+            "blend": blend,
+        }
+    )
+
+    for tile_id, t_path in tile_paths.items():
+        source_dict = {"url": f"{s3_path}/{t_path}"}
+        if dataset_type == "diSPIM":
+            net_tf = net_transforms[tile_id]
+            final_transform = link_utils.convert_matrix_3x4_to_5x6(net_tf)
+            source_dict["transform_matrix"] = final_transform.tolist()
+
+        sources.append(source_dict)
+
+    # Generate the link
+    neuroglancer_link = NgState(
+        input_config=input_config,
+        mount_service="s3",
+        bucket_path=bucket_path,
+        output_dir=output_json_path,
+    )
+    neuroglancer_link.save_state_as_json()
+    print(neuroglancer_link.get_url_link())

Rhapso/fusion/neuroglancer_link_gen/utils/__init__.py

@@ -0,0 +1,4 @@
+"""
+Init file of utility functions
+"""
+__version__ = "0.0.1"

Rhapso/fusion/neuroglancer_link_gen/utils/shader_utils.py

@@ -0,0 +1,85 @@
+"""
+Module containing utility functions to generate neuroglancer shader code
+"""
+from typing import Tuple
+
+
+def create_monochrome_shader(color: str, emitter: str, vec: str) -> str:
+    """
+    Creates a configuration for the neuroglancer shader.
+    This shader generates a monochromatic image.
+
+    Parameters
+    ------------------------
+    color:  str
+        The color of the monochromatic image
+    emitter: str
+        suffix of WebGL emit* method being called (e.g. 'RGB')
+    vec: str
+        class of vector we want color returned as in WebGL
+        (e.g. 'vec3')
+
+    Returns
+    ------------------------
+    str
+        String with the shader configuration for neuroglancer.
+    """
+
+    # Add all necessary ui controls here
+    ui_controls = [
+        f'#uicontrol {vec} color color(default="{color}")',
+        "#uicontrol invlerp normalized",
+    ]
+
+    # color emitter
+    emit_color = (
+        "void main() {\n" + f"emit{emitter}(color * normalized());" + "\n}"
+    )
+    shader_string = ""
+
+    for ui_control in ui_controls:
+        shader_string += ui_control + "\n"
+
+    shader_string += emit_color
+
+    return shader_string
+
+
+def create_rgb_shader(
+    r_range: Tuple[int, int],
+    g_range: Tuple[int, int],
+    b_range: Tuple[int, int],
+) -> str:
+    """
+    Return shader code for an RGB image with different dynamic
+    ranges for each channel.
+
+    Parameters
+    ----------
+    r_range: Tuple[int, int]
+        Dynamic range of the R channel (min, max)
+    g_range: Tuple[int, int]
+        Dynamic range of the G channel (min, max)
+    b_range: Tuple[int, int[
+        Dynamic range of the B channel (min, max)
+
+    Returns
+    -------
+    str
+        String containing the shader code for a neuroglancer
+        RGB image.
+    """
+
+    code = "#uicontrol invlerp "
+    code += f"normalized_r(range=[{r_range[0]}, {r_range[1]}])\n"
+    code += "#uicontrol invlerp "
+    code += f"normalized_g(range=[{g_range[0]}, {g_range[1]}])\n"
+    code += "#uicontrol invlerp "
+    code += f"normalized_b(range=[{b_range[0]}, {b_range[1]}])\n"
+    code += "void main(){\n"
+    code += "float r = normalized_r(getDataValue(0));\n"
+    code += "float g = normalized_g(getDataValue(1));\n"
+    code += "float b = normalized_b(getDataValue(2));\n"
+    code += "emitRGB(vec3(r, g, b));\n}\n"
+
+    return code

Rhapso/fusion/neuroglancer_link_gen/utils/transfer.py

@@ -0,0 +1,43 @@
+"""Transfer file to S3 bucket"""
+import subprocess
+from pathlib import Path
+
+
+def copy_to_s3(file_loc: str, bucket: str = None):
+    """Copy fileout to s3 bucket, generally from a
+    /scratch location to an S3 URI
+
+    Requires AWS CLI to be installed and configured with
+    credentials.
+
+    Parameters:
+    ------------
+    file_loc: str
+    The location of the process_output.json to be copied.
+
+    bucket: str
+    The S3 Bucket URI that the masks will be copied to.
+    """
+
+    print("Copying to s3 bucket")
+    file_loc = Path(file_loc)
+    assert file_loc.exists(), f"Fileout {file_loc} does not exist."
+    file_loc = str(file_loc)
+    if bucket is None:
+        print(
+            f"No bucket specified, segmentation masks at \
+                {file_loc} not transfered"
+        )
+        return
+    else:
+        bucket = str(bucket)
+
+        cmd = f"aws s3 cp {file_loc} {bucket}"
+        try:
+            subprocess.run(cmd, shell=True)
+            print("*" * 70)
+            print("Finished Copy segmentation masks to S3!")
+            print("*" * 70)
+        except Exception as e:
+            print("Error copying to s3 bucket: ", e)
+            raise e