added waveOrder reconstruction demo

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.zarr filter=lfs diff=lfs merge=lfs -text
+data/20x.zarr/A/1/*/0/c/0/0/0/0/0 filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,162 @@
+# Binary image files.
+*.tif[f]
+*.jp[e]g
+
+# pycharm IDE
+.idea
+.DS_Store
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+docs/build/
+docs/wo_examples/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+pytest_temp/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+.DS_Store
+
+# written by setuptools_scm
+*/_version.py
+waveorder/_version.py
+*.autosave
+
+# images
+*.npz
+*.tif[f]
+*.pdf
+
+# example data
+/examples/data_temp/*
+/logs/*
+runs/*
+
+# misc
+claudedocs/
+.claude/
+concatenate_3fovs.yml

README.md

@@ -1,12 +1,88 @@
 ---
-title: WaveOrder
-emoji: ⚡
-colorFrom: red
+title: waveOrder Phase Reconstruction Viewer
+emoji: 🔬
+colorFrom: blue
 colorTo: purple
 sdk: gradio
 sdk_version: 6.0.0
 app_file: app.py
 pinned: false
+license: bsd-3-clause
+tags:
+  - microscopy
+  - computational-imaging
+  - phase-reconstruction
+  - bioimaging
+  - scientific-visualization
+arxiv: 2412.09775
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# waveOrder: Phase Reconstruction Interactive Viewer
+
+<div align="center">
+
+[![arXiv](https://img.shields.io/badge/arXiv-2412.09775-b31b1b.svg)](https://arxiv.org/abs/2412.09775)
+[![GitHub](https://img.shields.io/badge/GitHub-mehta--lab%2Fwaveorder-181717?logo=github)](https://github.com/mehta-lab/waveorder)
+[![Paper Page](https://img.shields.io/badge/Paper%20Page-Hugging%20Face-ff9d00?logo=huggingface)](https://huggingface.co/papers/2412.09775)
+
+</div>
+
+## 📄 Paper
+
+**waveOrder: generalist framework for label-agnostic computational microscopy**
+Chandler et al. (2024)
+[arXiv:2412.09775](https://arxiv.org/abs/2412.09775)
+
+## 🔬 About
+
+Interactive web interface for exploring phase reconstruction from quantitative label-free microscopy data. This demo showcases the waveOrder framework's capabilities for reconstructing phase contrast images with interactive parameter optimization.
+
+### Features
+
+- **Interactive Visualization**: Side-by-side comparison of raw and reconstructed phase images
+- **Real-time Parameter Tuning**: Adjust reconstruction parameters and see results instantly
+- **Automated Optimization**: Gradient-based optimization to find optimal reconstruction parameters
+- **GPU Acceleration**: 15-25× speedup with CUDA-capable devices (auto-detected)
+- **Multi-FOV Support**: Navigate through multiple fields of view from plate imaging
+
+### Reconstruction Parameters
+
+- **Z Offset**: Axial focus calibration
+- **Numerical Apertures**: Detection and illumination NA optimization
+- **Tilt Angles**: Zenith and azimuthal illumination tilt correction
+
+## 🚀 Usage
+
+1. **Select Field of View**: Choose from available FOVs in the dropdown
+2. **Navigate Z-stack**: Use the Z-slice slider to explore different focal planes
+3. **Optimize Parameters**: Click "⚡ Optimize Parameters" to automatically find optimal settings
+4. **Manual Reconstruction**: Adjust sliders manually and click "🔬 Run Reconstruction"
+5. **Review Results**: Scrub through optimization iterations to see parameter evolution
+
+## 📊 Dataset
+
+This demo uses concatenated 20x objective microscopy data from high-content screening plates, featuring brightfield phase contrast imaging.
+
+## 🔗 Links
+
+- **Paper**: [arXiv:2412.09775](https://arxiv.org/abs/2412.09775)
+- **GitHub Repository**: [mehta-lab/waveorder](https://github.com/mehta-lab/waveorder)
+- **Documentation**: [waveOrder Docs](https://github.com/mehta-lab/waveorder/tree/main/docs)
+
+## 📝 Citation
+
+```bibtex
+@misc{chandler2024waveordergeneralistframeworklabelagnostic,
+      title={waveOrder: generalist framework for label-agnostic computational microscopy},
+      author={Talon Chandler and Eduardo Hirata-Miyasaki and Ivan E. Ivanov and Ziwen Liu and Deepika Sundarraman and Allyson Quinn Ryan and Adrian Jacobo and Keir Balla and Shalin B. Mehta},
+      year={2024},
+      eprint={2412.09775},
+      archivePrefix={arXiv},
+      primaryClass={physics.optics},
+      url={https://arxiv.org/abs/2412.09775},
+}
+```
+
+## ⚖️ License
+
+BSD 3-Clause License

app.py

@@ -1,7 +1,51 @@
-import gradio as gr
+"""
+WaveOrder Phase Reconstruction Viewer - Main Entry Point
 
-def greet(name):
-    return "Hello " + name + "!!"
+This is the main application entry point that launches the phase reconstruction
+viewer with interactive optimization capabilities.
 
-demo = gr.Interface(fn=greet, inputs="text", outputs="text")
-demo.launch()
+Usage:
+    python app.py
+
+For more details, see optimize_demo.py
+"""
+
+from optimize_demo import (
+    initialize_plate_metadata,
+    load_default_fov,
+    create_gradio_interface,
+    Config,
+)
+
+
+def main():
+    """Launch the Phase Reconstruction Viewer application."""
+    print("\n" + "=" * 60)
+    print("WaveOrder Phase Reconstruction Viewer")
+    print("=" * 60 + "\n")
+
+    # Initialize application state
+    print("Initializing application...")
+    plate_metadata, default_fields = initialize_plate_metadata()
+    data_xr, pixel_scales = load_default_fov(plate_metadata)
+
+    # Create Gradio interface
+    print("\nBuilding user interface...")
+    demo = create_gradio_interface(plate_metadata, default_fields, data_xr, pixel_scales)
+
+    # Launch application
+    print("\n" + "=" * 60)
+    print("Starting Gradio Phase Reconstruction Viewer")
+    print("=" * 60)
+    print("Open your browser to the URL shown below")
+    print("=" * 60 + "\n")
+
+    demo.launch(
+        share=False,  # Set to True to create public link
+        # server_name="0.0.0.0",  # Uncomment to allow external access
+        server_port=Config.SERVER_PORT,
+    )
+
+
+if __name__ == "__main__":
+    main()

data/20x.zarr/A/1/002026/0/c/0/0/0/0/0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:907a383d1ab54801143b6c34faaae986bb12303d6676a21f8ccc01cfce05f031
+size 42807124

data/20x.zarr/A/1/002026/0/zarr.json

@@ -0,0 +1,84 @@
+{
+  "shape": [
+    1,
+    1,
+    7,
+    2048,
+    2048
+  ],
+  "data_type": "uint16",
+  "chunk_grid": {
+    "name": "regular",
+    "configuration": {
+      "chunk_shape": [
+        1,
+        1,
+        7,
+        16384,
+        16384
+      ]
+    }
+  },
+  "chunk_key_encoding": {
+    "name": "default",
+    "configuration": {
+      "separator": "/"
+    }
+  },
+  "fill_value": 0,
+  "codecs": [
+    {
+      "name": "sharding_indexed",
+      "configuration": {
+        "chunk_shape": [
+          1,
+          1,
+          7,
+          2048,
+          2048
+        ],
+        "codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "blosc",
+            "configuration": {
+              "typesize": 2,
+              "cname": "zstd",
+              "clevel": 1,
+              "shuffle": "bitshuffle",
+              "blocksize": 0
+            }
+          }
+        ],
+        "index_codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "crc32c"
+          }
+        ],
+        "index_location": "end"
+      }
+    }
+  ],
+  "attributes": {},
+  "dimension_names": [
+    "T",
+    "C",
+    "Z",
+    "Y",
+    "X"
+  ],
+  "zarr_format": 3,
+  "node_type": "array",
+  "storage_transformers": []
+}

data/20x.zarr/A/1/002026/zarr.json

@@ -0,0 +1,86 @@
+{
+  "attributes": {
+    "ome": {
+      "multiscales": [
+        {
+          "version": "0.5",
+          "axes": [
+            {
+              "name": "T",
+              "type": "time",
+              "unit": "second"
+            },
+            {
+              "name": "C",
+              "type": "channel"
+            },
+            {
+              "name": "Z",
+              "type": "space",
+              "unit": "micrometer"
+            },
+            {
+              "name": "Y",
+              "type": "space",
+              "unit": "micrometer"
+            },
+            {
+              "name": "X",
+              "type": "space",
+              "unit": "micrometer"
+            }
+          ],
+          "datasets": [
+            {
+              "path": "0",
+              "coordinateTransformations": [
+                {
+                  "type": "scale",
+                  "scale": [
+                    1.0,
+                    1.0,
+                    2.0,
+                    0.65,
+                    0.65
+                  ]
+                }
+              ]
+            }
+          ],
+          "name": "0"
+        }
+      ],
+      "omero": {
+        "version": "0.5",
+        "id": 0,
+        "name": "002026",
+        "channels": [
+          {
+            "active": true,
+            "coefficient": 1.0,
+            "color": "FFFFFF",
+            "family": "linear",
+            "inverted": false,
+            "label": "BF",
+            "window": {
+              "start": 0.0,
+              "end": 5.0,
+              "min": 0.0,
+              "max": 65535.0
+            }
+          }
+        ],
+        "rdefs": {
+          "defaultT": 0,
+          "defaultZ": 0,
+          "model": "color",
+          "projection": "normal"
+        }
+      },
+      "version": "0.5"
+    },
+    "extra_metadata": null
+  },
+  "zarr_format": 3,
+  "node_type": "group"
+}

data/20x.zarr/A/1/002027/0/c/0/0/0/0/0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b4e974afc2a62a019249c465ca281e77aa700bf0b88903d322a48e0c5370b67b
+size 42747558

data/20x.zarr/A/1/002027/0/zarr.json

@@ -0,0 +1,84 @@
+{
+  "shape": [
+    1,
+    1,
+    7,
+    2048,
+    2048
+  ],
+  "data_type": "uint16",
+  "chunk_grid": {
+    "name": "regular",
+    "configuration": {
+      "chunk_shape": [
+        1,
+        1,
+        7,
+        16384,
+        16384
+      ]
+    }
+  },
+  "chunk_key_encoding": {
+    "name": "default",
+    "configuration": {
+      "separator": "/"
+    }
+  },
+  "fill_value": 0,
+  "codecs": [
+    {
+      "name": "sharding_indexed",
+      "configuration": {
+        "chunk_shape": [
+          1,
+          1,
+          7,
+          2048,
+          2048
+        ],
+        "codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "blosc",
+            "configuration": {
+              "typesize": 2,
+              "cname": "zstd",
+              "clevel": 1,
+              "shuffle": "bitshuffle",
+              "blocksize": 0
+            }
+          }
+        ],
+        "index_codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "crc32c"
+          }
+        ],
+        "index_location": "end"
+      }
+    }
+  ],
+  "attributes": {},
+  "dimension_names": [
+    "T",
+    "C",
+    "Z",
+    "Y",
+    "X"
+  ],
+  "zarr_format": 3,
+  "node_type": "array",
+  "storage_transformers": []
+}

data/20x.zarr/A/1/002027/zarr.json

@@ -0,0 +1,86 @@
+{
+  "attributes": {
+    "ome": {
+      "multiscales": [
+        {
+          "version": "0.5",
+          "axes": [
+            {
+              "name": "T",
+              "type": "time",
+              "unit": "second"
+            },
+            {
+              "name": "C",
+              "type": "channel"
+            },
+            {
+              "name": "Z",
+              "type": "space",
+              "unit": "micrometer"
+            },
+            {
+              "name": "Y",
+              "type": "space",
+              "unit": "micrometer"
+            },
+            {
+              "name": "X",
+              "type": "space",
+              "unit": "micrometer"
+            }
+          ],
+          "datasets": [
+            {
+              "path": "0",
+              "coordinateTransformations": [
+                {
+                  "type": "scale",
+                  "scale": [
+                    1.0,
+                    1.0,
+                    2.0,
+                    0.65,
+                    0.65
+                  ]
+                }
+              ]
+            }
+          ],
+          "name": "0"
+        }
+      ],
+      "omero": {
+        "version": "0.5",
+        "id": 0,
+        "name": "002027",
+        "channels": [
+          {
+            "active": true,
+            "coefficient": 1.0,
+            "color": "FFFFFF",
+            "family": "linear",
+            "inverted": false,
+            "label": "BF",
+            "window": {
+              "start": 0.0,
+              "end": 5.0,
+              "min": 0.0,
+              "max": 65535.0
+            }
+          }
+        ],
+        "rdefs": {
+          "defaultT": 0,
+          "defaultZ": 0,
+          "model": "color",
+          "projection": "normal"
+        }
+      },
+      "version": "0.5"
+    },
+    "extra_metadata": null
+  },
+  "zarr_format": 3,
+  "node_type": "group"
+}

data/20x.zarr/A/1/002028/0/c/0/0/0/0/0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fa115aed2ebdb7c0f15e15dbe728ee86c3189d19431c854f1515021b7578e320
+size 42727003

data/20x.zarr/A/1/002028/0/zarr.json

@@ -0,0 +1,84 @@
+{
+  "shape": [
+    1,
+    1,
+    7,
+    2048,
+    2048
+  ],
+  "data_type": "uint16",
+  "chunk_grid": {
+    "name": "regular",
+    "configuration": {
+      "chunk_shape": [
+        1,
+        1,
+        7,
+        16384,
+        16384
+      ]
+    }
+  },
+  "chunk_key_encoding": {
+    "name": "default",
+    "configuration": {
+      "separator": "/"
+    }
+  },
+  "fill_value": 0,
+  "codecs": [
+    {
+      "name": "sharding_indexed",
+      "configuration": {
+        "chunk_shape": [
+          1,
+          1,
+          7,
+          2048,
+          2048
+        ],
+        "codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "blosc",
+            "configuration": {
+              "typesize": 2,
+              "cname": "zstd",
+              "clevel": 1,
+              "shuffle": "bitshuffle",
+              "blocksize": 0
+            }
+          }
+        ],
+        "index_codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "crc32c"
+          }
+        ],
+        "index_location": "end"
+      }
+    }
+  ],
+  "attributes": {},
+  "dimension_names": [
+    "T",
+    "C",
+    "Z",
+    "Y",
+    "X"
+  ],
+  "zarr_format": 3,
+  "node_type": "array",
+  "storage_transformers": []
+}

data/20x.zarr/A/1/002028/zarr.json

@@ -0,0 +1,86 @@
+{
+  "attributes": {
+    "ome": {
+      "multiscales": [
+        {
+          "version": "0.5",
+          "axes": [
+            {
+              "name": "T",
+              "type": "time",
+              "unit": "second"
+            },
+            {
+              "name": "C",
+              "type": "channel"
+            },
+            {
+              "name": "Z",
+              "type": "space",
+              "unit": "micrometer"
+            },
+            {
+              "name": "Y",
+              "type": "space",
+              "unit": "micrometer"
+            },
+            {
+              "name": "X",
+              "type": "space",
+              "unit": "micrometer"
+            }
+          ],
+          "datasets": [
+            {
+              "path": "0",
+              "coordinateTransformations": [
+                {
+                  "type": "scale",
+                  "scale": [
+                    1.0,
+                    1.0,
+                    2.0,
+                    0.65,
+                    0.65
+                  ]
+                }
+              ]
+            }
+          ],
+          "name": "0"
+        }
+      ],
+      "omero": {
+        "version": "0.5",
+        "id": 0,
+        "name": "002028",
+        "channels": [
+          {
+            "active": true,
+            "coefficient": 1.0,
+            "color": "FFFFFF",
+            "family": "linear",
+            "inverted": false,
+            "label": "BF",
+            "window": {
+              "start": 0.0,
+              "end": 5.0,
+              "min": 0.0,
+              "max": 65535.0
+            }
+          }
+        ],
+        "rdefs": {
+          "defaultT": 0,
+          "defaultZ": 0,
+          "model": "color",
+          "projection": "normal"
+        }
+      },
+      "version": "0.5"
+    },
+    "extra_metadata": null
+  },
+  "zarr_format": 3,
+  "node_type": "group"
+}

data/20x.zarr/A/1/zarr.json

@@ -0,0 +1,26 @@
+{
+  "attributes": {
+    "ome": {
+      "well": {
+        "version": "0.5",
+        "images": [
+          {
+            "acquisition": 0,
+            "path": "002026"
+          },
+          {
+            "acquisition": 0,
+            "path": "002027"
+          },
+          {
+            "acquisition": 0,
+            "path": "002028"
+          }
+        ]
+      },
+      "version": "0.5"
+    }
+  },
+  "zarr_format": 3,
+  "node_type": "group"
+}

data/20x.zarr/A/zarr.json

@@ -0,0 +1,5 @@
+{
+  "attributes": {},
+  "zarr_format": 3,
+  "node_type": "group"
+}

data/20x.zarr/zarr.json

@@ -0,0 +1,34 @@
+{
+  "attributes": {
+    "ome": {
+      "plate": {
+        "version": "0.5",
+        "acquisitions": [
+          {
+            "id": 0
+          }
+        ],
+        "rows": [
+          {
+            "name": "A"
+          }
+        ],
+        "columns": [
+          {
+            "name": "1"
+          }
+        ],
+        "wells": [
+          {
+            "path": "A/1",
+            "rowIndex": 0,
+            "columnIndex": 0
+          }
+        ]
+      },
+      "version": "0.5"
+    }
+  },
+  "zarr_format": 3,
+  "node_type": "group"
+}

demo_utils.py

@@ -0,0 +1,818 @@
+"""
+Utility functions for Gradio demos
+
+Provides reusable components for:
+- Data loading from OME-Zarr stores
+- Image normalization and processing
+- Slice extraction from xarray DataArrays
+- Phase reconstruction and optimization
+
+Design Notes
+------------
+All image processing functions work with xarray.DataArray to maintain
+labeled dimensions and coordinate information as long as possible.
+Only convert to numpy arrays at the final display step.
+"""
+
+from pathlib import Path
+from typing import Generator
+
+import numpy as np
+import torch
+import xarray as xr
+from numpy.typing import NDArray
+from xarray_ome import open_ome_dataset
+
+from waveorder import util
+from waveorder.models import isotropic_thin_3d
+
+# Type alias for device specification
+Device = torch.device | str | None
+
+
+def get_device(device: Device = None) -> torch.device:
+    """
+    Get torch device with smart defaults.
+
+    Parameters
+    ----------
+    device : torch.device | str | None
+        If None, auto-selects cuda if available, else cpu.
+        If str, converts to torch.device.
+        If torch.device, returns as-is.
+
+    Returns
+    -------
+    torch.device
+        Validated device ready for use
+
+    Examples
+    --------
+    >>> get_device()  # Auto-detect
+    device(type='cuda', index=0)  # if GPU available
+
+    >>> get_device("cpu")  # Force CPU
+    device(type='cpu')
+
+    >>> get_device(torch.device("cuda:1"))  # Specific GPU
+    device(type='cuda', index=1)
+    """
+    if device is None:
+        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        if device.type == "cuda":
+            print(f"🚀 Using GPU: {torch.cuda.get_device_name(device)}")
+            gpu_mem_gb = torch.cuda.get_device_properties(device).total_memory / 1e9
+            print(f"   GPU Memory: {gpu_mem_gb:.2f} GB")
+        else:
+            print("💻 Using CPU (GPU not available)")
+        return device
+
+    if isinstance(device, str):
+        return torch.device(device)
+
+    return device
+
+
+# === HCS Plate Loading with iohub ===
+def get_plate_metadata(zarr_path: Path | str, allowed_fovs: list[str]) -> dict:
+    """
+    Extract HCS plate metadata for FOV selection using iohub.
+
+    Optimized to only load metadata for specified FOVs.
+
+    Parameters
+    ----------
+    zarr_path : Path | str
+        Path to the HCS plate zarr store
+    allowed_fovs : list[str]
+        List of allowed FOV names (e.g., ['002026', '002027', '002028'])
+
+    Returns
+    -------
+    dict
+        Metadata with keys:
+        - 'rows': list of row names (e.g., ['A'])
+        - 'columns': list of column names (e.g., ['1', '2', '3'])
+        - 'wells': dict mapping (row, col) to list of field names
+        - 'plate': iohub Plate object for later access
+        - 'zarr_path': stored path for data loading
+    """
+    from iohub import open_ome_zarr
+
+    # Open HCS plate with iohub (fast - doesn't load data)
+    plate = open_ome_zarr(str(zarr_path), mode="r", layout="hcs")
+
+    # Hardcoded metadata for known structure (avoids iterating 1000s of positions)
+    rows = ["A"]
+    columns = ["1", "2", "3"]
+
+    # Only return the allowed FOVs for each well
+    wells = {
+        ("A", "1"): allowed_fovs,
+        ("A", "2"): allowed_fovs,
+        ("A", "3"): allowed_fovs,
+    }
+
+    return {
+        "rows": rows,
+        "columns": columns,
+        "wells": wells,
+        "plate": plate,
+        "zarr_path": str(zarr_path),
+    }
+
+
+def load_fov_from_plate(
+    plate, row: str, column: str, field: str, resolution: int = 0
+) -> xr.DataArray:
+    """
+    Load a specific FOV from HCS plate using hybrid iohub + xarray-ome approach.
+
+    Uses iohub for navigation, then xarray-ome for fast data loading.
+
+    Parameters
+    ----------
+    plate : iohub.Plate
+        Plate loaded with open_ome_zarr(..., layout="hcs")
+    row : str
+        Row name (e.g., 'A')
+    column : str
+        Column name (e.g., '1')
+    field : str
+        Field/position name (e.g., '002026')
+    resolution : int, optional
+        Resolution level to load, by default 0
+
+    Returns
+    -------
+    xr.DataArray
+        Image data with labeled dimensions (T, C, Z, Y, X)
+    """
+    # Navigate to position using iohub (fast)
+    position_key = f"{row}/{column}/{field}"
+    position = plate[position_key]
+
+    # Get full zarr path from position (handle both Zarr V2 and V3)
+    store = position.zgroup.store
+    if hasattr(store, 'path'):
+        base_path = Path(store.path)  # Zarr V2 (DirectoryStore)
+    elif hasattr(store, 'root'):
+        base_path = Path(store.root)  # Zarr V3 (LocalStore)
+    else:
+        raise RuntimeError(f"Unknown store type: {type(store)}")
+
+    position_path = base_path / position.zgroup.path
+
+    # Load with xarray-ome (fast and reliable)
+    fov_dataset = open_ome_dataset(position_path, resolution=resolution, validate=False)
+    data_xr = fov_dataset["image"]
+
+    return data_xr
+
+
+# === Data Loading ===
+def load_ome_zarr_fov(
+    zarr_path: Path | str, fov_path: Path | str, resolution: int = 0
+) -> xr.DataArray:
+    """
+    Load a field of view from an OME-Zarr store as an xarray DataArray.
+
+    Parameters
+    ----------
+    zarr_path : Path | str
+        Path to the root OME-Zarr store
+    fov_path : Path | str
+        Relative path to the FOV (e.g., "A/1/001007")
+    resolution : int, optional
+        Resolution level to load (0 is full resolution), by default 0
+
+    Returns
+    -------
+    xr.DataArray
+        Image data with labeled dimensions (T, C, Z, Y, X)
+    """
+    zarr_path = Path(zarr_path)
+    fov_path = Path(fov_path)
+
+    print(f"Loading zarr store from: {zarr_path}")
+    print(f"Accessing FOV: {fov_path}")
+
+    # Load as xarray Dataset
+    fov_dataset: xr.Dataset = open_ome_dataset(
+        zarr_path / fov_path, resolution=resolution, validate=False
+    )
+
+    # Extract the image DataArray
+    data_xr = fov_dataset["image"]
+
+    print(f"Loaded data shape: {dict(data_xr.sizes)}")
+    print(f"Dimensions: {list(data_xr.dims)}")
+    print(f"Data type: {data_xr.dtype}")
+
+    return data_xr
+
+
+# === Image Processing ===
+def normalize_for_display(
+    img_2d: xr.DataArray,
+    percentiles: tuple[float, float] = (1, 99),
+    clip_to_uint8: bool = True,
+) -> np.ndarray:
+    """
+    Normalize a 2D microscopy image using percentile clipping.
+
+    Uses robust percentile-based normalization to handle outliers
+    common in microscopy data. Works with xarray DataArrays to maintain
+    labeled dimensions through the processing pipeline.
+
+    Parameters
+    ----------
+    img_2d : xr.DataArray
+        2D image DataArray to normalize
+    percentiles : tuple[float, float], optional
+        Lower and upper percentiles for clipping, by default (1, 99)
+    clip_to_uint8 : bool, optional
+        If True, convert to uint8 (0-255), otherwise keep as float (0-1),
+        by default True
+
+    Returns
+    -------
+    np.ndarray
+        Normalized numpy array (uint8 if clip_to_uint8=True, else float32)
+
+    Notes
+    -----
+    Expects xarray.DataArray input. For raw numpy arrays,
+    wrap in xarray first: xr.DataArray(array, dims=["Y", "X"])
+    """
+    # Calculate percentiles using xarray
+    p_low = float(img_2d.quantile(percentiles[0] / 100.0).values)
+    p_high = float(img_2d.quantile(percentiles[1] / 100.0).values)
+
+    # Handle edge case: no intensity variation
+    if p_high - p_low < 1e-10:
+        return np.zeros(img_2d.shape, dtype=np.uint8 if clip_to_uint8 else np.float32)
+
+    # Clip and normalize using xarray operations
+    img_clipped = img_2d.clip(min=p_low, max=p_high)
+    img_normalized = (img_clipped - p_low) / (p_high - p_low)
+
+    # Convert to numpy array
+    result = img_normalized.values
+
+    # Convert to requested output format
+    if clip_to_uint8:
+        result = (result * 255).astype(np.uint8)
+    else:
+        result = result.astype(np.float32)
+
+    return result
+
+
+# === Slice Extraction ===
+def extract_2d_slice(
+    data_xr: xr.DataArray,
+    t: int | None = None,
+    c: int | None = None,
+    z: int | None = None,
+    normalize: bool = True,
+    verbose: bool = True,
+) -> np.ndarray:
+    """
+    Extract and optionally normalize a 2D slice from xarray data.
+
+    Flexibly handles different dimension specifications. If a dimension
+    index is None, it will be squeezed out if size=1 or raise an error
+    if size>1.
+
+    Parameters
+    ----------
+    data_xr : xr.DataArray
+        Image data with dimensions (T, C, Z, Y, X)
+    t : int | None, optional
+        Timepoint index, by default None
+    c : int | None, optional
+        Channel index, by default None
+    z : int | None, optional
+        Z-slice index, by default None
+    normalize : bool, optional
+        Whether to normalize for display, by default True
+    verbose : bool, optional
+        Whether to print slice information, by default True
+
+    Returns
+    -------
+    np.ndarray
+        2D numpy array (normalized uint8 if normalize=True, else raw values)
+
+    Raises
+    ------
+    ValueError
+        If result is empty or not 2D after slicing and squeezing
+    """
+    # Build selection dictionary for indexed dimensions
+    sel_dict = {}
+    if t is not None:
+        sel_dict["T"] = int(t)
+    if c is not None:
+        sel_dict["C"] = int(c)
+    if z is not None:
+        sel_dict["Z"] = int(z)
+
+    # Extract slice using xarray's labeled indexing
+    slice_xr = data_xr.isel(**sel_dict) if sel_dict else data_xr
+
+    # Compute if Dask-backed (load from disk)
+    if hasattr(slice_xr.data, "compute"):
+        slice_xr = slice_xr.compute()
+
+    # Squeeze singleton dimensions (e.g., single channel, single Z)
+    slice_xr = slice_xr.squeeze()
+
+    # Validation: ensure non-empty result
+    if slice_xr.size == 0:
+        raise ValueError(
+            f"Empty array after slicing. Selection: {sel_dict}, "
+            f"Original shape: {data_xr.shape}"
+        )
+
+    # Validation: ensure 2D result
+    if slice_xr.ndim != 2:
+        raise ValueError(
+            f"Expected 2D array after slicing, got shape {slice_xr.shape}. "
+            f"Selection: {sel_dict}"
+        )
+
+    # Verbose output: print slice information
+    if verbose:
+        sel_str = (
+            ", ".join(f"{k}={v}" for k, v in sel_dict.items())
+            if sel_dict
+            else "full array"
+        )
+        print(
+            f"Extracted slice: {sel_str}, Shape={slice_xr.shape}, "
+            f"Range=[{float(slice_xr.min()):.1f}, {float(slice_xr.max()):.1f}]"
+        )
+
+    # Normalize or convert to numpy
+    if normalize:
+        slice_2d = normalize_for_display(slice_xr)
+    else:
+        slice_2d = slice_xr.values
+
+    return slice_2d
+
+
+# === Slice Extraction Factory ===
+def create_slice_extractor(
+    data_xr: xr.DataArray,
+    normalize: bool = True,
+    channel: int = 0,
+):
+    """
+    Create a closure function for extracting slices from a specific dataset.
+
+    This factory function is useful for Gradio callbacks where the data
+    is loaded once and the same extraction function is called multiple times.
+
+    Parameters
+    ----------
+    data_xr : xr.DataArray
+        Image data to extract slices from
+    normalize : bool, optional
+        Whether to normalize for display, by default True
+    channel : int, optional
+        Default channel to use, by default 0
+
+    Returns
+    -------
+    callable
+        Function with signature (t: int, z: int) -> np.ndarray that extracts
+        and normalizes 2D slices
+    """
+
+    def get_slice(t: int, z: int) -> np.ndarray:
+        """Extract and normalize a 2D slice at timepoint t and z-slice z."""
+        return extract_2d_slice(
+            data_xr,
+            t=int(t),
+            c=channel,
+            z=int(z),
+            normalize=normalize,
+            verbose=True,
+        )
+
+    return get_slice
+
+
+# === Metadata Helpers ===
+def get_dimension_info(data_xr: xr.DataArray) -> dict:
+    """
+    Extract dimension information from xarray DataArray.
+
+    Parameters
+    ----------
+    data_xr : xr.DataArray
+        Image data with dimensions
+
+    Returns
+    -------
+    dict
+        Dictionary with keys: 'sizes', 'dims', 'coords', 'dtype'
+    """
+    return {
+        "sizes": dict(data_xr.sizes),
+        "dims": list(data_xr.dims),
+        "coords": {dim: data_xr.coords[dim].values.tolist() for dim in data_xr.dims},
+        "dtype": str(data_xr.dtype),
+    }
+
+
+def print_data_summary(data_xr: xr.DataArray) -> None:
+    """
+    Print a formatted summary of xarray DataArray.
+
+    Parameters
+    ----------
+    data_xr : xr.DataArray
+        Image data to summarize
+    """
+    info = get_dimension_info(data_xr)
+
+    print("\n" + "=" * 60)
+    print("DATA SUMMARY")
+    print("=" * 60)
+    print(f"Shape: {info['sizes']}")
+    print(f"Dimensions: {info['dims']}")
+    print(f"Data type: {info['dtype']}")
+
+    # Print coordinate ranges
+    print("\nCoordinate Ranges:")
+    for dim in info["dims"]:
+        coords = info["coords"][dim]
+        if len(coords) > 0:
+            print(f"  {dim}: [{coords[0]:.2f} ... {coords[-1]:.2f}] (n={len(coords)})")
+
+    # Print memory size estimate
+    total_elements = np.prod(list(info["sizes"].values()))
+    dtype_size = np.dtype(data_xr.dtype).itemsize
+    size_mb = (total_elements * dtype_size) / (1024**2)
+    print(f"\nEstimated size: {size_mb:.1f} MB")
+    print("=" * 60 + "\n")
+
+
+# === Phase Reconstruction Functions ===
+def run_reconstruction(zyx_tile: torch.Tensor, recon_args: dict) -> torch.Tensor:
+    """
+    Run phase reconstruction on a Z-stack.
+
+    Takes a 3D stack (Z, Y, X) and produces a 2D phase reconstruction (Y, X).
+    Device is inferred from the input tensor.
+
+    Parameters
+    ----------
+    zyx_tile : torch.Tensor
+        Input Z-stack data with shape (Z, Y, X). Can be on CPU or GPU.
+    recon_args : dict
+        Reconstruction arguments including wavelength, NA, pixel sizes, etc.
+        All tensor values should be on the same device as zyx_tile.
+
+    Returns
+    -------
+    torch.Tensor
+        Reconstructed 2D phase image with shape (Y, X), on same device as input.
+
+    Notes
+    -----
+    All intermediate tensors are created on the same device as the input
+    to ensure efficient computation without device transfers.
+    """
+    # Infer device from input tensor
+    device = zyx_tile.device
+
+    # Prepare transfer function arguments - ensure all tensors are on the same device
+    tf_args = {}
+    for key, value in recon_args.items():
+        if isinstance(value, torch.Tensor):
+            tf_args[key] = value.to(device)
+        else:
+            tf_args[key] = value
+
+    Z, _, _ = zyx_tile.shape
+    tf_args["z_position_list"] = (
+        torch.arange(Z, device=device) - (Z // 2) + tf_args["z_offset"]
+    ) * tf_args["z_scale"]
+    tf_args.pop("z_offset")
+    tf_args.pop("z_scale")
+
+    # Core reconstruction calls (all on same device)
+    tf_abs, tf_phase = isotropic_thin_3d.calculate_transfer_function(**tf_args)
+    system = isotropic_thin_3d.calculate_singular_system(tf_abs, tf_phase)
+    _, yx_phase_recon = isotropic_thin_3d.apply_inverse_transfer_function(
+        zyx_tile, system, regularization_strength=1e-2
+    )
+    return yx_phase_recon
+
+
+def compute_midband_power(
+    yx_array: torch.Tensor,
+    NA_det: float,
+    lambda_ill: float,
+    pixel_size: float,
+    band: tuple[float, float] = (0.125, 0.25),
+) -> torch.Tensor:
+    """
+    Compute midband power metric for optimization loss.
+
+    Parameters
+    ----------
+    yx_array : torch.Tensor
+        2D reconstructed image (on CPU or GPU)
+    NA_det : float
+        Numerical aperture of detection
+    lambda_ill : float
+        Illumination wavelength
+    pixel_size : float
+        Pixel size in same units as wavelength
+    band : tuple[float, float], optional
+        Frequency band as fraction of cutoff, by default (0.125, 0.25)
+
+    Returns
+    -------
+    torch.Tensor
+        Scalar power value in the specified frequency band, on same device as input.
+
+    Notes
+    -----
+    All operations are performed on the same device as the input tensor
+    for efficient GPU computation.
+    """
+    device = yx_array.device
+
+    # Generate frequency coordinates (returns numpy arrays)
+    _, _, fxx, fyy = util.gen_coordinate(yx_array.shape, pixel_size)
+
+    # Convert to torch tensor on same device
+    frr = torch.tensor(np.sqrt(fxx**2 + fyy**2), dtype=torch.float32, device=device)
+
+    # FFT and frequency masking (all on device)
+    xy_abs_fft = torch.abs(torch.fft.fftn(yx_array))
+    cutoff = 2 * NA_det / lambda_ill
+    mask = torch.logical_and(frr > cutoff * band[0], frr < cutoff * band[1])
+
+    return torch.sum(xy_abs_fft[mask])
+
+
+def prepare_optimizer(
+    optimizable_params: dict[str, tuple[bool, float, float]],
+    device: torch.device,
+) -> tuple[dict[str, torch.nn.Parameter], torch.optim.Optimizer]:
+    """
+    Prepare optimization parameters and Adam optimizer.
+
+    Parameters
+    ----------
+    optimizable_params : dict
+        Dict mapping param names to (enabled, initial_value, learning_rate)
+    device : torch.device
+        Device to create parameters on (CPU or GPU)
+
+    Returns
+    -------
+    tuple[dict, Optimizer]
+        optimization_params dict and configured optimizer
+
+    Notes
+    -----
+    All parameters are created on the specified device for efficient
+    GPU-accelerated optimization if available.
+    """
+    optimization_params: dict[str, torch.nn.Parameter] = {}
+    optimizer_config = []
+    for name, (enabled, initial, lr) in optimizable_params.items():
+        if enabled:
+            param = torch.nn.Parameter(
+                torch.tensor([initial], dtype=torch.float32, device=device),
+                requires_grad=True,
+            )
+            optimization_params[name] = param
+            optimizer_config.append({"params": [param], "lr": lr})
+
+    optimizer = torch.optim.Adam(optimizer_config)
+    return optimization_params, optimizer
+
+
+def run_reconstruction_single(
+    zyx_stack: np.ndarray,
+    pixel_scales: tuple[float, float, float],
+    fixed_params: dict,
+    param_values: dict,
+    device: Device = None,
+) -> np.ndarray:
+    """
+    Run a single phase reconstruction with specified parameters (no optimization).
+
+    Parameters
+    ----------
+    zyx_stack : np.ndarray
+        Input Z-stack with shape (Z, Y, X)
+    pixel_scales : tuple[float, float, float]
+        (z_scale, y_scale, x_scale) in micrometers
+    fixed_params : dict
+        Fixed reconstruction parameters (wavelength, index, etc.)
+    param_values : dict
+        Parameter values to use (z_offset, numerical_aperture_detection, etc.)
+    device : torch.device | str | None, optional
+        Computing device. If None, auto-selects GPU if available, else CPU.
+
+    Returns
+    -------
+    np.ndarray
+        Normalized uint8 array of reconstructed phase image (for display)
+    """
+    # Resolve device (will print GPU info if available)
+    device = get_device(device)
+
+    # Convert to torch tensor on target device
+    zyx_tile = torch.tensor(zyx_stack, dtype=torch.float32, device=device)
+
+    # Prepare reconstruction arguments
+    z_scale, y_scale, x_scale = pixel_scales
+    recon_args = fixed_params.copy()
+
+    # Remove non-reconstruction parameters from fixed_params
+    recon_args.pop("num_iterations", None)
+    recon_args.pop("use_tiling", None)
+    recon_args.pop("device", None)
+
+    recon_args["yx_shape"] = zyx_tile.shape[1:]
+    recon_args["yx_pixel_size"] = y_scale
+    recon_args["z_scale"] = z_scale
+
+    # Set parameter values (convert to tensors on device)
+    for name, value in param_values.items():
+        recon_args[name] = torch.tensor([value], dtype=torch.float32, device=device)
+
+    # Run reconstruction
+    yx_recon = run_reconstruction(zyx_tile, recon_args)
+
+    # Transfer to CPU and normalize for display
+    recon_numpy = yx_recon.detach().cpu().numpy()
+    # Wrap in xarray for normalize_for_display (expects xr.DataArray)
+    recon_normalized = normalize_for_display(xr.DataArray(recon_numpy))
+
+    return recon_normalized
+
+
+def run_optimization_streaming(
+    zyx_stack: np.ndarray,
+    pixel_scales: tuple[float, float, float],
+    fixed_params: dict,
+    optimizable_params: dict,
+    num_iterations: int = 10,
+    device: Device = None,
+) -> Generator[dict, None, None]:
+    """
+    Run phase reconstruction optimization with streaming updates.
+
+    Generator that yields reconstruction results and loss after each iteration.
+    Supports GPU acceleration for significant speedup (15-25x on typical hardware).
+
+    Parameters
+    ----------
+    zyx_stack : np.ndarray
+        Input Z-stack with shape (Z, Y, X)
+    pixel_scales : tuple[float, float, float]
+        (z_scale, y_scale, x_scale) in micrometers
+    fixed_params : dict
+        Fixed reconstruction parameters (wavelength, index, etc.)
+    optimizable_params : dict
+        Parameters to optimize with (enabled, initial, lr) tuples
+    num_iterations : int, optional
+        Number of optimization iterations, by default 10
+    device : torch.device | str | None, optional
+        Computing device. If None, auto-selects GPU if available, else CPU.
+        Examples: "cuda", "cpu", "cuda:0", torch.device("cuda")
+        By default None
+
+    Yields
+    ------
+    dict
+        Dictionary with keys:
+        - 'reconstructed_image': normalized uint8 array (on CPU for display)
+        - 'loss': float loss value
+        - 'iteration': int iteration number (1-indexed)
+        - 'params': dict of current parameter values
+
+    Notes
+    -----
+    All computation is performed on the specified device (GPU if available).
+    Only final results are transferred to CPU for display, minimizing
+    transfer overhead.
+    """
+    # Resolve device (will print GPU info if available)
+    device = get_device(device)
+
+    # Convert to torch tensor on target device (single transfer)
+    zyx_tile = torch.tensor(zyx_stack, dtype=torch.float32, device=device)
+
+    # Prepare reconstruction arguments
+    z_scale, y_scale, x_scale = pixel_scales
+    recon_args = fixed_params.copy()
+
+    # Remove non-reconstruction parameters from fixed_params
+    recon_args.pop("num_iterations", None)
+    recon_args.pop("use_tiling", None)
+    recon_args.pop("device", None)  # Remove device if present
+
+    recon_args["yx_shape"] = zyx_tile.shape[1:]
+    recon_args["yx_pixel_size"] = y_scale
+    recon_args["z_scale"] = z_scale
+
+    # Initialize optimizable parameters on device
+    for name, (enabled, initial, lr) in optimizable_params.items():
+        recon_args[name] = torch.tensor([initial], dtype=torch.float32, device=device)
+
+    # Prepare optimizer with parameters on device
+    optimization_params, optimizer = prepare_optimizer(optimizable_params, device)
+
+    # Optimization loop (all on device)
+    for step in range(num_iterations):
+        # Update parameters
+        for name, param in optimization_params.items():
+            recon_args[name] = param
+
+        # Run reconstruction (all on device)
+        yx_recon = run_reconstruction(zyx_tile, recon_args)
+
+        # Compute loss (all on device, negative midband power - we want to maximize)
+        loss = -compute_midband_power(
+            yx_recon,
+            NA_det=0.15,
+            lambda_ill=recon_args["wavelength_illumination"],
+            pixel_size=recon_args["yx_pixel_size"],
+            band=(0.1, 0.2),
+        )
+
+        # Backward pass and optimizer step (on device)
+        loss.backward()
+        optimizer.step()
+        optimizer.zero_grad()
+
+        # Transfer to CPU ONLY for display (single transfer per iteration)
+        recon_numpy = yx_recon.detach().cpu().numpy()
+        # Wrap in xarray for normalize_for_display (expects xr.DataArray)
+        recon_normalized = normalize_for_display(xr.DataArray(recon_numpy))
+
+        # Extract current parameter values (scalars, already on CPU)
+        param_values = {
+            name: param.item() for name, param in optimization_params.items()
+        }
+
+        # Yield results
+        yield {
+            "reconstructed_image": recon_normalized,
+            "loss": loss.item(),
+            "iteration": step + 1,
+            "params": param_values,
+        }
+
+
+def extract_tiles(
+    zyx_data: np.ndarray, num_tiles: tuple[int, int], overlap_pct: float
+) -> tuple[dict[str, np.ndarray], dict[str, tuple[int, int, int]]]:
+    """
+    Extract overlapping tiles from a Z-stack for processing.
+
+    Parameters
+    ----------
+    zyx_data : np.ndarray
+        Input data with shape (Z, Y, X)
+    num_tiles : tuple[int, int]
+        Number of tiles in (Y, X) dimensions
+    overlap_pct : float
+        Overlap percentage between tiles (0.0 to 1.0)
+
+    Returns
+    -------
+    tuple[dict, dict]
+        tiles: dict mapping tile names to arrays
+        translations: dict mapping tile names to (z, y, x) positions
+    """
+    Z, Y, X = zyx_data.shape
+    tile_height = int(np.ceil(Y / (num_tiles[0] - (num_tiles[0] - 1) * overlap_pct)))
+    tile_width = int(np.ceil(X / (num_tiles[1] - (num_tiles[1] - 1) * overlap_pct)))
+    stride_y = int(tile_height * (1 - overlap_pct))
+    stride_x = int(tile_width * (1 - overlap_pct))
+
+    tiles = {}
+    translations = {}
+    for yi in range(num_tiles[0]):
+        for xi in range(num_tiles[1]):
+            y0, x0 = yi * stride_y, xi * stride_x
+            y1, x1 = min(y0 + tile_height, Y), min(x0 + tile_width, X)
+            tile_name = f"0/0/{yi:03d}{xi:03d}"
+            tiles[tile_name] = zyx_data[:, y0:y1, x0:x1]
+            translations[tile_name] = (0, y0, x0)
+    return tiles, translations

optimize_demo.py

@@ -0,0 +1,702 @@
+"""
+Gradio Phase Reconstruction Viewer
+
+Interactive web interface for viewing zarr microscopy data with T/Z navigation.
+Based on: docs/examples/visuals/optimize_phase_recon.py
+"""
+
+import gradio as gr
+import numpy as np
+import pandas as pd
+from pathlib import Path
+
+from demo_utils import (
+    print_data_summary,
+    run_optimization_streaming,
+    get_plate_metadata,
+    load_fov_from_plate,
+    extract_2d_slice,
+    run_reconstruction_single,
+)
+
+
+# ============================================================================
+# CONFIGURATION
+# ============================================================================
+
+class Config:
+    """Centralized configuration for the phase reconstruction viewer."""
+
+    # Input data path
+    INPUT_PATH = Path("data/20x.zarr")
+
+    # Default FOV selection
+    DEFAULT_ROW = "A"
+    DEFAULT_COLUMN = "1"
+    DEFAULT_FIELD = "002026"
+
+    # Restrict to specific FOVs (filter large plate)
+    ALLOWED_FOVS = ['002026', '002027', '002028']
+
+    # Channel selection (only BF channel in concatenated data)
+    CHANNEL = 0  # BF is now channel 0 (GFP was filtered out during concatenation)
+
+    # Pixel sizes for 20x objective (override incorrect Zarr metadata)
+    PIXEL_SIZE_YX = 0.325  # micrometers
+    PIXEL_SIZE_Z = 2.0     # micrometers
+
+    # Reconstruction configuration
+    RECON_CONFIG = {
+        "wavelength_illumination": 0.45,
+        "index_of_refraction_media": 1.3,
+        "invert_phase_contrast": False,
+        "num_iterations": 10,
+        # GPU Configuration (auto-detects GPU for 15-25x speedup)
+        # - None: Auto-detect (uses CUDA if available, else CPU)
+        # - "cuda": Force GPU usage (requires CUDA-capable device)
+        # - "cpu": Force CPU usage (for testing/debugging)
+        "device": None,
+        # Tiling (not implemented - using full image)
+        "use_tiling": False,
+    }
+
+    # Optimizable parameters: (optimize_flag, initial_value, learning_rate)
+    OPTIMIZABLE_PARAMS = {
+        "z_offset": (True, 0.0, 0.01),
+        "numerical_aperture_detection": (True, 0.55, 0.001),
+        "numerical_aperture_illumination": (True, 0.54, 0.001),
+        "tilt_angle_zenith": (True, 0.0, 0.005),
+        "tilt_angle_azimuth": (True, 0.0, 0.001),
+    }
+
+    # UI slider ranges
+    SLIDER_RANGES = {
+        "z_offset": (-0.5, 0.5, 0.01),
+        "na_detection": (0.05, 0.65, 0.001),  # Max 0.65 to accommodate optimization
+        "na_illumination": (0.05, 0.65, 0.001),  # Max 0.65 (but constrained <= NA_detection)
+        "tilt_zenith": (0.0, np.pi / 2, 0.005),
+        "tilt_azimuth": (0.0, 2 * np.pi, 0.001),
+    }
+
+    # UI configuration
+    IMAGE_HEIGHT = 800
+    SERVER_PORT = 12124
+
+
+# ============================================================================
+# GLOBAL STATE INITIALIZATION
+# ============================================================================
+
+def initialize_plate_metadata():
+    """Load and display plate metadata."""
+    print("\n" + "=" * 60)
+    print("Loading HCS Plate Metadata...")
+    print("=" * 60)
+
+    # Pass allowed FOVs to avoid iterating through all positions
+    plate_metadata = get_plate_metadata(Config.INPUT_PATH, Config.ALLOWED_FOVS)
+
+    print(f"Available rows: {plate_metadata['rows']}")
+    print(f"Available columns: {plate_metadata['columns']}")
+    print(f"Total wells: {len(plate_metadata['wells'])}")
+
+    # Get default well fields (already filtered)
+    default_well_key = (Config.DEFAULT_ROW, Config.DEFAULT_COLUMN)
+    default_fields = plate_metadata["wells"].get(default_well_key, [])
+
+    print(f"Fields in {Config.DEFAULT_ROW}/{Config.DEFAULT_COLUMN}: {len(default_fields)}")
+    print(f"Allowed FOVs: {Config.ALLOWED_FOVS}")
+    print("=" * 60 + "\n")
+
+    return plate_metadata, default_fields
+
+
+def load_default_fov(plate_metadata):
+    """Load the default field of view and use correct pixel scales."""
+    print(f"Loading default FOV: {Config.DEFAULT_ROW}/{Config.DEFAULT_COLUMN}/{Config.DEFAULT_FIELD}")
+
+    data_xr = load_fov_from_plate(
+        plate_metadata["plate"],
+        Config.DEFAULT_ROW,
+        Config.DEFAULT_COLUMN,
+        Config.DEFAULT_FIELD,
+        resolution=0,
+    )
+
+    print_data_summary(data_xr)
+
+    # Use correct pixel scales from config (20x objective)
+    # Note: Zarr metadata may have incorrect values from different magnification
+    pixel_scales = (
+        Config.PIXEL_SIZE_Z,   # z_scale
+        Config.PIXEL_SIZE_YX,  # y_scale
+        Config.PIXEL_SIZE_YX,  # x_scale
+    )
+    print(f"Using pixel scales (Z, Y, X): {pixel_scales} micrometers (from config, 20x objective)")
+
+    return data_xr, pixel_scales
+
+
+# ============================================================================
+# FOV LOADING CALLBACKS
+# ============================================================================
+
+def load_selected_fov(field: str, current_z: int, plate_metadata):
+    """Load selected FOV and update UI components."""
+    try:
+        print(f"\nLoading FOV: {Config.DEFAULT_ROW}/{Config.DEFAULT_COLUMN}/{field}")
+
+        # Load new data
+        new_data_xr = load_fov_from_plate(
+            plate_metadata["plate"],
+            Config.DEFAULT_ROW,
+            Config.DEFAULT_COLUMN,
+            field,
+            resolution=0,
+        )
+
+        # Use pixel scales from config (not Zarr metadata)
+        new_pixel_scales = (Config.PIXEL_SIZE_Z, Config.PIXEL_SIZE_YX, Config.PIXEL_SIZE_YX)
+
+        # Update Z slider
+        z_max = new_data_xr.sizes["Z"] - 1
+        new_z = min(current_z, z_max)
+
+        print(f"✅ Loaded: {dict(new_data_xr.sizes)}")
+
+        # Get preview image
+        preview_image = extract_2d_slice(
+            new_data_xr, t=0, c=Config.CHANNEL, z=new_z, normalize=True, verbose=False
+        )
+
+        return (
+            gr.Slider(maximum=z_max, value=new_z),  # Updated Z slider
+            (preview_image, preview_image),  # ImageSlider in preview mode
+            new_data_xr,  # Update state
+            new_pixel_scales,  # Update state
+        )
+
+    except Exception as e:
+        print(f"❌ Error loading FOV: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        return (gr.skip(), gr.skip(), gr.skip(), gr.skip())
+
+
+# ============================================================================
+# IMAGE DISPLAY CALLBACKS
+# ============================================================================
+
+def get_slice_for_preview(z: int, data_xr_state):
+    """Extract slice and show in preview mode (same image twice)."""
+    slice_img = extract_2d_slice(
+        data_xr_state, t=0, c=Config.CHANNEL, z=int(z), normalize=True, verbose=False
+    )
+    return (slice_img, slice_img)  # Preview mode: both sides show same image
+
+
+# ============================================================================
+# RECONSTRUCTION CALLBACKS
+# ============================================================================
+
+def run_reconstruction_ui(
+    z: int,
+    z_offset: float,
+    na_det: float,
+    na_ill: float,
+    tilt_zenith: float,
+    tilt_azimuth: float,
+    data_xr_state,
+    pixel_scales_state,
+):
+    """
+    Run reconstruction with CURRENT slider values (no optimization).
+
+    Uses slider parameters directly for a single fast reconstruction.
+    """
+    # Extract full Z-stack for timepoint 0 (for reconstruction)
+    zyx_stack = data_xr_state.isel(T=0, C=Config.CHANNEL).values
+
+    # Get current Z-slice for comparison (left side of ImageSlider)
+    original_normalized = extract_2d_slice(
+        data_xr_state, t=0, c=Config.CHANNEL, z=int(z), normalize=True, verbose=False
+    )
+
+    # Build parameter dict from slider values
+    param_values = {
+        "z_offset": z_offset,
+        "numerical_aperture_detection": na_det,
+        "numerical_aperture_illumination": na_ill,
+        "tilt_angle_zenith": tilt_zenith,
+        "tilt_angle_azimuth": tilt_azimuth,
+    }
+
+    # Run single reconstruction with these parameters
+    reconstructed_image = run_reconstruction_single(
+        zyx_stack, pixel_scales_state, Config.RECON_CONFIG, param_values
+    )
+
+    # Return updated image slider (no optimization results)
+    return (original_normalized, reconstructed_image)
+
+
+def run_optimization_ui(z: int, data_xr_state, pixel_scales_state):
+    """
+    Run OPTIMIZATION and stream updates to UI with iteration caching.
+
+    Uses OPTIMIZABLE_PARAMS as initial guesses, runs full optimization loop.
+    Yields progressive updates for ImageSlider, loss plot, status,
+    iteration history, iteration slider, and SLIDER UPDATES.
+    """
+    # Extract full Z-stack for timepoint 0 (for reconstruction)
+    zyx_stack = data_xr_state.isel(T=0, C=Config.CHANNEL).values
+
+    # Get current Z-slice for comparison (left side of ImageSlider)
+    original_normalized = extract_2d_slice(
+        data_xr_state, t=0, c=Config.CHANNEL, z=int(z), normalize=True, verbose=False
+    )
+
+    # Initialize tracking
+    loss_history = []
+    iteration_cache = []
+
+    # Set raw image once at the start (pin it)
+    yield (
+        (original_normalized, original_normalized),  # Show raw image on both sides initially
+        pd.DataFrame({"iteration": [], "loss": []}),  # Initialize loss plot with empty data
+        [],  # Clear iteration history
+        gr.skip(),  # Don't update slider yet (avoid min=max=1 error)
+        gr.Markdown(value="Starting optimization...", visible=True),
+        # Slider updates (5 outputs):
+        gr.skip(),  # z_offset
+        gr.skip(),  # na_det
+        gr.skip(),  # na_ill
+        gr.skip(),  # tilt_zenith
+        gr.skip(),  # tilt_azimuth
+    )
+
+    # Run optimization with streaming
+    for result in run_optimization_streaming(
+        zyx_stack,
+        pixel_scales_state,
+        Config.RECON_CONFIG,
+        Config.OPTIMIZABLE_PARAMS,
+        num_iterations=Config.RECON_CONFIG["num_iterations"],
+    ):
+        # Current iteration number
+        n = result["iteration"]
+
+        # Cache iteration result
+        iteration_cache.append(
+            {
+                "iteration": n,
+                "reconstructed_image": result["reconstructed_image"],
+                "loss": result["loss"],
+                "params": result["params"],
+                "raw_image": original_normalized,
+            }
+        )
+
+        # Accumulate loss history (ensure iteration is int for proper x-axis)
+        loss_history.append({"iteration": int(n), "loss": result["loss"]})
+
+        # Format iteration info
+        info_md = f"**Iteration {n}/{Config.RECON_CONFIG['num_iterations']}** | Loss: `{result['loss']:.2e}`"
+
+        # Yield updates - update ImageSlider AND sliders with latest params
+        yield (
+            (original_normalized, result["reconstructed_image"]),  # Update ImageSlider
+            pd.DataFrame(loss_history),  # Loss plot
+            iteration_cache,  # Update iteration history state
+            gr.Slider(  # Update iteration slider (grows from 1-1 to 1-10)
+                minimum=1,
+                maximum=n,
+                value=n,
+                step=1,
+                visible=True,
+                interactive=True,
+            ),
+            gr.Markdown(value=info_md, visible=True),  # Show iteration info
+            # Update parameter sliders with optimized values:
+            result["params"].get("z_offset", gr.skip()),
+            result["params"].get("numerical_aperture_detection", gr.skip()),
+            result["params"].get("numerical_aperture_illumination", gr.skip()),
+            result["params"].get("tilt_angle_zenith", gr.skip()),
+            result["params"].get("tilt_angle_azimuth", gr.skip()),
+        )
+
+    # Final yield (keep last state)
+    yield (
+        gr.skip(),  # Keep last ImageSlider state
+        gr.skip(),  # Keep last loss plot
+        gr.skip(),  # Keep iteration history
+        gr.skip(),  # Keep iteration slider
+        gr.Markdown(
+            value=f"**Optimization Complete!** Final Loss: `{result['loss']:.2e}`",
+            visible=True,
+        ),
+        gr.skip(),  # Keep z_offset
+        gr.skip(),  # Keep na_det
+        gr.skip(),  # Keep na_ill
+        gr.skip(),  # Keep tilt_zenith
+        gr.skip(),  # Keep tilt_azimuth
+    )
+
+
+# ============================================================================
+# ITERATION SCRUBBING CALLBACKS
+# ============================================================================
+
+def scrub_iterations(iteration_idx: int, history: list):
+    """Update display AND parameter sliders when user scrubs to different iteration."""
+    if not history or iteration_idx < 1 or iteration_idx > len(history):
+        return (gr.skip(),) * 7  # image, info, and 5 parameter values
+
+    # Get selected iteration (convert to 0-indexed)
+    selected = history[iteration_idx - 1]
+
+    # Update ImageSlider overlay
+    comparison = (selected["raw_image"], selected["reconstructed_image"])
+
+    # Update info display
+    info_md = f"**Iteration {selected['iteration']}/{len(history)}** | Loss: `{selected['loss']:.2e}`"
+
+    # Extract parameter values at this iteration
+    params = selected["params"]
+    z_offset = params.get("z_offset", 0.0)
+    na_det = params.get("numerical_aperture_detection", 0.55)
+    na_ill = params.get("numerical_aperture_illumination", 0.54)
+    tilt_zenith = params.get("tilt_angle_zenith", 0.0)
+    tilt_azimuth = params.get("tilt_angle_azimuth", 0.0)
+
+    return comparison, info_md, z_offset, na_det, na_ill, tilt_zenith, tilt_azimuth
+
+
+def clear_iteration_state():
+    """Reset iteration state when coordinates change."""
+    return (
+        [],  # Clear iteration_history
+        gr.skip(),  # Don't update slider (avoid min=max error)
+        gr.Markdown(value="", visible=False),  # Hide info
+    )
+
+
+# ============================================================================
+# UI CONSTRUCTION
+# ============================================================================
+
+def create_gradio_interface(plate_metadata, default_fields, data_xr, pixel_scales):
+    """Build the Gradio interface with all components and event wiring."""
+
+    with gr.Blocks() as demo:
+        gr.Markdown("# waveOrder Phase Reconstruction Demo")
+        gr.Markdown(
+            "**Paper:** Chandler et al. (2024). *waveOrder: generalist framework for label-agnostic computational microscopy*. "
+            "[arXiv:2412.09775](https://arxiv.org/abs/2412.09775)\n\n"
+            "**GitHub Repository:** [mehta-lab/waveorder](https://github.com/mehta-lab/waveorder)"
+        )
+        gr.Markdown("---")
+
+        # FOV Selection (top of page)
+        with gr.Row():
+            fov_dropdown = gr.Dropdown(
+                choices=default_fields,
+                value=Config.DEFAULT_FIELD,
+                label="Field of View",
+                info=f"Select FOV from well {Config.DEFAULT_ROW}/{Config.DEFAULT_COLUMN}",
+                scale=2,
+            )
+            load_fov_btn = gr.Button("🔄 Load FOV", variant="secondary", size="sm", scale=1)
+
+        gr.Markdown("---")
+
+        # Two-column layout: Image viewer (left) | Controls (right)
+        with gr.Row():
+            # LEFT COLUMN: Large ImageSlider (60% width)
+            with gr.Column(scale=4):
+                # Image viewer
+                initial_preview = extract_2d_slice(
+                    data_xr,
+                    t=0,
+                    c=Config.CHANNEL,
+                    z=data_xr.sizes["Z"] // 2,
+                    normalize=True,
+                    verbose=False,
+                )
+
+                image_viewer = gr.ImageSlider(
+                    label="Raw (left) vs Reconstructed (right) - Drag slider to compare",
+                    type="numpy",
+                    value=(initial_preview, initial_preview),
+                    height=Config.IMAGE_HEIGHT,
+                )
+
+                gr.Markdown("---")
+
+                # Section 2: Navigation (below image)
+                gr.Markdown("### 🎛️ Navigation")
+                z_slider = gr.Slider(
+                    minimum=0,
+                    maximum=data_xr.sizes["Z"] - 1,
+                    value=data_xr.sizes["Z"] // 2,
+                    step=1,
+                    label="Z-slice",
+                    scale=1,
+                )
+
+            # RIGHT COLUMN: All controls (40% width)
+            with gr.Column(scale=2):
+                # Section 3: Reconstruction Parameters
+                gr.Markdown("### ⚙️ Reconstruction Parameters")
+
+                # Sliders for optimizable parameters
+                z_offset_slider = gr.Slider(
+                    minimum=Config.SLIDER_RANGES["z_offset"][0],
+                    maximum=Config.SLIDER_RANGES["z_offset"][1],
+                    value=Config.OPTIMIZABLE_PARAMS["z_offset"][1],
+                    step=Config.SLIDER_RANGES["z_offset"][2],
+                    label="Z Offset (μm)",
+                    info="Axial focus offset",
+                )
+
+                na_det_slider = gr.Slider(
+                    minimum=Config.SLIDER_RANGES["na_detection"][0],
+                    maximum=Config.SLIDER_RANGES["na_detection"][1],
+                    value=Config.OPTIMIZABLE_PARAMS["numerical_aperture_detection"][1],
+                    step=Config.SLIDER_RANGES["na_detection"][2],
+                    label="NA Detection",
+                    info="Numerical aperture of detection objective",
+                )
+
+                na_ill_slider = gr.Slider(
+                    minimum=Config.SLIDER_RANGES["na_illumination"][0],
+                    maximum=Config.SLIDER_RANGES["na_illumination"][1],
+                    value=Config.OPTIMIZABLE_PARAMS["numerical_aperture_illumination"][1],
+                    step=Config.SLIDER_RANGES["na_illumination"][2],
+                    label="NA Illumination",
+                    info="Numerical aperture of illumination",
+                )
+
+                tilt_zenith_slider = gr.Slider(
+                    minimum=Config.SLIDER_RANGES["tilt_zenith"][0],
+                    maximum=Config.SLIDER_RANGES["tilt_zenith"][1],
+                    value=Config.OPTIMIZABLE_PARAMS["tilt_angle_zenith"][1],
+                    step=Config.SLIDER_RANGES["tilt_zenith"][2],
+                    label="Tilt Zenith (rad)",
+                    info="Zenith angle of illumination tilt",
+                )
+
+                tilt_azimuth_slider = gr.Slider(
+                    minimum=Config.SLIDER_RANGES["tilt_azimuth"][0],
+                    maximum=Config.SLIDER_RANGES["tilt_azimuth"][1],
+                    value=Config.OPTIMIZABLE_PARAMS["tilt_angle_azimuth"][1],
+                    step=Config.SLIDER_RANGES["tilt_azimuth"][2],
+                    label="Tilt Azimuth (rad)",
+                    info="Azimuthal angle of illumination tilt",
+                )
+
+                gr.Markdown("---")
+
+                # Section 4: Reconstruction Actions
+                gr.Markdown("### 🔬 Phase Reconstruction")
+
+                with gr.Row():
+                    optimize_btn = gr.Button(
+                        "⚡ Optimize Parameters", variant="secondary", size="lg"
+                    )
+                    reconstruct_btn = gr.Button(
+                        "🔬 Run Reconstruction", variant="primary", size="lg"
+                    )
+
+                gr.Markdown("---")
+
+                # Section 5: Optimization Results
+                gr.Markdown("### 📊 Optimization Results")
+
+                loss_plot = gr.LinePlot(
+                    x="iteration",
+                    y="loss",
+                    title="Optimization - Midband Spatial Frequency Loss",
+                    height=200,
+                    scale=2,
+                    value=pd.DataFrame({"iteration": [], "loss": []}),  # Initialize with empty DataFrame structure
+                )
+
+                # Iteration scrubbing controls
+                iteration_slider = gr.Slider(
+                    minimum=1,
+                    maximum=1,
+                    value=1,
+                    step=1,
+                    label="View Iteration",
+                    info="Scrub through optimization history",
+                    interactive=True,  # Always interactive (just hidden until optimization)
+                    visible=False,
+                )
+                iteration_info = gr.Markdown(value="", visible=False)
+
+        # State storage
+        iteration_history = gr.State(value=[])
+        current_data_xr = gr.State(value=data_xr)
+        current_pixel_scales = gr.State(value=pixel_scales)
+
+        gr.Markdown("---")
+
+        # Wire all event handlers
+        _wire_event_handlers(
+            demo,
+            fov_dropdown,
+            load_fov_btn,
+            z_slider,
+            image_viewer,
+            z_offset_slider,
+            na_det_slider,
+            na_ill_slider,
+            tilt_zenith_slider,
+            tilt_azimuth_slider,
+            optimize_btn,
+            reconstruct_btn,
+            loss_plot,
+            iteration_slider,
+            iteration_info,
+            iteration_history,
+            current_data_xr,
+            current_pixel_scales,
+            plate_metadata,
+        )
+
+    return demo
+
+
+def _wire_event_handlers(
+    demo,
+    fov_dropdown,
+    load_fov_btn,
+    z_slider,
+    image_viewer,
+    z_offset_slider,
+    na_det_slider,
+    na_ill_slider,
+    tilt_zenith_slider,
+    tilt_azimuth_slider,
+    optimize_btn,
+    reconstruct_btn,
+    loss_plot,
+    iteration_slider,
+    iteration_info,
+    iteration_history,
+    current_data_xr,
+    current_pixel_scales,
+    plate_metadata,
+):
+    """Wire all Gradio event handlers."""
+
+    # FOV loading
+    load_fov_btn.click(
+        fn=lambda field, z: load_selected_fov(field, z, plate_metadata),
+        inputs=[fov_dropdown, z_slider],
+        outputs=[z_slider, image_viewer, current_data_xr, current_pixel_scales],
+    )
+
+    # NA slider linking: Ensure NA_illumination <= NA_detection (physical constraint)
+    # Only enforce when NA_detection changes (avoid feedback loop)
+    def enforce_na_constraint(na_det_value, na_ill_value):
+        """When NA_detection decreases below NA_illumination, cap NA_illumination."""
+        return min(na_ill_value, na_det_value)
+
+    na_det_slider.change(
+        fn=enforce_na_constraint,
+        inputs=[na_det_slider, na_ill_slider],
+        outputs=[na_ill_slider],
+    )
+
+    # Image viewer for Z navigation (preview mode: same image twice)
+    demo.load(
+        fn=get_slice_for_preview,
+        inputs=[z_slider, current_data_xr],
+        outputs=image_viewer,
+    )
+    z_slider.change(
+        fn=get_slice_for_preview,
+        inputs=[z_slider, current_data_xr],
+        outputs=image_viewer,
+    )
+
+    # Reconstruction buttons
+    optimize_btn.click(
+        fn=run_optimization_ui,
+        inputs=[z_slider, current_data_xr, current_pixel_scales],
+        outputs=[
+            image_viewer,
+            loss_plot,
+            iteration_history,
+            iteration_slider,
+            iteration_info,
+            z_offset_slider,
+            na_det_slider,
+            na_ill_slider,
+            tilt_zenith_slider,
+            tilt_azimuth_slider,
+        ],
+    )
+
+    reconstruct_btn.click(
+        fn=run_reconstruction_ui,
+        inputs=[
+            z_slider,
+            z_offset_slider,
+            na_det_slider,
+            na_ill_slider,
+            tilt_zenith_slider,
+            tilt_azimuth_slider,
+            current_data_xr,
+            current_pixel_scales,
+        ],
+        outputs=[image_viewer],
+    )
+
+    # Iteration scrubbing - updates image AND all parameter sliders
+    iteration_slider.change(
+        fn=scrub_iterations,
+        inputs=[iteration_slider, iteration_history],
+        outputs=[
+            image_viewer,
+            iteration_info,
+            z_offset_slider,
+            na_det_slider,
+            na_ill_slider,
+            tilt_zenith_slider,
+            tilt_azimuth_slider,
+        ],
+    )
+
+    # Clear iteration state when Z changes
+    z_slider.change(
+        fn=clear_iteration_state,
+        inputs=[],
+        outputs=[iteration_history, iteration_slider, iteration_info],
+    )
+
+
+# ============================================================================
+# MAIN ENTRY POINT
+# ============================================================================
+
+if __name__ == "__main__":
+    # Initialize single FOV data
+    data_xr, pixel_scales = initialize_single_fov()
+
+    # Create and launch interface
+    demo = create_gradio_interface(data_xr, pixel_scales)
+
+    print("\n" + "=" * 60)
+    print("Starting Gradio Phase Reconstruction Viewer")
+    print("=" * 60)
+    print("Open your browser to the URL shown below")
+    print("=" * 60 + "\n")
+
+    demo.launch(
+        share=False,  # Set to True to create public link
+        # server_name="0.0.0.0",  # Allow external access
+        server_port=Config.SERVER_PORT,
+    )

requirements.txt

@@ -0,0 +1,10 @@
+# WaveOrder Phase Reconstruction Demo - Requirements
+# Install waveorder from gradio-demo branch (includes GPU device handling fixes)
+
+# Install waveorder from gradio-demo branch
+git+https://github.com/mehta-lab/waveorder.git@gradio-demo
+git+https://github.com/ianhi/xarray-ome.git@main
+git+https://github.com/czbiohub-sf/iohub.git@v0.3.0a2
+
+# Gradio for web interface
+gradio>=6.0.0