dropdrop 1.1.0__py3-none-any.whl

dropdrop/__init__.py

@@ -0,0 +1,16 @@
+"""DropDrop - Droplet and Inclusion Detection Pipeline."""
+
+from .cache import CacheManager
+from .config import load_config
+from .pipeline import DropletInclusionPipeline
+from .stats import DropletStatistics
+from .ui import BaseWindow, InclusionEditor, Viewer
+
+__all__ = [
+    "CacheManager",
+    "DropletInclusionPipeline",
+    "DropletStatistics",
+    "InclusionEditor",
+    "Viewer",
+    "load_config",
+]

dropdrop/cache.py

@@ -0,0 +1,133 @@
+"""Cache management for expensive computations."""
+
+import hashlib
+import json
+import shutil
+from datetime import datetime
+from pathlib import Path
+
+import numpy as np
+
+
+class CacheManager:
+    """Global LRU cache for expensive computations, stored in project root."""
+
+    def __init__(self, config, cache_dir=None):
+        cache_cfg = config.get("cache", {})
+        self.enabled = cache_cfg.get("enabled", True)
+        self.max_frames = cache_cfg.get("max_frames", 100)
+        # Cache in project root by default
+        if cache_dir:
+            self.cache_dir = Path(cache_dir)
+        else:
+            self.cache_dir = Path(__file__).parent.parent.parent / ".cache"
+        self.metadata_path = self.cache_dir / "metadata.json"
+        self.metadata = self._load_metadata()
+        self.config = config
+
+    def _load_metadata(self):
+        """Load cache metadata from disk."""
+        if self.metadata_path.exists():
+            try:
+                with open(self.metadata_path) as f:
+                    return json.load(f)
+            except (json.JSONDecodeError, IOError):
+                return self._default_metadata()
+        return self._default_metadata()
+
+    def _default_metadata(self):
+        """Return default metadata structure."""
+        return {"version": "1.0", "config_hash": None, "frames": {}, "access_order": []}
+
+    def _save_metadata(self):
+        """Save cache metadata to disk."""
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+        with open(self.metadata_path, "w") as f:
+            json.dump(self.metadata, f, indent=2)
+
+    def _enforce_lru(self):
+        """Remove oldest frames if over max_frames limit."""
+        while len(self.metadata["access_order"]) > self.max_frames:
+            oldest_key = self.metadata["access_order"].pop(0)
+            cache_file = self.cache_dir / f"{oldest_key}.npz"
+            if cache_file.exists():
+                cache_file.unlink()
+            self.metadata["frames"].pop(oldest_key, None)
+
+    def get_config_hash(self):
+        """Hash detection-related config keys that affect caching."""
+        keys = [
+            "cellpose_flow_threshold",
+            "cellpose_cellprob_threshold",
+            "min_droplet_diameter",
+            "max_droplet_diameter",
+        ]
+        data = {k: self.config.get(k) for k in keys}
+        return hashlib.sha256(json.dumps(data, sort_keys=True).encode()).hexdigest()[:16]
+
+    def _get_cache_key(self, source_filename):
+        """Generate cache key from source filename (not full path)."""
+        name = Path(source_filename).stem
+        return hashlib.sha256(name.encode()).hexdigest()[:16]
+
+    def is_valid(self, source_filename):
+        """Check if cache is valid for frame by source filename."""
+        if not self.enabled:
+            return False
+        current_hash = self.get_config_hash()
+        if self.metadata.get("config_hash") != current_hash:
+            return False
+        cache_key = self._get_cache_key(source_filename)
+        cache_file = self.cache_dir / f"{cache_key}.npz"
+        return cache_file.exists()
+
+    def load_frame(self, source_filename):
+        """Load cached data by source filename and update access order."""
+        cache_key = self._get_cache_key(source_filename)
+        cache_file = self.cache_dir / f"{cache_key}.npz"
+        data = np.load(cache_file, allow_pickle=True)
+
+        # Update LRU order
+        if cache_key in self.metadata["access_order"]:
+            self.metadata["access_order"].remove(cache_key)
+        self.metadata["access_order"].append(cache_key)
+        self._save_metadata()
+
+        return {
+            "min_projection": data["min_projection"],
+            "droplet_coords": list(data["droplet_coords"]),
+        }
+
+    def save_frame(self, source_filename, min_proj, droplet_coords):
+        """Save frame data by source filename and enforce LRU limit."""
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+        cache_key = self._get_cache_key(source_filename)
+        cache_file = self.cache_dir / f"{cache_key}.npz"
+
+        np.savez(
+            cache_file,
+            min_projection=min_proj,
+            droplet_coords=np.array(droplet_coords, dtype=object),
+        )
+
+        # Update metadata
+        self.metadata["config_hash"] = self.get_config_hash()
+        self.metadata["frames"][cache_key] = {
+            "source": str(source_filename),
+            "cached_at": datetime.now().isoformat(),
+        }
+
+        # Update LRU order
+        if cache_key in self.metadata["access_order"]:
+            self.metadata["access_order"].remove(cache_key)
+        self.metadata["access_order"].append(cache_key)
+
+        self._enforce_lru()
+        self._save_metadata()
+
+    def clear(self):
+        """Clear entire cache."""
+        if self.cache_dir.exists():
+            shutil.rmtree(self.cache_dir)
+        self.metadata = self._default_metadata()
+        print("Cache cleared.")

dropdrop/cli.py

@@ -0,0 +1,252 @@
+"""Command-line interface for DropDrop pipeline."""
+
+import argparse
+import sys
+import tarfile
+from datetime import datetime
+from pathlib import Path
+
+import pandas as pd
+
+from .cache import CacheManager
+from .config import load_config
+from .pipeline import DropletInclusionPipeline
+from .stats import DropletStatistics
+from .ui import InclusionEditor, Viewer
+
+
+def parse_settings(settings_str):
+    """Parse compact settings string.
+
+    Format: key=value,key=value
+    Keys: d[ilution], p[oisson], c[ount], l[abel]
+
+    Examples:
+        "d=1000,p=on,c=6.5e5,l=experiment1"
+        "dilution=500,poisson=off"
+    """
+    settings = {
+        "dilution": 500,
+        "poisson": True,
+        "count": 6.5e5,
+        "label": None,
+    }
+
+    if not settings_str:
+        return settings
+
+    key_map = {
+        "d": "dilution",
+        "dilution": "dilution",
+        "p": "poisson",
+        "poisson": "poisson",
+        "c": "count",
+        "count": "count",
+        "l": "label",
+        "label": "label",
+    }
+
+    for part in settings_str.split(","):
+        if "=" not in part:
+            continue
+        key, value = part.split("=", 1)
+        key = key_map.get(key.strip().lower(), key.strip().lower())
+
+        if key == "dilution":
+            settings["dilution"] = int(value)
+        elif key == "poisson":
+            settings["poisson"] = value.lower() in ("on", "yes", "true", "1")
+        elif key == "count":
+            settings["count"] = float(value)
+        elif key == "label":
+            settings["label"] = value.strip()
+
+    return settings
+
+
+def prompt_settings():
+    """Interactive prompts for settings when --settings not provided."""
+    settings = {"dilution": 500, "poisson": True, "count": 6.5e5, "label": None}
+
+    print("\n--- Project Settings ---")
+
+    # Poisson analysis
+    use_poisson = input("Use Poisson analysis? [yes/no] (yes): ").strip().lower()
+    settings["poisson"] = use_poisson != "no"
+
+    if settings["poisson"]:
+        # Bead count
+        count_input = input("Stock count/uL [6.5e5]: ").strip()
+        if count_input:
+            try:
+                settings["count"] = float(count_input)
+            except ValueError:
+                print(f"  Invalid value, using default: {settings['count']}")
+
+        # Dilution
+        dilution_input = input("Dilution factor [500]: ").strip()
+        if dilution_input:
+            try:
+                settings["dilution"] = int(dilution_input)
+            except ValueError:
+                print(f"  Invalid value, using default: {settings['dilution']}")
+
+    # Label
+    label_input = input("Project label (optional, press Enter to skip): ").strip()
+    settings["label"] = label_input if label_input else None
+
+    print("------------------------\n")
+    return settings
+
+
+def generate_project_name(settings):
+    """Generate project directory name from date and label."""
+    date_str = datetime.now().strftime("%Y%m%d")
+    if settings.get("label"):
+        return f"{date_str}_{settings['label']}"
+    return date_str
+
+
+def main():
+    """Main entry point."""
+    parser = argparse.ArgumentParser(
+        description="Droplet and inclusion detection pipeline using Cellpose"
+    )
+
+    parser.add_argument(
+        "input_dir", type=str, help="Input directory containing z-stack images"
+    )
+
+    parser.add_argument(
+        "output_dir",
+        type=str,
+        nargs="?",
+        default=None,
+        help="Output directory (default: ./results/<date>_<label>)",
+    )
+
+    parser.add_argument(
+        "-s",
+        "--settings",
+        type=str,
+        default=None,
+        help='Compact settings: "d=1000,p=on,c=6.5e5,l=label" (d=dilution, p=poisson, c=count, l=label)',
+    )
+
+    viewer_group = parser.add_mutually_exclusive_group()
+    viewer_group.add_argument(
+        "--view", action="store_true", help="Enable interactive viewer after processing"
+    )
+    viewer_group.add_argument(
+        "-i",
+        "--interactive",
+        action="store_true",
+        help="Interactive inclusion correction mode",
+    )
+
+    parser.add_argument(
+        "-n",
+        "--number",
+        type=int,
+        default=None,
+        help="Process only the first N frames (for testing)",
+    )
+    parser.add_argument(
+        "--no-cache",
+        action="store_true",
+        help="Disable caching for this run",
+    )
+    parser.add_argument(
+        "--clear-cache",
+        action="store_true",
+        help="Clear cache before processing",
+    )
+    parser.add_argument(
+        "-z",
+        "--gzip",
+        action="store_true",
+        help="Archive project directory as .tar.gz after completion",
+    )
+    args = parser.parse_args()
+
+    # Check input directory exists
+    if not Path(args.input_dir).exists():
+        print(f"ERROR: Input directory '{args.input_dir}' does not exist")
+        sys.exit(1)
+
+    # Get settings (from --settings or interactive prompts)
+    if args.settings:
+        settings = parse_settings(args.settings)
+    else:
+        settings = prompt_settings()
+
+    # Determine output directory
+    if args.output_dir:
+        output_dir = Path(args.output_dir)
+    else:
+        project_name = generate_project_name(settings)
+        output_dir = Path("results") / project_name
+
+    # Store settings for later use
+    settings["input_dir"] = str(Path(args.input_dir).resolve())
+
+    # Initialize and run pipeline
+    print(f"Input directory: {args.input_dir}")
+    print(f"Output directory: {output_dir}")
+    if settings["poisson"]:
+        print(f"Poisson: ON (count={settings['count']:.2e}, dilution={settings['dilution']})")
+    else:
+        print("Poisson: OFF")
+    if args.number:
+        print(f"Frame limit: {args.number}")
+
+    # Create pipeline with visualization storage if viewer is requested
+    store_viz = args.view or args.interactive
+    use_cache = not args.no_cache
+    pipeline = DropletInclusionPipeline(store_visualizations=store_viz, use_cache=use_cache)
+
+    # Handle cache clear request
+    if args.clear_cache and pipeline.cache:
+        pipeline.cache.clear()
+
+    results = pipeline.run(args.input_dir, str(output_dir), frame_limit=args.number)
+
+    if results:
+        print("\nPipeline completed successfully!")
+
+        # Interactive editing mode
+        if args.interactive and pipeline.visualization_data:
+            print("\nLaunching interactive inclusion editor...")
+            editor = InclusionEditor(pipeline.visualization_data, results)
+            results = editor.run()  # Update results with manual corrections
+
+            # Save updated results
+            df = pd.DataFrame(results)
+            csv_path = output_dir / "data.csv"
+            df.to_csv(csv_path, index=False)
+            print(f"Updated results saved to: {csv_path}")
+
+        # Always generate statistics (after any interactive corrections)
+        print("\nGenerating statistical analysis...")
+        csv_path = output_dir / "data.csv"
+        stats_module = DropletStatistics(csv_path, settings)
+        stats_module.run_analysis(str(output_dir))
+
+        # Launch viewer if requested (no editing, just viewing)
+        if args.view and pipeline.visualization_data:
+            print("\nLaunching interactive viewer...")
+            df = pd.DataFrame(results)
+            viewer = Viewer(pipeline.visualization_data, df)
+            viewer.run()
+
+        # Archive project if requested
+        if args.gzip:
+            archive_name = f"{output_dir}.tar.gz"
+            print(f"\nArchiving project to: {archive_name}")
+            with tarfile.open(archive_name, "w:gz") as tar:
+                tar.add(output_dir, arcname=output_dir.name)
+            print(f"Archive created: {archive_name}")
+
+
+if __name__ == "__main__":
+    main()

dropdrop/config.py

@@ -0,0 +1,67 @@
+"""Configuration management."""
+
+import json
+from pathlib import Path
+
+DEFAULT_CONFIG = {
+    # Cellpose parameters
+    "cellpose_flow_threshold": 0.4,
+    "cellpose_cellprob_threshold": 0.0,
+    # Erosion parameters
+    "erosion_pixels": 5,
+    # Inclusion detection parameters
+    "kernel_size": 7,
+    "tophat_threshold": 30,
+    "min_inclusion_area": 7,
+    "max_inclusion_area": 50,
+    "edge_buffer": 5,
+    # Droplet filtering
+    "min_droplet_diameter": 80,
+    "max_droplet_diameter": 200,
+    # Conversion factor
+    "px_to_um": 1.14,
+    # Cache settings
+    "cache": {
+        "enabled": True,
+        "max_frames": 100,
+        "strategy": "lru",
+    },
+}
+
+
+def load_config(config_path=None):
+    """Load configuration from JSON file or use defaults.
+
+    Args:
+        config_path: Path to config.json. If None, looks in current directory.
+
+    Returns:
+        dict: Configuration dictionary with defaults merged.
+    """
+    config = DEFAULT_CONFIG.copy()
+
+    if config_path is None:
+        # Look for config.json in current directory or project root
+        search_paths = [
+            Path.cwd() / "config.json",
+            Path(__file__).parent.parent.parent / "config.json",
+        ]
+        for path in search_paths:
+            if path.exists():
+                config_path = path
+                break
+
+    if config_path and Path(config_path).exists():
+        print(f"Loading config from: {config_path}")
+        with open(config_path, "r") as f:
+            loaded_config = json.load(f)
+            # Deep merge for nested dicts like 'cache'
+            for key, value in loaded_config.items():
+                if isinstance(value, dict) and key in config:
+                    config[key].update(value)
+                else:
+                    config[key] = value
+    else:
+        print("Using default configuration (no config.json found)")
+
+    return config