waveorder 2.2.1__py3-none-any.whl → 3.0.0__py3-none-any.whl

waveorder/scripts/launch_napari.py

@@ -0,0 +1,13 @@
+import napari
+
+from waveorder.plugin.main_widget import MainWidget
+
+
+def main():
+    viewer = napari.Viewer()
+    viewer.window.add_dock_widget(MainWidget(viewer))
+    napari.run()
+
+
+if __name__ == "__main__":
+    main()

waveorder/scripts/repeat-cal-acq-rec.py

@@ -0,0 +1,147 @@
+# This script can be modified to debug and test calibrations
+
+import random
+import time
+from contextlib import contextmanager
+
+import napari
+from pycromanager import Core
+
+from waveorder.plugin.main_widget import MainWidget
+
+SAVE_DIR = "."
+SWING = 0.05
+CAL_REPEATS = 3
+BKG_REPEATS = 3
+
+
+@contextmanager
+def stage_detour(app: MainWidget, dx: float, dy: float, wait=5):
+    """Context manager to temporarily move the stage to a new XY-position.
+
+    Parameters
+    ----------
+    app : MainWidget
+        waveorder main widget instance
+    dx : float
+        relative x to translate
+    dy : float
+        relative y to translate
+    wait : int, optional
+        time to wait for the stage to complete movement, by default 5
+
+    Yields
+    ------
+    MainWidget
+        waveorder main widget instance
+
+    Usage
+    -----
+    ```py
+    with stage_detour(app) as app:
+        pass # do something at the new location
+    ```
+    """
+    xy_stage = app.mmc.getXYStageDevice()
+    # get the original position
+    ox = app.mmc.getXPosition(xy_stage)
+    oy = app.mmc.getYPosition(xy_stage)
+    # go to a translated position
+    # TODO: args are floored due to a pycromanager bug: https://github.com/micro-manager/pycro-manager/issues/67
+    app.mmc.setRelativeXYPosition(int(dx), int(dy))
+    time.sleep(wait)
+    try:
+        yield app
+    finally:
+        # go back to the original position
+        # TODO: args are floored due to a pycromanager bug: https://github.com/micro-manager/pycro-manager/issues/67
+        app.mmc.setXYPosition(int(ox), int(oy))
+        time.sleep(wait)
+
+
+def measure_fov(mmc: Core):
+    """Calculate the MM FOV in micrometers.
+
+    Parameters
+    ----------
+    mmc : Core
+        MMCore object via pycromanager (with CamelCase set to `True`)
+
+    Returns
+    -------
+    tuple[float, float]
+        FOV size (x, y)
+    """
+    pixel_size = float(mmc.getPixelSizeUm())
+    if pixel_size == 0:
+        float(
+            input(
+                "Pixel size is not calibrated. Please provide an estimate (in micrometers):"
+            )
+        )
+    fov_x = pixel_size * float(mmc.getImageWidth())
+    fov_y = pixel_size * float(mmc.getImageHeight())
+    return fov_x, fov_y
+
+
+def rand_shift(length: float):
+    """Randomly signed shift of a certain length.
+
+    Parameters
+    ----------
+    length : float
+        absolote length in micrometers
+
+    Returns
+    -------
+    float
+        +length or -length
+    """
+    sign = random.randint(0, 1) * 2 - 1
+    return sign * length
+
+
+def main():
+    viewer = napari.Viewer()
+    app = MainWidget(viewer)
+    viewer.window.add_dock_widget(app)
+    app.ui.qbutton_gui_mode.click()
+    app.calib_scheme = "5-State"
+    app.directory = SAVE_DIR
+    app.save_directory = SAVE_DIR
+
+    fov_x, fov_y = measure_fov(app.mmc)
+
+    input("Please center the target in the FOV and hit <Enter>")
+
+    for cal_repeat in range(CAL_REPEATS):
+        dx = rand_shift(fov_x)
+        dy = rand_shift(fov_y)
+        # run calibration
+        with stage_detour(app, dx, dy) as app:
+            print(f"Calibration repeat # {cal_repeat}")
+            app.swing = SWING
+
+            print(f"Calibrating with swing = {SWING}")
+            app.run_calibration()
+            time.sleep(90)
+
+        for bkg_repeat in range(BKG_REPEATS):
+            # capture background
+            with stage_detour(app, dx, dy) as app:
+                print(f">>> Background repeat # {bkg_repeat}")
+                app.last_calib_meta_file = app.calib.meta_file
+                app.capture_bg()
+                time.sleep(20)
+            app.ui.cb_bg_method.setCurrentIndex(
+                1
+            )  # Set to "Measured" bg correction
+            app.enter_bg_correction()
+            app.save_name = f"cal-{cal_repeat}-bkg-{bkg_repeat}"
+            app.enter_acq_bg_path()
+            app.acq_ret_ori()
+            time.sleep(15)
+
+
+if __name__ == "__main__":
+    main()

waveorder/scripts/repeat-calibration.py

@@ -0,0 +1,31 @@
+# This script can be modified to debug and test calibrations
+
+import time
+
+import napari
+
+from waveorder.plugin.main_widget import MainWidget
+
+SAVE_DIR = "./"
+SWINGS = [0.1, 0.03, 0.01, 0.005]
+REPEATS = 5
+
+
+def main():
+    viewer = napari.Viewer()
+    waveorder = MainWidget(viewer)
+    viewer.window.add_dock_widget(waveorder)
+    waveorder.ui.qbutton_connect_to_mm.click()
+    waveorder.calib_scheme = "5-State"
+
+    for repeat in range(REPEATS):
+        for swing in SWINGS:
+            print("Calibrating with swing = " + str(swing))
+            waveorder.swing = swing
+            waveorder.directory = SAVE_DIR
+            waveorder.run_calibration()
+            time.sleep(100)
+
+
+if __name__ == "__main__":
+    main()

waveorder/scripts/samples.py

@@ -0,0 +1,85 @@
+import shutil
+from pathlib import Path
+from typing import Literal
+
+from iohub import open_ome_zarr
+from iohub.ngff import Plate
+from napari.utils.notifications import show_warning
+from platformdirs import user_data_dir
+from wget import download
+
+
+def _build_layer_list(dataset: Plate, layer_names: list[str]):
+    layer_list = []
+    for channel_name in layer_names:
+        channel_index = dataset.channel_names.index(channel_name)
+        position = dataset["0/0/0"]
+        data = (position["0"][:, channel_index],)
+        layer_dict = {"name": channel_name, "scale": position.scale[3:]}
+        layer_list.append((data, layer_dict))
+
+    return layer_list
+
+
+def download_and_unzip(data_type: Literal["target", "embryo"]) -> tuple[Path]:
+    """Downloads sample data .zip from zenodo, unzips, and returns Paths to the .zarr datasets.
+
+    Skips the download if the files already exist.
+
+    Uses platformdirs.user_data_dir to store data.
+    """
+
+    # Delete old data
+    old_data_dirs = ["waveorder-sample-v1.4"]
+    for old_data_dir in old_data_dirs:
+        old_data_path = Path(user_data_dir(old_data_dir))
+        if old_data_path.exists():
+            shutil.rmtree(str(old_data_path))
+
+    temp_dirpath = Path(user_data_dir("waveorder-sample-v1.5"))
+    temp_dirpath.mkdir(exist_ok=True, parents=True)
+
+    if data_type == "target":
+        data_dirpath = temp_dirpath / "sample_contribution"
+        data_size = "10 MB"
+        data_url = "https://zenodo.org/record/8386856/files/sample_contribution.zip?download=1"
+    elif data_type == "embryo":
+        data_dirpath = temp_dirpath / "sample_contribution_embryo"
+        data_size = "92 MB"
+        data_url = "https://zenodo.org/record/8386856/files/sample_contribution_embryo.zip?download=1"
+
+    if not data_dirpath.with_suffix(".zip").exists():
+        show_warning(
+            f"Downloading {data_size} sample contribution. This might take a moment..."
+        )
+        download(data_url, out=str(temp_dirpath))
+
+    if not data_dirpath.exists():
+        shutil.unpack_archive(
+            data_dirpath.with_suffix(".zip"), extract_dir=temp_dirpath
+        )
+
+    data_path = data_dirpath / "raw_data.zarr"
+    recon_path = data_dirpath / "reconstruction.zarr"
+    return data_path, recon_path
+
+
+def read_polarization_target_data():
+    """Returns the polarization data sample contribution"""
+    data_path, _ = download_and_unzip("target")
+    dataset = open_ome_zarr(data_path)
+    return _build_layer_list(dataset, dataset.channel_names)
+
+
+def read_polarization_target_reconstruction():
+    """Returns the polarization target reconstruction sample contribution"""
+    _, recon_path = download_and_unzip("target")
+    dataset = open_ome_zarr(recon_path)
+    return _build_layer_list(dataset, ["Phase3D", "Retardance", "Orientation"])
+
+
+def read_zebrafish_embryo_reconstruction():
+    """Returns the embryo reconstruction sample contribution"""
+    _, recon_path = download_and_unzip("embryo")
+    dataset = open_ome_zarr(recon_path)
+    return _build_layer_list(dataset, ["Retardance", "Orientation"])

waveorder/scripts/simulate_zarr_acq.py

@@ -0,0 +1,204 @@
+import os
+import shutil
+import subprocess
+import threading
+import time
+from pathlib import Path
+
+from iohub.convert import TIFFConverter
+from iohub.ngff import open_ome_zarr
+
+from waveorder.cli.utils import create_empty_hcs_zarr
+
+# This script is a demo .zarr acquisition simulation from an acquired .zarr store
+# The script copies and writes additional metadata to .zattrs inserting two keys
+# The two keys are "FinalDimensions" and "CurrentDimensions".
+# The "FinalDimensions" key with (t,p,z,c) needs to be inserted when the dataset is created
+# and then should be updated at close to ensure aborted acquisitions represent correct dimensions.
+# The "CurrentDimensions" key should have the same (t,p,z,c) information and should be written out
+# either with every new image, end of dimension OR at frequent intervals.
+# Refer further notes below in the example regarding encountered issues.
+#
+# Refer to steps at the end of the file on steps to run this file
+
+
+# %% #############################################
+def convert_data(
+    tif_path, latest_out_path, prefix="", data_type_str="ometiff"
+):
+    converter = TIFFConverter(
+        os.path.join(tif_path, prefix),
+        latest_out_path,
+        data_type=data_type_str,
+        grid_layout=False,
+    )
+    converter.run()
+
+
+def run_convert(ome_tif_path):
+    out_path = os.path.join(
+        Path(ome_tif_path).parent.absolute(),
+        ("raw_" + Path(ome_tif_path).name + ".zarr"),
+    )
+    convert_data(ome_tif_path, out_path)
+
+
+# %% #############################################
+
+
+def run_acq(input_path="", waitBetweenT=30):
+
+    output_store_path = os.path.join(
+        Path(input_path).parent.absolute(),
+        ("acq_sim_" + Path(input_path).name),
+    )
+
+    if Path(output_store_path).exists():
+        shutil.rmtree(output_store_path)
+        time.sleep(1)
+
+    input_data = open_ome_zarr(input_path, mode="r")
+    channel_names = input_data.channel_names
+
+    position_keys: list[tuple[str]] = []
+
+    for path, pos in input_data.positions():
+        shape = pos["0"].shape
+        dtype = pos["0"].dtype
+        chunks = pos["0"].chunks
+        scale = (1, 1, 1, 1, 1)
+        position_keys.append(path.split("/"))
+
+    create_empty_hcs_zarr(
+        output_store_path,
+        position_keys,
+        shape,
+        chunks,
+        scale,
+        channel_names,
+        dtype,
+        {},
+    )
+    output_dataset = open_ome_zarr(output_store_path, mode="r+")
+
+    if "Summary" in input_data.zattrs.keys():
+        output_dataset.zattrs["Summary"] = input_data.zattrs["Summary"]
+
+    output_dataset.zattrs.update(
+        {
+            "FinalDimensions": {
+                "channel": shape[1],
+                "position": len(position_keys),
+                "time": shape[0],
+                "z": shape[2],
+            }
+        }
+    )
+
+    total_time = shape[0]
+    total_pos = len(position_keys)
+    total_z = shape[2]
+    total_c = shape[1]
+    for t in range(total_time):
+        for p in range(total_pos):
+            for z in range(total_z):
+                for c in range(total_c):
+                    position_key_string = "/".join(position_keys[p])
+                    img_src = input_data[position_key_string][0][t, c, z]
+
+                    img_data = output_dataset[position_key_string][0]
+                    img_data[t, c, z] = img_src
+
+                # Note: On-The-Fly dataset reconstruction will throw Permission Denied when being written
+                # Maybe we can read the zaatrs directly in that case as a file which is less blocking
+                # If this write/read is a constant issue then the zattrs 'CurrentDimensions' key
+                # should be updated less frequently, instead of current design of updating with
+                # each image
+                output_dataset.zattrs.update(
+                    {
+                        "CurrentDimensions": {
+                            "channel": total_c,
+                            "position": p + 1,
+                            "time": t + 1,
+                            "z": z + 1,
+                        }
+                    }
+                )
+
+        required_order = ["time", "position", "z", "channel"]
+        my_dict = output_dataset.zattrs["CurrentDimensions"]
+        sorted_dict_acq = {
+            k: my_dict[k]
+            for k in sorted(my_dict, key=lambda x: required_order.index(x))
+        }
+        print("Writer thread - Acquisition Dim:", sorted_dict_acq)
+
+        # reconThread = threading.Thread(target=doReconstruct, args=(output_store_path, t))
+        # reconThread.start()
+
+        time.sleep(waitBetweenT)  # sleep after every t
+
+    output_dataset.close
+
+
+def do_reconstruct(input_path, time_point):
+
+    config_path = os.path.join(
+        Path(input_path).parent.absolute(), "Bire-" + str(time_point) + ".yml"
+    )
+    output_path = os.path.join(
+        Path(input_path).parent.absolute(), "Recon_" + Path(input_path).name
+    )
+
+    print(
+        "Processing {input} time_point={tp}".format(
+            input=input_path, tp=time_point
+        )
+    )
+
+    try:
+        proc = subprocess.run(
+            [
+                "waveorder",
+                "reconstruct",
+                "-i",
+                input_path,
+                "-c",
+                config_path,
+                "-o",
+                output_path,
+                "-uid",
+                "test",
+            ]
+        )
+        if proc.returncode != 0:
+            raise Exception(
+                "An error occurred in processing ! Check terminal output."
+            )
+    except Exception as exc:
+        print(exc.args)
+
+
+# %% #############################################
+def run_acquire(input_path, waitBetweenT):
+    runThread1Acq = threading.Thread(
+        target=run_acq, args=(input_path, waitBetweenT)
+    )
+    runThread1Acq.start()
+
+
+# %% #############################################
+# Step 1:
+# Convert an existing ome-tif waveorder acquisition, preferably with all dims (t, p, z, c)
+# This will convert an existing ome-tif to a .zarr storage
+
+# ome_tif_path = "/ome-zarr_data/waveorderAcq/test/snap_6D_ometiff_1"
+# runConvert(ome_tif_path)
+
+# %% #############################################
+# Step 2:
+# run the test to simulate Acquiring a waveorder .zarr store
+
+input_path = "/ome-zarr_data/waveorderAcq/test/raw_snap_6D_ometiff_1.zarr"
+waitBetweenT = 60
+run_acquire(input_path, waitBetweenT)

waveorder/util.py

@@ -714,7 +714,7 @@ def inten_normalization(img_stack, bg_filter=True):
                 img_stack[i], size=X // 2
             )
         else:
-            img_norm_stack[i] = img_stack[i].copy()
+            img_norm_stack[i] = img_stack[i]
         img_norm_stack[i] /= torch.mean(img_norm_stack[i])
         img_norm_stack[i] -= 1
 

waveorder/visuals/napari_visuals.py

@@ -13,7 +13,7 @@ def add_transfer_function_to_viewer(
     complex_rgb: bool = False,
 ):
     zyx_shape = transfer_function.shape[-3:]
-    lim = torch.max(torch.abs(transfer_function)) * clim_factor
+    lim = (torch.max(torch.abs(transfer_function)) * clim_factor).item()
     voxel_scale = np.array(
         [
             zyx_shape[0] * zyx_scale[0],