AutoMorphoTrack 1.0.0__tar.gz

AutoMorphoTrack-1.0.0/AutoMorphoTrack.egg-info/PKG-INFO

@@ -0,0 +1,115 @@
+Metadata-Version: 2.1
+Name: AutoMorphoTrack
+Version: 1.0.0
+Summary: AutoMorphoTrack is an open-source Python package for automated detection, morphology classification, motility tracking, and colocalization analysis of organelles in multichannel fluorescence microscopy data.
+Home-page: https://github.com/abayatibrain/AMTpackage
+Author: Armin Bayati
+Author-email: a.bayati.brain@gmail.com
+License: MIT
+Project-URL: Documentation, https://github.com/abayatibrain/AMTpackage
+Project-URL: Source, https://github.com/abayatibrain/AMTpackage
+Project-URL: Tracker, https://github.com/abayatibrain/AMTpackage/issues
+Description: # AutoMorphoTrack
+        
+        **AutoMorphoTrack** is an open-source Python package for automated detection, morphology classification, shape profiling, motility tracking, and colocalization analysis of subcellular organelles in multichannel fluorescence microscopy data.  
+        
+        This package represents the fully modular version of the **AutoMorphoTrack pipeline**, originally developed as a Jupyter Notebook by **Armin Bayati, Ph.D.**, and now distributed as an installable Python framework.  
+        Repository: [https://github.com/abayatibrain/automorphotrack](https://github.com/abayatibrain/automorphotrack)
+        
+        ---
+        
+        ## 🧬 Overview
+        
+        AutoMorphoTrack automates quantitative analysis of time-lapse `.tif` image stacks—typically dual-channel recordings of mitochondria and lysosomes—and generates publication-ready visual and numerical outputs at every step of the analysis pipeline.
+        
+        **Pipeline stages:**
+        
+        1. **Detection** – Organelle segmentation and outline visualization  
+        2. **Lysosomal Counting** – Per-frame lysosome enumeration and temporal profiling  
+        3. **Morphology Classification** – Elongated vs. punctate mitochondria  
+        4. **Shape Feature Extraction** – Area, circularity, solidity, aspect ratio, orientation  
+        5. **Tracking** – Cumulative organelle trajectories (mitochondria, lysosomes, composite)  
+        6. **Motility Analysis** – Velocity, displacement, and trajectory-based statistics  
+        7. **Colocalization** – Bright-blue overlap overlays and correlation metrics  
+        8. **Integrated Summary** – Correlation matrices linking morphology, motility, and overlap  
+        
+        Each stage outputs high-resolution figures, videos, and CSV data tables stored in standardized subdirectories, ensuring reproducibility and compatibility with any image dataset.
+        
+        ---
+        
+        ## 📦 Installation
+        
+        Install directly from PyPI:
+        
+        ```bash
+        pip install AutoMorphoTrack
+        ```
+        
+        Or from source:
+        
+        ```bash
+        git clone https://github.com/abayatibrain/automorphotrack.git
+        cd automorphotrack
+        pip install -e .
+        ```
+        
+        ---
+        
+        ## 🚀 Basic Usage
+        
+        ```python
+        from automorphotrack import *
+        
+        tif_path = "Composite.tif"
+        
+        detect_organelles(tif_path)
+        count_lysosomes_per_frame(tif_path)
+        classify_morphology(tif_path)
+        analyze_shape_features(tif_path)
+        track_organelles(tif_path)
+        analyze_motility()
+        analyze_colocalization(tif_path)
+        summarize_integrated_data()
+        ```
+        
+        Each function automatically generates visual and quantitative outputs at every step.
+        
+        ---
+        
+        ## 📁 Outputs
+        
+        | Step | Output Type | Example Files |
+        |------|--------------|---------------|
+        | Detection | PNG + MP4 | `Mito_Frame0.png`, `Mitochondria_Detection.mp4` |
+        | Lysosome Count | PNG + CSV + MP4 | `Lyso_Count_Plot.png`, `Lysosome_Counts.csv` |
+        | Morphology | PNG + MP4 + CSV | `Morphology_Frame0_Labeled.png`, `Morphology_Labeled.mp4` |
+        | Shape Features | PNG + CSV | `Shape_Distributions.png`, `Mito_ShapeMetrics.csv` |
+        | Tracking | PNG + MP4 + CSV | `Cumulative_Mito.png`, `Mito_Tracks.csv` |
+        | Motility | PNG + CSV | `Motility_Distributions.png`, `Motility_Scatter.png` |
+        | Colocalization | PNG + MP4 + CSV | `Colocalization_Frame0.png`, `Colocalization.csv` |
+        | Summary | PNG + CSV | `Integrated_CorrelationMatrix.png`, `Integrated_Merged_Data.csv` |
+        
+        ---
+        
+        ## 🔧 Dependencies
+        
+        - Python ≥ 3.9  
+        - numpy, pandas, matplotlib, seaborn, opencv-python, scikit-image, scipy, tifffile
+        
+        ---
+        
+        ## 🧩 Citation
+        
+        If you use **AutoMorphoTrack** in your research, please cite:
+        
+        > **Bayati, A. (2025)**. AutoMorphoTrack: An accessible Python framework for automated analysis of organelle morphology and motility.  
+        > *GitHub Repository:* [https://github.com/abayatibrain/automorphotrack](https://github.com/abayatibrain/automorphotrack)
+        
+Platform: UNKNOWN
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown

AutoMorphoTrack-1.0.0/AutoMorphoTrack.egg-info/SOURCES.txt

@@ -0,0 +1,20 @@
+MANIFEST.in
+README.md
+setup.py
+AutoMorphoTrack.egg-info/PKG-INFO
+AutoMorphoTrack.egg-info/SOURCES.txt
+AutoMorphoTrack.egg-info/dependency_links.txt
+AutoMorphoTrack.egg-info/requires.txt
+AutoMorphoTrack.egg-info/top_level.txt
+automorphotrack/__init__.py
+automorphotrack/colocalization.py
+automorphotrack/detection.py
+automorphotrack/lyso_count.py
+automorphotrack/morphology.py
+automorphotrack/motility.py
+automorphotrack/shape_features.py
+automorphotrack/shape_profiling.py
+automorphotrack/summary.py
+automorphotrack/tracking.py
+automorphotrack/tracking_overlay.py
+automorphotrack/utils.py

AutoMorphoTrack-1.0.0/AutoMorphoTrack.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

AutoMorphoTrack-1.0.0/AutoMorphoTrack.egg-info/requires.txt

@@ -0,0 +1,8 @@
+numpy>=1.23.0
+pandas>=1.5.0
+matplotlib>=3.6.0
+seaborn>=0.12.0
+opencv-python>=4.6.0
+scikit-image>=0.19.0
+scipy>=1.9.0
+tifffile>=2022.8.12

AutoMorphoTrack-1.0.0/AutoMorphoTrack.egg-info/top_level.txt

@@ -0,0 +1 @@
+automorphotrack

AutoMorphoTrack-1.0.0/MANIFEST.in

@@ -0,0 +1,19 @@
+# Include documentation and license files
+include README.md
+include LICENSE
+include requirements.txt
+
+# Include all Python source files
+recursive-include automorphotrack *.py
+
+# Include any additional data files (if present)
+recursive-include automorphotrack *.csv
+recursive-include automorphotrack *.txt
+recursive-include automorphotrack *.ipynb
+recursive-include automorphotrack *.png
+recursive-include automorphotrack *.jpg
+recursive-include automorphotrack *.tif
+recursive-include automorphotrack *.json
+
+# Exclude unnecessary system or cache files
+global-exclude __pycache__ *.py[cod] .DS_Store

AutoMorphoTrack-1.0.0/PKG-INFO

@@ -0,0 +1,115 @@
+Metadata-Version: 2.1
+Name: AutoMorphoTrack
+Version: 1.0.0
+Summary: AutoMorphoTrack is an open-source Python package for automated detection, morphology classification, motility tracking, and colocalization analysis of organelles in multichannel fluorescence microscopy data.
+Home-page: https://github.com/abayatibrain/AMTpackage
+Author: Armin Bayati
+Author-email: a.bayati.brain@gmail.com
+License: MIT
+Project-URL: Documentation, https://github.com/abayatibrain/AMTpackage
+Project-URL: Source, https://github.com/abayatibrain/AMTpackage
+Project-URL: Tracker, https://github.com/abayatibrain/AMTpackage/issues
+Description: # AutoMorphoTrack
+        
+        **AutoMorphoTrack** is an open-source Python package for automated detection, morphology classification, shape profiling, motility tracking, and colocalization analysis of subcellular organelles in multichannel fluorescence microscopy data.  
+        
+        This package represents the fully modular version of the **AutoMorphoTrack pipeline**, originally developed as a Jupyter Notebook by **Armin Bayati, Ph.D.**, and now distributed as an installable Python framework.  
+        Repository: [https://github.com/abayatibrain/automorphotrack](https://github.com/abayatibrain/automorphotrack)
+        
+        ---
+        
+        ## 🧬 Overview
+        
+        AutoMorphoTrack automates quantitative analysis of time-lapse `.tif` image stacks—typically dual-channel recordings of mitochondria and lysosomes—and generates publication-ready visual and numerical outputs at every step of the analysis pipeline.
+        
+        **Pipeline stages:**
+        
+        1. **Detection** – Organelle segmentation and outline visualization  
+        2. **Lysosomal Counting** – Per-frame lysosome enumeration and temporal profiling  
+        3. **Morphology Classification** – Elongated vs. punctate mitochondria  
+        4. **Shape Feature Extraction** – Area, circularity, solidity, aspect ratio, orientation  
+        5. **Tracking** – Cumulative organelle trajectories (mitochondria, lysosomes, composite)  
+        6. **Motility Analysis** – Velocity, displacement, and trajectory-based statistics  
+        7. **Colocalization** – Bright-blue overlap overlays and correlation metrics  
+        8. **Integrated Summary** – Correlation matrices linking morphology, motility, and overlap  
+        
+        Each stage outputs high-resolution figures, videos, and CSV data tables stored in standardized subdirectories, ensuring reproducibility and compatibility with any image dataset.
+        
+        ---
+        
+        ## 📦 Installation
+        
+        Install directly from PyPI:
+        
+        ```bash
+        pip install AutoMorphoTrack
+        ```
+        
+        Or from source:
+        
+        ```bash
+        git clone https://github.com/abayatibrain/automorphotrack.git
+        cd automorphotrack
+        pip install -e .
+        ```
+        
+        ---
+        
+        ## 🚀 Basic Usage
+        
+        ```python
+        from automorphotrack import *
+        
+        tif_path = "Composite.tif"
+        
+        detect_organelles(tif_path)
+        count_lysosomes_per_frame(tif_path)
+        classify_morphology(tif_path)
+        analyze_shape_features(tif_path)
+        track_organelles(tif_path)
+        analyze_motility()
+        analyze_colocalization(tif_path)
+        summarize_integrated_data()
+        ```
+        
+        Each function automatically generates visual and quantitative outputs at every step.
+        
+        ---
+        
+        ## 📁 Outputs
+        
+        | Step | Output Type | Example Files |
+        |------|--------------|---------------|
+        | Detection | PNG + MP4 | `Mito_Frame0.png`, `Mitochondria_Detection.mp4` |
+        | Lysosome Count | PNG + CSV + MP4 | `Lyso_Count_Plot.png`, `Lysosome_Counts.csv` |
+        | Morphology | PNG + MP4 + CSV | `Morphology_Frame0_Labeled.png`, `Morphology_Labeled.mp4` |
+        | Shape Features | PNG + CSV | `Shape_Distributions.png`, `Mito_ShapeMetrics.csv` |
+        | Tracking | PNG + MP4 + CSV | `Cumulative_Mito.png`, `Mito_Tracks.csv` |
+        | Motility | PNG + CSV | `Motility_Distributions.png`, `Motility_Scatter.png` |
+        | Colocalization | PNG + MP4 + CSV | `Colocalization_Frame0.png`, `Colocalization.csv` |
+        | Summary | PNG + CSV | `Integrated_CorrelationMatrix.png`, `Integrated_Merged_Data.csv` |
+        
+        ---
+        
+        ## 🔧 Dependencies
+        
+        - Python ≥ 3.9  
+        - numpy, pandas, matplotlib, seaborn, opencv-python, scikit-image, scipy, tifffile
+        
+        ---
+        
+        ## 🧩 Citation
+        
+        If you use **AutoMorphoTrack** in your research, please cite:
+        
+        > **Bayati, A. (2025)**. AutoMorphoTrack: An accessible Python framework for automated analysis of organelle morphology and motility.  
+        > *GitHub Repository:* [https://github.com/abayatibrain/automorphotrack](https://github.com/abayatibrain/automorphotrack)
+        
+Platform: UNKNOWN
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown

AutoMorphoTrack-1.0.0/README.md

@@ -0,0 +1,95 @@
+# AutoMorphoTrack
+
+**AutoMorphoTrack** is an open-source Python package for automated detection, morphology classification, shape profiling, motility tracking, and colocalization analysis of subcellular organelles in multichannel fluorescence microscopy data.  
+
+This package represents the fully modular version of the **AutoMorphoTrack pipeline**, originally developed as a Jupyter Notebook by **Armin Bayati, Ph.D.**, and now distributed as an installable Python framework.  
+Repository: [https://github.com/abayatibrain/automorphotrack](https://github.com/abayatibrain/automorphotrack)
+
+---
+
+## 🧬 Overview
+
+AutoMorphoTrack automates quantitative analysis of time-lapse `.tif` image stacks—typically dual-channel recordings of mitochondria and lysosomes—and generates publication-ready visual and numerical outputs at every step of the analysis pipeline.
+
+**Pipeline stages:**
+
+1. **Detection** – Organelle segmentation and outline visualization  
+2. **Lysosomal Counting** – Per-frame lysosome enumeration and temporal profiling  
+3. **Morphology Classification** – Elongated vs. punctate mitochondria  
+4. **Shape Feature Extraction** – Area, circularity, solidity, aspect ratio, orientation  
+5. **Tracking** – Cumulative organelle trajectories (mitochondria, lysosomes, composite)  
+6. **Motility Analysis** – Velocity, displacement, and trajectory-based statistics  
+7. **Colocalization** – Bright-blue overlap overlays and correlation metrics  
+8. **Integrated Summary** – Correlation matrices linking morphology, motility, and overlap  
+
+Each stage outputs high-resolution figures, videos, and CSV data tables stored in standardized subdirectories, ensuring reproducibility and compatibility with any image dataset.
+
+---
+
+## 📦 Installation
+
+Install directly from PyPI:
+
+```bash
+pip install AutoMorphoTrack
+```
+
+Or from source:
+
+```bash
+git clone https://github.com/abayatibrain/automorphotrack.git
+cd automorphotrack
+pip install -e .
+```
+
+---
+
+## 🚀 Basic Usage
+
+```python
+from automorphotrack import *
+
+tif_path = "Composite.tif"
+
+detect_organelles(tif_path)
+count_lysosomes_per_frame(tif_path)
+classify_morphology(tif_path)
+analyze_shape_features(tif_path)
+track_organelles(tif_path)
+analyze_motility()
+analyze_colocalization(tif_path)
+summarize_integrated_data()
+```
+
+Each function automatically generates visual and quantitative outputs at every step.
+
+---
+
+## 📁 Outputs
+
+| Step | Output Type | Example Files |
+|------|--------------|---------------|
+| Detection | PNG + MP4 | `Mito_Frame0.png`, `Mitochondria_Detection.mp4` |
+| Lysosome Count | PNG + CSV + MP4 | `Lyso_Count_Plot.png`, `Lysosome_Counts.csv` |
+| Morphology | PNG + MP4 + CSV | `Morphology_Frame0_Labeled.png`, `Morphology_Labeled.mp4` |
+| Shape Features | PNG + CSV | `Shape_Distributions.png`, `Mito_ShapeMetrics.csv` |
+| Tracking | PNG + MP4 + CSV | `Cumulative_Mito.png`, `Mito_Tracks.csv` |
+| Motility | PNG + CSV | `Motility_Distributions.png`, `Motility_Scatter.png` |
+| Colocalization | PNG + MP4 + CSV | `Colocalization_Frame0.png`, `Colocalization.csv` |
+| Summary | PNG + CSV | `Integrated_CorrelationMatrix.png`, `Integrated_Merged_Data.csv` |
+
+---
+
+## 🔧 Dependencies
+
+- Python ≥ 3.9  
+- numpy, pandas, matplotlib, seaborn, opencv-python, scikit-image, scipy, tifffile
+
+---
+
+## 🧩 Citation
+
+If you use **AutoMorphoTrack** in your research, please cite:
+
+> **Bayati, A. (2025)**. AutoMorphoTrack: An accessible Python framework for automated analysis of organelle morphology and motility.  
+> *GitHub Repository:* [https://github.com/abayatibrain/automorphotrack](https://github.com/abayatibrain/automorphotrack)

AutoMorphoTrack-1.0.0/automorphotrack/__init__.py

@@ -0,0 +1,75 @@
+# ============================================================
+# AutoMorphoTrack – Automated Organelle Detection and Tracking
+# ============================================================
+# Author: Armin Bayati, Ph.D.
+# Description:
+#     AutoMorphoTrack is a modular image-analysis package for
+#     mitochondria and lysosome tracking, morphology, shape,
+#     motility, and colocalization analysis in fluorescence microscopy.
+#
+# Core Pipeline:
+#     1. Detection (detection.py)
+#     2. Lysosome counting (lyso_count.py)
+#     3. Morphology classification (morphology.py)
+#     4. Shape feature extraction (shape_features.py)
+#     5. Shape profiling (shape_profiling.py)
+#     6. Organelle tracking (tracking.py / tracking_overlay.py)
+#     7. Motility analysis (motility.py)
+#     8. Colocalization analysis (colocalization.py)
+#     9. Integrated summary (summary.py)
+#
+# Package structure follows:
+#     from automorphotrack import (
+#         detect_organelles,
+#         count_lysosomes_per_frame,
+#         classify_morphology,
+#         analyze_shape_features,
+#         profile_shape_data,
+#         track_organelles,
+#         track_overlay,
+#         analyze_motility,
+#         analyze_colocalization,
+#         summarize_integrated_data
+#     )
+# ============================================================
+
+__version__ = "1.0.0"
+__author__ = "Armin Bayati"
+
+# --- Utility Imports ---
+from automorphotrack.utils import (
+    ensure_dir,
+    save_high_dpi,
+    upscale_frame,
+    write_video
+)
+
+# --- Core Functional Imports ---
+from automorphotrack.detection import detect_organelles
+from automorphotrack.lyso_count import count_lysosomes_per_frame
+from automorphotrack.morphology import classify_morphology
+from automorphotrack.shape_features import analyze_shape_features
+from automorphotrack.shape_profiling import profile_shape_data
+from automorphotrack.tracking import track_organelles
+from automorphotrack.tracking_overlay import track_overlay
+from automorphotrack.motility import analyze_motility
+from automorphotrack.colocalization import analyze_colocalization
+from automorphotrack.summary import summarize_integrated_data
+
+# --- Convenience Alias (optional shortcut API) ---
+__all__ = [
+    "ensure_dir",
+    "save_high_dpi",
+    "upscale_frame",
+    "write_video",
+    "detect_organelles",
+    "count_lysosomes_per_frame",
+    "classify_morphology",
+    "analyze_shape_features",
+    "profile_shape_data",
+    "track_organelles",
+    "track_overlay",
+    "analyze_motility",
+    "analyze_colocalization",
+    "summarize_integrated_data"
+]

AutoMorphoTrack-1.0.0/automorphotrack/colocalization.py

@@ -0,0 +1,128 @@
+# ============================================================
+# AutoMorphoTrack – Colocalization Analysis (Manders + Pearson)
+# ============================================================
+
+import tifffile, cv2, numpy as np, pandas as pd, matplotlib.pyplot as plt
+from skimage.filters import threshold_otsu
+from pathlib import Path
+from automorphotrack.utils import ensure_dir, save_high_dpi
+
+def analyze_colocalization(
+    tif_path="Composite.tif",
+    mito_channel=0,
+    lyso_channel=1,
+    out_dir="Colocalization_Outputs",
+    fps=5,
+    upscale=2.0,
+    overlay_alpha=0.6):
+
+    ensure_dir(out_dir)
+    stack = tifffile.imread(tif_path)
+    if stack.shape[1] == 3 and stack.shape[-1] != 3:
+        stack = np.moveaxis(stack, 1, -1)
+    n_frames = stack.shape[0]
+    print(f"Loaded {n_frames} frames for colocalization analysis")
+
+    # ---------- Helpers ----------
+    def upscale_frame(img):
+        h, w = img.shape[:2]
+        return cv2.resize(img, (int(w * upscale), int(h * upscale)), interpolation=cv2.INTER_CUBIC)
+
+    def write_video(frames, out_path, fps):
+        h, w = frames[0].shape[:2]
+        out = cv2.VideoWriter(str(out_path), cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))
+        for fr in frames:
+            out.write(cv2.cvtColor(fr, cv2.COLOR_RGB2BGR))
+        out.release()
+
+    frames_out = []
+    overlap_percent, m1_list, m2_list = [], [], []
+    pearson_r, overlap_R = [], []
+    mito_sum, lyso_sum = [], []
+
+    for f in range(n_frames):
+        mito = stack[f][..., mito_channel].astype(float)
+        lyso = stack[f][..., lyso_channel].astype(float)
+
+        # Background correction
+        mito -= np.percentile(mito, 5)
+        lyso -= np.percentile(lyso, 5)
+        mito, lyso = np.clip(mito, 0, None), np.clip(lyso, 0, None)
+
+        # Binary masks
+        thr_m, thr_l = threshold_otsu(mito), threshold_otsu(lyso)
+        mito_mask, lyso_mask = mito > thr_m, lyso > thr_l
+        overlap_mask, union_mask = mito_mask & lyso_mask, mito_mask | lyso_mask
+
+        # Metrics
+        overlap_ratio = (overlap_mask.sum() / union_mask.sum() * 100) if union_mask.sum() else 0
+        overlap_percent.append(overlap_ratio)
+        M1 = mito[lyso_mask].sum() / mito.sum() if mito.sum() > 0 else 0
+        M2 = lyso[mito_mask].sum() / lyso.sum() if lyso.sum() > 0 else 0
+        m1_list.append(M1)
+        m2_list.append(M2)
+
+        flat_m, flat_l = mito.flatten(), lyso.flatten()
+        if np.std(flat_m) > 0 and np.std(flat_l) > 0:
+            pearson_r.append(np.corrcoef(flat_m, flat_l)[0, 1])
+        else:
+            pearson_r.append(0)
+        denom = np.sqrt((mito**2).sum() * (lyso**2).sum())
+        overlap_R.append((mito * lyso).sum() / denom if denom > 0 else 0)
+
+        mito_sum.append(mito.sum())
+        lyso_sum.append(lyso.sum())
+
+        # Visualization with bright-blue overlay
+        mito_norm = (mito / mito.max() * 255).astype(np.uint8)
+        lyso_norm = (lyso / lyso.max() * 255).astype(np.uint8)
+        rgb = np.zeros((*mito.shape, 3), np.uint8)
+        rgb[..., 0], rgb[..., 1] = mito_norm, lyso_norm
+
+        mask = overlap_mask.astype(bool)
+        bright_blue_overlay = np.full_like(rgb[mask], (0, 150, 255), dtype=np.uint8)
+        rgb[mask] = cv2.addWeighted(rgb[mask], 1 - overlay_alpha, bright_blue_overlay, overlay_alpha, 0)
+
+        frames_out.append(upscale_frame(rgb))
+
+    # ---------- Save metrics ----------
+    csv_path = Path(out_dir) / "Colocalization.csv"
+    pd.DataFrame({
+        "Frame": np.arange(n_frames),
+        "Percent_Overlap": overlap_percent,
+        "Manders_M1": m1_list,
+        "Manders_M2": m2_list,
+        "Pearson_r": pearson_r,
+        "Overlap_R": overlap_R,
+        "Mito_TotalIntensity": mito_sum,
+        "Lyso_TotalIntensity": lyso_sum
+    }).to_csv(csv_path, index=False)
+    print(f"Saved metrics → {csv_path}")
+
+    # ---------- Save video ----------
+    video_path = Path(out_dir) / "Colocalization_BrightBlueOverlay.mp4"
+    write_video(frames_out, video_path, fps=fps)
+
+    # ---------- Save frame 0 still ----------
+    frame0_path = Path(out_dir) / "Colocalization_Frame0.png"
+    cv2.imwrite(str(frame0_path),
+                cv2.cvtColor(frames_out[0], cv2.COLOR_RGB2BGR),
+                [cv2.IMWRITE_PNG_COMPRESSION, 0])
+
+    # ---------- Plot metrics ----------
+    plot_path = Path(out_dir) / "Colocalization_MetricsPlot.png"
+    fig, ax = plt.subplots(figsize=(10, 9))
+    ax.plot(m1_list, 'r-', label='Manders M1 (mito→lyso)')
+    ax.plot(m2_list, 'g-', label='Manders M2 (lyso→mito)')
+    ax.plot(np.array(overlap_percent) / 100, 'b--', label='Overlap fraction')
+    ax.plot(pearson_r, 'k-.', label='Pearson r')
+    ax.plot(overlap_R, 'm:', label='Normalized R')
+    ax.set_xlabel("Frame")
+    ax.set_ylabel("Coefficient / Fraction (0–1)")
+    ax.set_ylim(0, 1)
+    ax.legend()
+    ax.set_title("Colocalization Metrics Over Time")
+    plt.tight_layout()
+    save_high_dpi(fig, plot_path)
+
+    print(f"Colocalization analysis complete — results saved in {Path(out_dir).resolve()}")

AutoMorphoTrack-1.0.0/automorphotrack/detection.py

@@ -0,0 +1,65 @@
+# ============================================================
+# AutoMorphoTrack – Organelle Detection
+# ============================================================
+
+import tifffile, numpy as np, cv2
+from skimage.filters import threshold_otsu
+from skimage.morphology import remove_small_objects, binary_opening, disk
+from skimage.segmentation import clear_border
+from pathlib import Path
+from automorphotrack.utils import ensure_dir, write_video, upscale_frame
+
+def detect_mask(frame, ch, thr_factor=0.8, min_size=3):
+    """Threshold and clean a single channel."""
+    img = frame[..., ch].astype(float)
+    img = (img - img.min()) / (img.ptp() + 1e-12)
+    thr = threshold_otsu(img) * thr_factor
+    mask = clear_border(binary_opening(img > thr, footprint=disk(1)))
+    mask = remove_small_objects(mask, min_size)
+    return (mask * 255).astype(np.uint8), img
+
+def detect_organelles(
+    tif_path="Composite.tif",
+    out_dir="Detection_Outputs",
+    mito_channel=0,
+    lyso_channel=1,
+    upscale_factor=2,
+    fps=5):
+
+    ensure_dir(out_dir)
+    stack = tifffile.imread(str(tif_path))
+    if stack.shape[1] == 3 and stack.shape[-1] != 3:
+        stack = np.moveaxis(stack, 1, -1)
+    n_frames = stack.shape[0]
+    print(f"Loaded {n_frames} frames for detection")
+
+    mito_frames, lyso_frames = [], []
+
+    for f in range(n_frames):
+        # ----- Mitochondria (relaxed detection) -----
+        mito_mask, mito_img = detect_mask(stack[f], mito_channel, thr_factor=0.6, min_size=0.5)
+        mito_gray = (mito_img * 255).astype(np.uint8)
+        mito_rgb = cv2.cvtColor(mito_gray, cv2.COLOR_GRAY2RGB)
+        cnts, _ = cv2.findContours(mito_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        cv2.drawContours(mito_rgb, cnts, -1, (255, 0, 0), 1, cv2.LINE_AA)
+        mito_frames.append(upscale_frame(mito_rgb, upscale_factor))
+
+        # ----- Lysosomes (standard detection) -----
+        lyso_mask, lyso_img = detect_mask(stack[f], lyso_channel, thr_factor=0.8, min_size=2)
+        lyso_gray = (lyso_img * 255).astype(np.uint8)
+        lyso_rgb = cv2.cvtColor(lyso_gray, cv2.COLOR_GRAY2RGB)
+        cnts, _ = cv2.findContours(lyso_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        cv2.drawContours(lyso_rgb, cnts, -1, (0, 255, 0), 1, cv2.LINE_AA)
+        lyso_frames.append(upscale_frame(lyso_rgb, upscale_factor))
+
+    # Save representative frames
+    cv2.imwrite(str(Path(out_dir) / "Mito_Frame0.png"),
+                cv2.cvtColor(mito_frames[0], cv2.COLOR_RGB2BGR))
+    cv2.imwrite(str(Path(out_dir) / "Lyso_Frame0.png"),
+                cv2.cvtColor(lyso_frames[0], cv2.COLOR_RGB2BGR))
+
+    # Save videos
+    write_video(mito_frames, Path(out_dir) / "Mitochondria_Detection.mp4", fps=fps)
+    write_video(lyso_frames, Path(out_dir) / "Lysosomes_Detection.mp4", fps=fps)
+
+    print(f"Detection complete — outputs saved in {Path(out_dir).resolve()}")