PoLab-analyzer 0.1.0__tar.gz

polab_analyzer-0.1.0/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: PoLab_analyzer
+Version: 0.1.0
+Summary: CLI tools for PoLab eve and hunchback in-situ image analysis
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: matplotlib
+Requires-Dist: scipy
+Requires-Dist: openpyxl

polab_analyzer-0.1.0/README.md

@@ -0,0 +1,2 @@
+# polab_analyzer
+This repository contains in-situ image analysis program for eve and hunchback.

polab_analyzer-0.1.0/pyproject.toml

@@ -0,0 +1,19 @@
+[build-system]
+requires = ["setuptools>=61.0.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "PoLab_analyzer"
+version = "0.1.0"
+description = "CLI tools for PoLab eve and hunchback in-situ image analysis"
+dependencies = [
+    "numpy",
+    "pandas",
+    "matplotlib",
+    "scipy",
+    "openpyxl"
+]
+
+[project.scripts]
+eve = "scripts.eve:main"
+hb = "scripts.hb:main"

polab_analyzer-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

polab_analyzer-0.1.0/src/PoLab_analyzer.egg-info/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: PoLab_analyzer
+Version: 0.1.0
+Summary: CLI tools for PoLab eve and hunchback in-situ image analysis
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: matplotlib
+Requires-Dist: scipy
+Requires-Dist: openpyxl

polab_analyzer-0.1.0/src/PoLab_analyzer.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+src/PoLab_analyzer.egg-info/PKG-INFO
+src/PoLab_analyzer.egg-info/SOURCES.txt
+src/PoLab_analyzer.egg-info/dependency_links.txt
+src/PoLab_analyzer.egg-info/entry_points.txt
+src/PoLab_analyzer.egg-info/requires.txt
+src/PoLab_analyzer.egg-info/top_level.txt
+src/scripts/__init__.py
+src/scripts/eve.py
+src/scripts/hb.py

polab_analyzer-0.1.0/src/PoLab_analyzer.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

polab_analyzer-0.1.0/src/PoLab_analyzer.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+eve = scripts.eve:main
+hb = scripts.hb:main

polab_analyzer-0.1.0/src/PoLab_analyzer.egg-info/requires.txt

@@ -0,0 +1,5 @@
+numpy
+pandas
+matplotlib
+scipy
+openpyxl

polab_analyzer-0.1.0/src/PoLab_analyzer.egg-info/top_level.txt

@@ -0,0 +1 @@
+scripts

polab_analyzer-0.1.0/src/scripts/eve.py

@@ -0,0 +1,787 @@
+#!/usr/bin/env python3
+import argparse
+import os
+from posixpath import abspath
+import re
+import sys
+import warnings
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+from openpyxl import load_workbook
+from openpyxl.drawing.image import Image as XLImage
+from scipy.signal import find_peaks, savgol_filter
+
+warnings.simplefilter(action="ignore", category=FutureWarning)
+
+
+# --- Helper: test run without saving ---
+def test_parameters(excel_file, lower_lim, upper_lim, distance, prominence, height):
+    discarded_sheets = 0
+    total_sheets = 0
+
+    try:
+        xl = pd.ExcelFile(excel_file)
+        # Process sheets that match the 's' followed by digits pattern
+        sheet_names = [s for s in xl.sheet_names if re.match(r"^s\d+$", s)]
+    except Exception:
+        return 0, 0
+
+    for sheet_name in sheet_names:
+        try:
+            data = pd.read_excel(excel_file, sheet_name=sheet_name)
+            length = data.iloc[:, 0]
+            intensity = data.iloc[:, 1]
+
+            norm_intensity = intensity / intensity.max()
+            inverted_intensity = 1 - norm_intensity
+            norm_length = length / length.max()
+            percent_length = norm_length * 100
+
+            smoothed = savgol_filter(inverted_intensity, 11, 2)
+            diff = np.diff(smoothed, prepend=smoothed[0])
+            change_points = np.diff(np.sign(diff), prepend=0)
+            change_point_flags = (change_points < 0).astype(int)
+
+            peaks, _ = find_peaks(
+                smoothed, distance=distance, prominence=prominence, height=height
+            )
+            peak_percent_lengths = percent_length.iloc[peaks].values
+            valid_peak_mask = (peak_percent_lengths > lower_lim) & (
+                    peak_percent_lengths < upper_lim
+            )
+            peak_percent_lengths = peak_percent_lengths[valid_peak_mask]
+
+            data["Percent Length"] = percent_length
+            data["Change Point"] = change_point_flags
+
+            change_df = data[
+                (data["Change Point"] == 1) & (data["Percent Length"] < upper_lim)
+                ]
+            closest_matches = []
+            for px in peak_percent_lengths:
+                if not change_df.empty:
+                    closest = change_df.iloc[
+                        (change_df["Percent Length"] - px).abs().argsort()[:1]
+                    ]
+                    closest_val = closest["Percent Length"].values[0]
+                    closest_matches.append(closest_val)
+
+            total_sheets += 1
+            if len(closest_matches) != 7:
+                discarded_sheets += 1
+
+        except Exception:
+            discarded_sheets += 1
+
+    return discarded_sheets, total_sheets
+
+
+
+def test_parameters2(input_folder, lower_lim, upper_lim, distance, prominence, height):
+    discarded_files = 0
+    total_files = 0
+
+    for filename in os.listdir(input_folder):
+        if filename.endswith(".xlsx"):
+            input_path = os.path.join(input_folder, filename)
+            try:
+                data = pd.read_excel(input_path)
+                length = data.iloc[:, 0]
+                intensity = data.iloc[:, 1]
+
+                norm_intensity = intensity / intensity.max()
+                inverted_intensity = 1 - norm_intensity
+                norm_length = length / length.max()
+                percent_length = norm_length * 100
+
+                smoothed = savgol_filter(inverted_intensity, 11, 2)
+                diff = np.diff(smoothed, prepend=smoothed[0])
+                change_points = np.diff(np.sign(diff), prepend=0)
+                change_point_flags = (change_points < 0).astype(int)
+
+                peaks, _ = find_peaks(
+                    smoothed, distance=distance, prominence=prominence, height=height
+                )
+                peak_percent_lengths = percent_length.iloc[peaks].values
+                valid_peak_mask = (peak_percent_lengths > lower_lim) & (
+                        peak_percent_lengths < upper_lim
+                )
+                peak_percent_lengths = peak_percent_lengths[valid_peak_mask]
+
+                data["Percent Length"] = percent_length
+                data["Change Point"] = change_point_flags
+
+                change_df = data[
+                    (data["Change Point"] == 1) & (data["Percent Length"] < upper_lim)
+                    ]
+                closest_matches = []
+                for px in peak_percent_lengths:
+                    if not change_df.empty:
+                        closest = change_df.iloc[
+                            (change_df["Percent Length"] - px).abs().argsort()[:1]
+                        ]
+                        closest_val = closest["Percent Length"].values[0]
+                        closest_matches.append(closest_val)
+
+                total_files += 1
+                if len(closest_matches) != 7:
+                    discarded_files += 1
+
+            except Exception:
+                discarded_files += 1
+
+    return discarded_files, total_files  
+
+
+def generate_stripe_summary(output_folder):
+    summary_output_path = os.path.join(output_folder, "stripe_summary.xlsx")
+
+    all_rows = []
+    processed_files = sorted(
+        [
+            f
+            for f in os.listdir(output_folder)
+            if f.startswith("processed_") and f.endswith(".xlsx")
+        ],
+        key=lambda x: (
+            int(re.findall(r"(\d+)", x)[-1]) if re.findall(r"(\d+)", x) else 0
+        ),
+    )
+
+    for fname in processed_files:
+        fpath = os.path.join(output_folder, fname)
+        try:
+            wb = load_workbook(fpath, data_only=True)
+            if "Peaks" not in wb.sheetnames:
+                continue
+
+            peaks_ws = wb["Peaks"]
+            peaks = []
+            for i, r in enumerate(
+                    peaks_ws.iter_rows(min_row=2, values_only=True), start=2
+            ):
+                if r[0] is not None:
+                    peaks.append(r[0])
+
+            if len(peaks) != 7:
+                print(f"\033[91mSkipping {fname}\033[0m: found {len(peaks)} stripes, not 7.")
+                continue
+
+            row_data = {"File": fname}
+            for i, p in enumerate(peaks, start=1):
+                row_data[f"Stripe-{i}"] = p
+
+            all_rows.append(row_data)
+
+        except Exception as e:
+            print(f"Error reading {fname}: {e}")
+
+    # Save summary
+    summary_df = pd.DataFrame(all_rows)
+    summary_df.to_excel(summary_output_path, index=False)
+    print(f"\033[92mStripe summary written to: {summary_output_path}\033[0m")
+
+
+def run_pipeline(
+    excel_file,
+    lower_lim,
+    upper_lim,
+    test,
+    distance,
+    prominence,
+    height,
+    distances,
+    prom_range,
+    height_range,
+):
+    """Auto-tune (or use fixed) peak-detection parameters and process every
+    s1, s2, s3, ... sheet of a single Excel file. Shared by both --file mode
+    (one file) and --folder mode (looped over every xlsx file in the folder)."""
+    if test:
+        # --- Grid search mode ---
+        distances_list = distances
+        prominences = np.arange(
+            prom_range[0],
+            prom_range[1] + prom_range[2],
+            prom_range[2],
+        )
+        heights = np.arange(
+            height_range[0],
+            height_range[1] + height_range[2],
+            height_range[2],
+        )
+
+        best_params = None
+        best_discarded = float("inf")
+
+        total_iterations = len(distances_list) * len(prominences) * len(heights)
+        current_iteration = 0
+
+        print(f"\n\033[94mRunning parameter grid search over sheets in '{os.path.basename(excel_file)}'...\033[0m")
+
+        for d in distances_list:
+            for p in prominences:
+                for h in heights:
+                    discarded, total = test_parameters(
+                        excel_file, lower_lim, upper_lim, d, p, h
+                    )
+                    if discarded < best_discarded:
+                        best_discarded = discarded
+                        best_params = (d, p, h)
+
+                    current_iteration += 1
+                    percent = (current_iteration / total_iterations) * 100
+
+                    sys.stdout.write(
+                        f"\r\033[92mProgress: [{percent:3.0f}%]\033[0m Processing parameter set {current_iteration}/{total_iterations}..."
+                    )
+                    sys.stdout.flush()
+
+        print("\n")
+
+        print(
+            f"\033[96mFound best parameters:\033[0m distance={best_params[0]}, "
+            f"prominence={best_params[1]:.2f}, height={best_params[2]:.2f} "
+            f"(\033[91mdiscarded {best_discarded} sheets\033[0m)"
+        )
+
+        final_distance, final_prominence, final_height = best_params
+
+    else:
+        # --- Direct mode ---
+        final_distance = distance
+        final_prominence = prominence
+        final_height = height
+
+        print(
+            f"\n Using user-specified parameters: "
+            f"distance={final_distance}, prominence={final_prominence}, height={final_height}"
+        )
+
+    process_excel_file(
+        excel_file,
+        lower_lim,
+        upper_lim,
+        distance=final_distance,
+        prominence=final_prominence,
+        height=final_height,
+    )
+    
+    
+def run_pipeline2(input_folder, lower_lim, upper_lim, test, distance, prominence, height, distances, prom_range, height_range):
+    if test:
+        # --- Grid search mode ---
+        distances_list = distances
+        prominences = np.arange(
+            prom_range[0],
+            prom_range[1] + prom_range[2],
+            prom_range[2],
+        )
+        heights = np.arange(
+            height_range[0],
+            height_range[1] + height_range[2],
+            height_range[2],
+        )
+
+        best_params = None
+        best_discarded = float("inf")
+
+        total_iterations = len(distances_list) * len(prominences) * len(heights)
+        current_iteration = 0
+
+        print(f"\n\033[94mRunning parameter grid search over files in '{os.path.basename(input_folder)}'...\033[0m")
+
+        for d in distances_list:
+            for p in prominences:
+                for h in heights:
+                    discarded, total = test_parameters2(
+                        input_folder, lower_lim, upper_lim, d, p, h
+                    )
+                    if discarded < best_discarded:
+                        best_discarded = discarded
+                        best_params = (d, p, h)
+
+                    current_iteration += 1
+                    percent = (current_iteration / total_iterations) * 100
+
+                    sys.stdout.write(
+                        f"\r\033[92mProgress: [{percent:3.0f}%]\033[0m Processing parameter set {current_iteration}/{total_iterations}..."
+                    )
+                    sys.stdout.flush()
+
+        print("\n")
+
+        print(
+            f"\033[96mFound best parameters:\033[0m distance={best_params[0]}, "
+            f"prominence={best_params[1]:.2f}, height={best_params[2]:.2f} "
+            f"(\033[91mdiscarded {best_discarded} files\033[0m)"
+        )
+
+        final_distance, final_prominence, final_height = best_params
+
+    else:
+        # --- Direct mode ---
+        final_distance = distance
+        final_prominence = prominence
+        final_height = height
+        print(
+            f"\n Using user-specified parameters: "
+            f"distance={final_distance}, prominence={final_prominence}, height={final_height}"
+        )
+
+    process_folder(
+        input_folder,
+        lower_lim,
+        upper_lim,
+        distance=final_distance,
+        prominence=final_prominence,
+        height=final_height,
+    )
+
+
+def process_folder(input_folder, lower_lim, upper_lim, distance=10, prominence=0.03, height = 0.1):
+    output_folder = os.path.join(input_folder, "results")
+    os.makedirs(output_folder, exist_ok=True)
+
+    for filename in os.listdir(input_folder):
+        if filename.endswith(".xlsx"):
+            input_path = os.path.join(input_folder, filename)
+            output_path = os.path.join(output_folder, f"processed_{filename}")
+            temp_plot_path = "temp_plot.png"
+            try:
+                data = pd.read_excel(input_path)
+                length = data.iloc[:, 0]
+                intensity = data.iloc[:, 1]
+
+                norm_intensity = intensity / intensity.max()
+                inverted_intensity = 1 - norm_intensity
+                norm_length = length / length.max()
+                percent_length = norm_length * 100
+
+                smoothed = savgol_filter(inverted_intensity, 11, 2)
+                diff = np.diff(smoothed, prepend=smoothed[0])
+                change_points = np.diff(np.sign(diff), prepend=0)
+                change_point_flags = (change_points < 0).astype(int)
+                
+                # Detect peaks
+                peaks, _ = find_peaks(smoothed, distance=distance, prominence=prominence, height=height)
+                peak_percent_lengths = percent_length.iloc[peaks].values
+                peak_values = smoothed[peaks]
+                valid_peak_mask = (peak_percent_lengths > lower_lim) & (peak_percent_lengths < upper_lim)
+                peak_percent_lengths = peak_percent_lengths[valid_peak_mask]
+                peak_values = peak_values[valid_peak_mask]
+
+                data['Normalized Intensity'] = norm_intensity
+                data['Inverted Intensity'] = inverted_intensity
+                data['Normalized Length'] = norm_length
+                data['Percent Length'] = percent_length
+                data['Smoothed'] = smoothed
+                data['Difference'] = diff
+                data['Change Point'] = change_point_flags
+                data.to_excel(output_path, index=False)
+
+                plt.figure(figsize=(5, 3))
+                plt.plot(percent_length, smoothed, label="Smoothed", color='blue')
+                plt.scatter(peak_percent_lengths, peak_values, color='red', s=50, label=f"Peaks > {lower_lim}%")
+                plt.title("Smoothed Inverted Intensity")
+                plt.xlabel("Percent Length (%)")
+                plt.ylabel("Inverted Intensity")
+                plt.legend()
+                plt.tight_layout()
+                plt.savefig(temp_plot_path, dpi=200)
+                plt.close()
+                wb = load_workbook(output_path)
+                ws = wb.active
+                img = XLImage(temp_plot_path)
+                img.width = 360
+                img.height = 220
+                ws.add_image(img, "K2")
+                wb.save(output_path)
+
+                # Add Peaks Sheets
+                if "Peaks" in wb.sheetnames:
+                    del wb["Peaks"]
+                peak_ws = wb.create_sheet("Peaks")
+                peak_ws.append(["Percent Length", "Inverted Intensity"])
+                for x, y in zip(peak_percent_lengths, peak_values):
+                    peak_ws.append([x, y])
+
+                # Match peaks with change_df data frame
+                change_df = data[(data["Change Point"] == 1) & (data["Percent Length"] > lower_lim) & (
+                            data["Percent Length"] < upper_lim)]
+                closest_matches = []
+                for px in peak_percent_lengths:
+                    if not change_df.empty:
+                        closest = change_df.iloc[(change_df["Percent Length"] - px).abs().argsort()[:1]]
+                        closest_val = closest["Percent Length"].values[0]
+                        closest_matches.append(closest_val)
+                        
+                # Discard files which have not exactly 7 stripes.
+                if len(closest_matches) != 7:
+                    print(
+                        f"\033[91mSkipping {filename}:\033[0m found {len(closest_matches)} stripes, not exactly 7."
+                        )
+                    if os.path.exists(temp_plot_path):
+                        os.remove(temp_plot_path)
+                    continue
+                wb.save(output_path)
+                if os.path.exists(temp_plot_path):
+                    os.remove(temp_plot_path)
+
+                # Add macro sheets.
+                macro_df = pd.DataFrame({
+                    "Percent Length": percent_length,
+                    "Inverted Intensity": inverted_intensity
+                })
+                with pd.ExcelWriter(output_path, engine='openpyxl', mode='a', if_sheet_exists="replace") as writer:
+                    macro_df.to_excel(writer, sheet_name="Macro", index=False)
+
+                # Add macro 600 points sheet
+                indices = np.linspace(0, len(macro_df) - 1, 600, dtype=int)
+                squeezed_macro_df = macro_df.iloc[indices].reset_index(drop=True)
+                with pd.ExcelWriter(output_path, engine='openpyxl', mode='a', if_sheet_exists='replace') as writer:
+                    squeezed_macro_df.to_excel(writer, sheet_name='Macro_600points', index=False)
+            except Exception as e:
+                print(f"Error processing {filename}: {e}")
+
+    def extract_numeric_suffix(filename):
+        nums = re.findall(r'(\d+)', filename)
+        return tuple(map(int, nums)) if nums else (0,)
+    # Combine all Macro_600points into one Excel
+    macro_percent_cols = []
+    macro_intensity_cols = []
+    sample_names = []
+    processed_files = sorted(
+        [f for f in os.listdir(output_folder) if f.startswith("processed_") and f.endswith(".xlsx")],
+        key=lambda x: int(re.findall(r'(\d+)', x)[-1])
+    )
+    for idx, fname in enumerate(processed_files, start=1):
+        fpath = os.path.join(output_folder, fname)
+        try:
+            df = pd.read_excel(fpath, sheet_name="Macro")
+            percent_col = df.iloc[:, 0] / df.iloc[:, 0].max()
+            intensity_col = df.iloc[:, 1]
+            indices = np.linspace(0, len(df) - 1, 600, dtype=int)
+            percent_squeezed = percent_col.iloc[indices].reset_index(drop=True)
+            intensity_squeezed = intensity_col.iloc[indices].reset_index(drop=True)
+            
+            label = os.path.basename(input_folder) + f"_{idx}"
+            sample_names.append(label)
+            macro_percent_cols.append(percent_squeezed.rename(label))
+            macro_intensity_cols.append(intensity_squeezed.rename(label))
+        except Exception:
+            pass
+            
+    percent_df = pd.concat(macro_percent_cols, axis=1)
+    intensity_df = pd.concat(macro_intensity_cols, axis=1)
+    percent_df[""] = ""
+    intensity_df[""] = ""
+    percent_df["Average"] = percent_df.select_dtypes(include=[np.number]).mean(axis=1)
+    intensity_df["Average"] = intensity_df.select_dtypes(include=[np.number]).mean(axis=1)
+    combined_macro_path = os.path.join(output_folder, "combined_macro_600points.xlsx")
+    with pd.ExcelWriter(combined_macro_path) as writer:
+        percent_df.to_excel(writer, sheet_name="Percent Length", index=False)
+        intensity_df.to_excel(writer, sheet_name="Inverted Intensity", index=False)
+
+    generate_stripe_summary(output_folder)
+    
+    
+    
+def process_excel_file(
+        excel_file, lower_lim, upper_lim, distance=10, prominence=0.03, height=0.1
+):
+    parent_folder = os.path.dirname(os.path.abspath(excel_file))
+    base_name = os.path.splitext(os.path.basename(excel_file))[0]
+    output_folder = os.path.join(parent_folder, "results")
+    os.makedirs(output_folder, exist_ok=True)
+
+    xl = pd.ExcelFile(excel_file)
+    sheet_names = sorted(
+        [s for s in xl.sheet_names if re.match(r"^s\d+$", s)],
+        key=lambda x: int(re.findall(r"(\d+)", x)[0])
+    )
+
+    for sheet_name in sheet_names:
+        output_path = os.path.join(output_folder, f"processed_{base_name}_{sheet_name}.xlsx")
+        temp_plot_path = f"temp_plot_{sheet_name}.png"
+        try:
+            data = pd.read_excel(excel_file, sheet_name=sheet_name)
+            length = data.iloc[:, 0]
+            intensity = data.iloc[:, 1]
+
+            norm_intensity = intensity / intensity.max()
+            inverted_intensity = 1 - norm_intensity
+            norm_length = length / length.max()
+            percent_length = norm_length * 100
+
+            smoothed = savgol_filter(inverted_intensity, 11, 2)
+            diff = np.diff(smoothed, prepend=smoothed[0])
+            change_points = np.diff(np.sign(diff), prepend=0)
+            change_point_flags = (change_points < 0).astype(int)
+
+            # Detect peaks
+            peaks, _ = find_peaks(
+                smoothed, distance=distance, prominence=prominence, height=height
+            )
+            peak_percent_lengths = percent_length.iloc[peaks].values
+            peak_values = smoothed[peaks]
+            valid_peak_mask = (peak_percent_lengths > lower_lim) & (
+                    peak_percent_lengths < upper_lim
+            )
+            peak_percent_lengths = peak_percent_lengths[valid_peak_mask]
+            peak_values = peak_values[valid_peak_mask]
+
+            data["Normalized Intensity"] = norm_intensity
+            data["Inverted Intensity"] = inverted_intensity
+            data["Normalized Length"] = norm_length
+            data["Percent Length"] = percent_length
+            data["Smoothed"] = smoothed
+            data["Difference"] = diff
+            data["Change Point"] = change_point_flags
+            data.to_excel(output_path, index=False)
+
+            plt.figure(figsize=(5, 3))
+            plt.plot(percent_length, smoothed, label="Smoothed", color="blue")
+            plt.scatter(
+                peak_percent_lengths,
+                peak_values,
+                color="red",
+                s=50,
+                label=f"Peaks > {lower_lim}%",
+            )
+            plt.title("Smoothed Inverted Intensity")
+            plt.xlabel("Percent Length (%)")
+            plt.ylabel("Inverted Intensity")
+            plt.legend()
+            plt.tight_layout()
+            plt.savefig(temp_plot_path, dpi=200)
+            plt.close()
+
+            wb = load_workbook(output_path)
+            ws = wb.active
+            img = XLImage(temp_plot_path)
+            img.width = 360
+            img.height = 220
+            ws.add_image(img, "K2")
+            wb.save(output_path)
+
+            # Add Peaks Sheets
+            if "Peaks" in wb.sheetnames:
+                del wb["Peaks"]
+            peak_ws = wb.create_sheet("Peaks")
+            peak_ws.append(["Percent Length", "Inverted Intensity"])
+            for x, y in zip(peak_percent_lengths, peak_values):
+                peak_ws.append([x, y])
+
+            # Match peaks with change_df data frame
+            change_df = data[
+                (data["Change Point"] == 1)
+                & (data["Percent Length"] > lower_lim)
+                & (data["Percent Length"] < upper_lim)
+                ]
+            closest_matches = []
+            for px in peak_percent_lengths:
+                if not change_df.empty:
+                    closest = change_df.iloc[
+                        (change_df["Percent Length"] - px).abs().argsort()[:1]
+                    ]
+                    closest_val = closest["Percent Length"].values[0]
+                    closest_matches.append(closest_val)
+
+            # Discard files which have not exactly 7 stripes.
+            if len(closest_matches) != 7:
+                print(
+                    f"\033[91mSkipping sheet {sheet_name}:\033[0m found {len(closest_matches)} stripes, not exactly 7."
+                )
+                if os.path.exists(temp_plot_path):
+                    os.remove(temp_plot_path)
+                continue
+            wb.save(output_path)
+            if os.path.exists(temp_plot_path):
+                os.remove(temp_plot_path)
+
+            # Add macro sheets.
+            macro_df = pd.DataFrame(
+                {
+                    "Percent Length": percent_length,
+                    "Inverted Intensity": inverted_intensity,
+                }
+            )
+            with pd.ExcelWriter(
+                    output_path, engine="openpyxl", mode="a", if_sheet_exists="replace"
+            ) as writer:
+                macro_df.to_excel(writer, sheet_name="Macro", index=False)
+
+            # Add macro 600 points sheet
+            indices = np.linspace(0, len(macro_df) - 1, 600, dtype=int)
+            squeezed_macro_df = macro_df.iloc[indices].reset_index(drop=True)
+            with pd.ExcelWriter(
+                    output_path, engine="openpyxl", mode="a", if_sheet_exists="replace"
+            ) as writer:
+                squeezed_macro_df.to_excel(
+                    writer, sheet_name="Macro_600points", index=False
+                )
+        except Exception as e:
+            print(f"Error processing sheet {sheet_name}: {e}")
+            if os.path.exists(temp_plot_path):
+                os.remove(temp_plot_path)
+
+    # Combine all Macro_600points into one Excel
+    macro_percent_cols = []
+    macro_intensity_cols = []
+    processed_files = sorted(
+        [
+            f
+            for f in os.listdir(output_folder)
+            if f.startswith("processed_") and f.endswith(
+            ".xlsx") and "stripe_summary" not in f and "combined_macro" not in f
+        ],
+        key=lambda x: int(re.findall(r"(\d+)", x)[-1]) if re.findall(r"(\d+)", x) else 0,
+    )
+
+    for idx, fname in enumerate(processed_files, start=1):
+        fpath = os.path.join(output_folder, fname)
+        try:
+            df = pd.read_excel(fpath, sheet_name="Macro")
+            percent_col = df.iloc[:, 0] / df.iloc[:, 0].max()
+            intensity_col = df.iloc[:, 1]
+            indices = np.linspace(0, len(df) - 1, 600, dtype=int)
+            percent_squeezed = percent_col.iloc[indices].reset_index(drop=True)
+            intensity_squeezed = intensity_col.iloc[indices].reset_index(drop=True)
+
+            label = f"{base_name}_{idx}"
+            macro_percent_cols.append(percent_squeezed.rename(label))
+            macro_intensity_cols.append(intensity_squeezed.rename(label))
+        except Exception:
+            pass
+
+    if macro_percent_cols and macro_intensity_cols:
+        percent_df = pd.concat(macro_percent_cols, axis=1)
+        intensity_df = pd.concat(macro_intensity_cols, axis=1)
+        percent_df[""] = ""
+        intensity_df[""] = ""
+        percent_df["Average"] = percent_df.select_dtypes(include=[np.number]).mean(axis=1)
+        intensity_df["Average"] = intensity_df.select_dtypes(include=[np.number]).mean(axis=1)
+
+        combined_macro_path = os.path.join(output_folder, "combined_macro_600points.xlsx")
+        with pd.ExcelWriter(combined_macro_path) as writer:
+            percent_df.to_excel(writer, sheet_name="Percent Length", index=False)
+            intensity_df.to_excel(writer, sheet_name="Inverted Intensity", index=False)
+
+    generate_stripe_summary(output_folder)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Embryo stripe analysis: auto-tunes parameters to minimize discarded sheets from a single Excel file."
+    )
+    group = parser.add_mutually_exclusive_group(required=True)
+    group.add_argument(
+        "--file", "-file", help="Path to a single Excel file containing sheets s1, s2, s3..."
+    )
+    group.add_argument(
+        "--folder",
+        "-folder",
+        help="Path to a folder containing multiple Excel files, each with sheets s1, s2, s3...",
+    )
+    parser.add_argument(
+        "--lower",
+        "-l",
+        type=float,
+        required=True,
+        help="Lower limit for percent length",
+    )
+    parser.add_argument(
+        "--upper",
+        "-u",
+        type=float,
+        required=True,
+        help="Upper limit for percent length",
+    )
+
+    parser.add_argument(
+        "--test",
+        type=lambda x: str(x).lower() == "true",
+        default=True,
+        help="Whether to run parameter testing (true/false, default: true)",
+    )
+    parser.add_argument(
+        "--distance",
+        type=int,
+        default=15,
+        help="Distance for peak detection (used if --test false)",
+    )
+    parser.add_argument(
+        "--prominence",
+        type=float,
+        default=0.03,
+        help="Prominence for peak detection (used if --test false)",
+    )
+    parser.add_argument(
+        "--height",
+        type=float,
+        default=0.1,
+        help="Height for peak detection (used if --test false)",
+    )
+
+    # For test mode
+    parser.add_argument(
+        "--distances",
+        nargs="+",
+        type=int,
+        default=[10, 15, 20, 25, 30, 35],
+        help="List of distances to test (default: 10 15 20 25 30 35)",
+    )
+    parser.add_argument(
+        "--prom_range",
+        nargs=3,
+        type=float,
+        default=[0.005, 0.08, 0.05],
+        help="Prominence range: start end step (default: 0.05 0.8 0.05)",
+    )
+    parser.add_argument(
+        "--height_range",
+        nargs=3,
+        type=float,
+        default=[0.01, 0.5, 0.05],
+        help="Height range: start end step (default: 0.01 0.5 0.05)",
+    )
+
+    args = parser.parse_args()
+    lower_lim = args.lower
+    upper_lim = args.upper
+
+    pipeline_kwargs = dict(
+        lower_lim=lower_lim,
+        upper_lim=upper_lim,
+        test=args.test,
+        distance=args.distance,
+        prominence=args.prominence,
+        height=args.height,
+        distances=args.distances,
+        prom_range=args.prom_range,
+        height_range=args.height_range,
+    )
+
+    if args.file:
+        # --- Single-file mode: file contains sheets s1, s2, s3... ---
+        run_pipeline(args.file, **pipeline_kwargs)
+
+    else:
+        # --- Folder mode ---
+        input_folder = args.folder
+
+        if not os.path.isdir(input_folder):
+            print(f"\033[91mError: '{input_folder}' is not a valid directory.\033[0m")
+            sys.exit(1)
+
+        # Simply pass the folder path ONCE to the pipeline instead of looping here
+        print(f"\033[94m\nStarting analysis on folder: {abspath(input_folder)}\033[0m")
+        run_pipeline2(input_folder, **pipeline_kwargs)
+
+        print("\n Completed !!!")
+
+
+if __name__ == "__main__":
+    main()

polab_analyzer-0.1.0/src/scripts/hb.py

@@ -0,0 +1,375 @@
+#!/usr/bin/env python3
+import argparse
+import os
+import re
+import sys
+import warnings
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+from openpyxl import load_workbook
+from openpyxl.drawing.image import Image as XLImage
+from scipy.signal import savgol_filter, find_peaks
+
+warnings.simplefilter(action="ignore", category=FutureWarning)
+
+def analyze_intensity_profile(x_orig, y_orig, sample_name):
+    # Normalize length to a 0-100 scale
+    if (x_orig.max() - x_orig.min()) == 0:
+        print(f"  - Skipping {sample_name}: Length data is constant.")
+        return None
+    x_norm = 100 * (x_orig - x_orig.min()) / (x_orig.max() - x_orig.min())
+
+    # Normalize intensity to 0-1 and then invert it (1 - normalized_value)
+    if (y_orig.max() - y_orig.min()) == 0:
+        print(f"  - Skipping {sample_name}: Intensity data is constant.")
+        return None
+    y_norm = (y_orig - y_orig.min()) / (y_orig.max() - y_orig.min())
+    y_proc = 1 - y_norm
+
+    # Smooth the PROCESSED data
+    if len(y_proc) > 51:
+        window_length = 51
+    else:
+        window_length = max(5, len(y_proc) // 2 * 2 + 1)
+
+    if window_length <= 3:
+        print(f"  - Skipping {sample_name}: Not enough data points to process.")
+        return None
+
+    polyorder = 3
+    y_smooth = savgol_filter(y_proc, window_length, polyorder)
+
+    # Find peaks on the PROCESSED data
+    peaks, _ = find_peaks(y_smooth, prominence=0.05, height=0.05)
+
+    change_point_x = None
+    peak_indices = []
+
+    # Applying the peak finding logic.
+    if len(peaks) >= 2:
+        # --- Two-Peak Method ---
+        peak_prominences = y_smooth[peaks]
+        top_two_indices = np.argsort(peak_prominences)[-2:]
+        peak_indices = sorted(peaks[top_two_indices])
+        first_peak_idx, second_peak_idx = peak_indices[0], peak_indices[1]
+
+        section = slice(first_peak_idx, second_peak_idx + 1)
+        if len(y_smooth[section]) > 1:
+            intensity_gradient = np.gradient(y_smooth[section])
+            decreasing_indices = np.where(intensity_gradient < -0.002)[0]
+            if len(decreasing_indices) > 0:
+                groups = np.split(decreasing_indices, np.where(np.diff(decreasing_indices) > 1)[0] + 1)
+                longest_group = max(groups, key=len)
+                midpoint_local_idx = (longest_group[0] + longest_group[-1]) // 2
+                change_point_x = x_norm[section][midpoint_local_idx]
+    else:
+        # --- Single-Peak Method ---
+        first_peak_idx = np.argmax(y_smooth) if len(peaks) == 0 else peaks[0]
+        peak_indices = [first_peak_idx]
+
+        section = slice(first_peak_idx, len(y_smooth))
+        if len(y_smooth[section]) > 1:
+            intensity_gradient = np.gradient(y_smooth[section])
+            steepest_decrease_local_idx = np.argmin(intensity_gradient)
+            change_point_x = x_norm[section][steepest_decrease_local_idx]
+
+    return {
+        "x_norm": x_norm,
+        "y_proc": y_proc,
+        "y_smooth": y_smooth,
+        "peak_indices": peak_indices,
+        "change_point_x": change_point_x,
+    }
+
+
+def _natural_sort_key(s):
+    return [int(t) if t.isdigit() else t.lower() for t in re.split(r"(\d+)", s)]
+
+
+def generate_midpoint_summary(output_folder):
+    summary_output_path = os.path.join(output_folder, "midpoint_summary.xlsx")
+
+    all_rows = []
+    processed_files = sorted(
+        [
+            f
+            for f in os.listdir(output_folder)
+            if f.startswith("processed_") and f.endswith(".xlsx")
+        ],
+        key=_natural_sort_key,
+    )
+
+    for fname in processed_files:
+        fpath = os.path.join(output_folder, fname)
+        try:
+            wb = load_workbook(fpath, data_only=True)
+            if "Midpoint" not in wb.sheetnames:
+                continue
+
+            mp_ws = wb["Midpoint"]
+            rows = list(mp_ws.iter_rows(min_row=2, max_row=2, values_only=True))
+            if not rows:
+                continue
+
+            sample, midpoint = rows[0]
+            all_rows.append(
+                {
+                    "Sample": sample,
+                    "Midpoint (% Egg Length)": midpoint if midpoint is not None else "N/A",
+                }
+            )
+
+        except Exception as e:
+            print(f"Error reading {fname}: {e}")
+
+    summary_df = pd.DataFrame(all_rows)
+    summary_df.to_excel(summary_output_path, index=False)
+    print(f"\033[92mMidpoint summary written to: {summary_output_path} \033[0m")
+
+
+def process_dataset(x_orig, y_orig, sample_name, output_path):
+    """Run the analysis/plot/save pipeline for a single (x, y) profile and
+    write the result to output_path. Shared by both --folder mode (one xlsx
+    file = one sample) and --file mode (one sheet = one sample)."""
+    base_name = os.path.splitext(os.path.basename(output_path))[0]
+    temp_plot_path = os.path.join(
+        os.path.dirname(output_path), f"temp_plot_{base_name}.png"
+    )
+
+    result = analyze_intensity_profile(x_orig, y_orig, sample_name)
+    if result is None:
+        return None
+
+    x_norm = result["x_norm"]
+    y_proc = result["y_proc"]
+    y_smooth = result["y_smooth"]
+    peak_indices = result["peak_indices"]
+    change_point_x = result["change_point_x"]
+
+    try:
+        # Save processed data
+        out_df = pd.DataFrame(
+            {
+                "Length (orig)": x_orig,
+                "Intensity (orig)": y_orig,
+                "Percent Length": x_norm,
+                "Processed Intensity": y_proc,
+                "Smoothed Intensity": y_smooth,
+            }
+        )
+        out_df.to_excel(output_path, index=False)
+
+        # Plot the results using PROCESSED data.
+        plt.figure(figsize=(12, 7))
+        plt.plot(x_norm, y_proc, color="grey", alpha=0.6, label="Raw datapoints")
+        plt.plot(x_norm, y_smooth, color="black", linewidth=2, label="Smoothed Line")
+
+        if len(peak_indices) > 0:
+            plt.axvline(
+                x=x_norm[peak_indices[0]],
+                color="blue",
+                linestyle="--",
+                label=f"Peak 1 (at {x_norm[peak_indices[0]]:.2f})",
+            )
+        if len(peak_indices) > 1:
+            plt.axvline(
+                x=x_norm[peak_indices[1]],
+                color="green",
+                linestyle="--",
+                label=f"Peak 2 (at {x_norm[peak_indices[1]]:.2f})",
+            )
+
+        if change_point_x is not None:
+            plt.axvline(
+                x=change_point_x,
+                color="red",
+                linestyle="--",
+                linewidth=2,
+                label="Midpoint of Decrease",
+            )
+            annotation_text = f"Midpoint: {change_point_x:.2f}"
+            y_range = plt.ylim()[1] - plt.ylim()[0]
+            plt.text(
+                change_point_x + 2,
+                plt.ylim()[0] + y_range * 0.5,
+                annotation_text,
+                color="red",
+                fontsize=12,
+                bbox=dict(facecolor="white", alpha=0.8, edgecolor="red"),
+            )
+
+        plt.title(f"Intensity Profile for: {sample_name}", fontsize=16)
+        plt.xlabel("Embryo Length (%)", fontsize=12)
+        plt.ylabel("Intensity", fontsize=12)
+        plt.grid(True, which="both", linestyle="--", linewidth=0.5)
+        plt.legend()
+        plt.tight_layout()
+        plt.savefig(temp_plot_path, dpi=200)
+        plt.close()
+
+        # Embed the plot image into the processed xlsx.
+        wb = load_workbook(output_path)
+        ws = wb.active
+        img = XLImage(temp_plot_path)
+        img.width = 480
+        img.height = 280
+        ws.add_image(img, "H2")
+
+        if "Midpoint" in wb.sheetnames:
+            del wb["Midpoint"]
+        mp_ws = wb.create_sheet("Midpoint")
+        mp_ws.append(["Sample", "Midpoint (% Egg Length)"])
+        mp_ws.append([sample_name, change_point_x if change_point_x is not None else "N/A"])
+
+        wb.save(output_path)
+
+    except Exception as e:
+        print(f"  - Error processing {sample_name}: {e}")
+        return None
+    finally:
+        if os.path.exists(temp_plot_path):
+            os.remove(temp_plot_path)
+
+    return change_point_x
+
+
+def process_excel_file(excel_file, output_folder):
+    """--folder mode: one xlsx file = one sample."""
+    base_name = os.path.splitext(os.path.basename(excel_file))[0]
+    output_path = os.path.join(output_folder, f"processed_{base_name}.xlsx")
+
+    try:
+        data = pd.read_excel(excel_file)
+        x_orig = data.iloc[:, 0].values
+        y_orig = data.iloc[:, 1].values
+    except Exception as e:
+        print(f"  - Error reading {os.path.basename(excel_file)}: {e}")
+        return None
+
+    return process_dataset(x_orig, y_orig, base_name, output_path)
+
+
+def process_file_sheets(excel_file, output_folder):
+    """--file mode: one xlsx file containing sheets s1, s2, s3, ... = multiple samples."""
+    base_name = os.path.splitext(os.path.basename(excel_file))[0]
+
+    try:
+        xl = pd.ExcelFile(excel_file)
+        sheet_names = sorted(
+            [s for s in xl.sheet_names if re.match(r"^s\d+$", s, re.IGNORECASE)],
+            key=lambda s: int(re.findall(r"\d+", s)[0]),
+        )
+    except Exception as e:
+        print(f"\033[91mError reading '{excel_file}': {e}\033[0m")
+        return
+
+    if not sheet_names:
+        print(
+            f"\033[91mNo sheets matching the 's1', 's2', ... pattern were found in "
+            f"'{excel_file}'.\033[0m"
+        )
+        return
+
+    total_sheets = len(sheet_names)
+    print(
+        f"\033[96m\nFound {total_sheets} sheets in '{os.path.basename(excel_file)}'.\033[0m "
+        f"\n\033[91mStarting analysis...\033[0m"
+    )
+
+    for i, sheet_name in enumerate(sheet_names, start=1):
+        percent = (i / total_sheets) * 100
+        sys.stdout.write(
+            f"\r\033[92mProgress: [{percent:3.0f}%]\033[0m Processing sheets {i}/{total_sheets}..."
+        )
+        sys.stdout.flush()
+
+        sample_name = f"{base_name}_{sheet_name}"
+        output_path = os.path.join(output_folder, f"processed_{sample_name}.xlsx")
+
+        try:
+            data = pd.read_excel(excel_file, sheet_name=sheet_name)
+            x_orig = data.iloc[:, 0].values
+            y_orig = data.iloc[:, 1].values
+        except Exception as e:
+            print(f"\n  - Error reading sheet {sheet_name}: {e}")
+            continue
+
+        process_dataset(x_orig, y_orig, sample_name, output_path)
+
+    print()
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Hb fluorescence intensity profile batch analyzer: finds the midpoint "
+        "of the intensity decrease for every sample file in a folder."
+    )
+    group = parser.add_mutually_exclusive_group(required=True)
+    group.add_argument(
+        "--folder",
+        "-folder",
+        help="Path to a folder containing input .xlsx sample files (one sample per file)",
+    )
+    group.add_argument(
+        "--file",
+        "-file",
+        help="Path to a single .xlsx file containing sheets s1, s2, s3, ... "
+        "(one sample per sheet)",
+    )
+    args = parser.parse_args()
+
+    if args.folder:
+        input_folder = args.folder
+
+        if not os.path.isdir(input_folder):
+            print(f"\033[91mError: '{input_folder}' is not a valid directory.\033[0m")
+            sys.exit(1)
+
+        xlsx_files = sorted(
+            f
+            for f in os.listdir(input_folder)
+            if f.endswith(".xlsx") and not f.startswith("processed_") and "summary" not in f.lower()
+        )
+
+        if not xlsx_files:
+            print(f"\nNo .xlsx files found in '{input_folder}'. Exiting.")
+            sys.exit(0)
+
+        output_folder = os.path.join(input_folder, "results")
+        os.makedirs(output_folder, exist_ok=True)
+
+        print(f"\033[96m\nFound total {len(xlsx_files)} Excel files.\033[0m \n\033[91mStarting analysis...\033[0m")
+
+        total_files = len(xlsx_files)
+        for i, fname in enumerate(xlsx_files, start=1):
+            fpath = os.path.join(input_folder, fname)
+            percent = (i / total_files) * 100
+
+            sys.stdout.write(
+                f"\r\033[92mProgress: [{percent:3.0f}%]\033[0m Processing Excel Files {i}/{total_files}..."
+            )
+            sys.stdout.flush()
+
+            process_excel_file(fpath, output_folder)
+
+        print("\n Completed !!!")
+
+    else:
+        input_file = args.file
+
+        if not os.path.isfile(input_file):
+            print(f"\033[91mError: '{input_file}' is not a valid file.\033[0m")
+            sys.exit(1)
+
+        output_folder = os.path.join(os.path.dirname(os.path.abspath(input_file)), "results")
+        os.makedirs(output_folder, exist_ok=True)
+
+        process_file_sheets(input_file, output_folder)
+
+        print("\n Completed !!!")
+
+    generate_midpoint_summary(output_folder)
+
+if __name__ == "__main__":
+    main()