Add DCRM Analysis API

.gitignore

@@ -0,0 +1 @@
+__pycache__

Dockerfile

@@ -0,0 +1,26 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+# Install system dependencies for OpenCV
+RUN apt-get update && apt-get install -y \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for caching
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY flask_app.py .
+COPY dcrm/ ./dcrm/
+
+# Expose port 7860 (Hugging Face default)
+EXPOSE 7860
+
+# Run the Flask app
+CMD ["python", "flask_app.py"]

dcrm/history_manager.py

@@ -0,0 +1,55 @@
+import json
+import os
+import datetime
+
+class HistoryManager:
+    def __init__(self, history_file="data/history.json"):
+        self.history_file = history_file
+        self.ensure_data_dir()
+
+    def ensure_data_dir(self):
+        directory = os.path.dirname(self.history_file)
+        if directory and not os.path.exists(directory):
+            os.makedirs(directory)
+        
+        if not os.path.exists(self.history_file):
+            with open(self.history_file, 'w') as f:
+                json.dump([], f)
+
+    def load_history(self):
+        try:
+            with open(self.history_file, 'r') as f:
+                return json.load(f)
+        except (json.JSONDecodeError, FileNotFoundError):
+            return []
+
+    def save_analysis(self, analysis_data, zone_analysis, filename="Unknown"):
+        history = self.load_history()
+        
+        overall = zone_analysis.get('overall_health', {})
+        
+        record = {
+            "timestamp": datetime.datetime.now().isoformat(),
+            "filename": filename,
+            "overall_status": overall.get('status', 'Unknown'),
+            "score": overall.get('overall_score', 0),
+            "recommendation": overall.get('recommendation', 'N/A'),
+            "issues_count": overall.get('total_issues', 0),
+            # Store minimal data to keep file size manageable
+            # We could store full analysis if needed, but for a list view this is enough
+            "analysis_summary": {
+                "static_resistance": analysis_data.get("analysis_metrics", {}).get("static_resistance_Rp_uOhm", "N/A") if analysis_data else "N/A"
+            }
+        }
+        
+        # Prepend to list (newest first)
+        history.insert(0, record)
+        
+        # Keep only last 50 records
+        if len(history) > 50:
+            history = history[:50]
+            
+        with open(self.history_file, 'w') as f:
+            json.dump(history, f, indent=2)
+            
+        return record

dcrm/image_processing.py

@@ -0,0 +1,445 @@
+import cv2
+import numpy as np
+import pandas as pd
+from functools import reduce
+from PIL import Image
+
+
+def detect_graph_boundaries(img):
+    height, width = img.shape[:2]
+    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+    _, thresh = cv2.threshold(gray, 200, 255, cv2.THRESH_BINARY_INV)
+
+    col_sums = np.sum(thresh, axis=0) / 255
+    is_line = col_sums > (height * 0.40)
+    line_indices = np.where(is_line)[0]
+
+    start_x = 0
+    if len(line_indices) > 0:
+        left_lines = [x for x in line_indices if x < width * 0.2 and x > 5]
+        if left_lines:
+            start_x = left_lines[0]
+
+    end_x = width - 1
+    if len(line_indices) > 0:
+        right_margin = width * 0.95
+        right_lines = [x for x in line_indices if x > right_margin]
+        if right_lines:
+            end_x = right_lines[-1]
+
+    # Create debug image
+    debug_img = img.copy()
+    cv2.line(debug_img, (int(start_x), 0), (int(start_x), height), (0, 255, 0), 3)
+    cv2.line(debug_img, (int(end_x), 0), (int(end_x), height), (0, 0, 255), 3)
+
+    return int(start_x), int(end_x), debug_img
+
+
+def extract_color_pixels(
+    image, color="green", mode="dominant", threshold=0, difference=10
+):
+    """
+    Process an image and extract only pixels of a specific color.
+    Display them on a black background.
+
+    Args:
+        image: PIL Image object
+        color: str, one of 'red', 'green', or 'blue'
+        mode: str, detection mode - 'dominant', 'difference', or 'strict'
+        threshold: int, minimum value for the target color channel (0-255)
+        difference: int/float, parameter meaning depends on mode
+
+    Returns:
+        tuple: (PIL Image object with only specified color pixels, color_mask array)
+    """
+    # Convert image to RGB if it's not already
+    if image.mode != "RGB":
+        image = image.convert("RGB")
+
+    # Convert to numpy array for easier manipulation
+    img_array = np.array(image)
+
+    # Create a black background with the same dimensions
+    result_array = np.zeros_like(img_array)
+
+    # Extract RGB channels
+    red = img_array[:, :, 0].astype(np.float32)
+    green = img_array[:, :, 1].astype(np.float32)
+    blue = img_array[:, :, 2].astype(np.float32)
+
+    # Create mask based on selected color and mode
+    if mode == "dominant":
+        # Simply check if the target color is the highest channel
+        if color == "red":
+            color_mask = (red >= green) & (red >= blue) & (red > threshold)
+        elif color == "green":
+            color_mask = (green >= red) & (green >= blue) & (green > threshold)
+        elif color == "blue":
+            color_mask = (blue >= red) & (blue >= green) & (blue > threshold)
+
+    elif mode == "difference":
+        # Target color must be higher than others by a certain absolute difference
+        if color == "red":
+            color_mask = (
+                (red > threshold)
+                & (red > green + difference)
+                & (red > blue + difference)
+            )
+        elif color == "green":
+            color_mask = (
+                (green > threshold)
+                & (green > red + difference)
+                & (green > blue + difference)
+            )
+        elif color == "blue":
+            color_mask = (
+                (blue > threshold)
+                & (blue > red + difference)
+                & (blue > green + difference)
+            )
+
+    elif mode == "strict":
+        # Target color must be significantly higher (percentage-based)
+        dominance_factor = 1.0 + (difference / 100.0)
+        if color == "red":
+            color_mask = (
+                (red > threshold)
+                & (red > green * dominance_factor)
+                & (red > blue * dominance_factor)
+            )
+        elif color == "green":
+            color_mask = (
+                (green > threshold)
+                & (green > red * dominance_factor)
+                & (green > blue * dominance_factor)
+            )
+        elif color == "blue":
+            color_mask = (
+                (blue > threshold)
+                & (blue > red * dominance_factor)
+                & (blue > green * dominance_factor)
+            )
+    else:
+        raise ValueError("Mode must be 'dominant', 'difference', or 'strict'")
+
+    # Apply mask to keep only target color pixels
+    result_array[color_mask] = img_array[color_mask]
+
+    # Convert back to PIL Image
+    result_image = Image.fromarray(result_array.astype("uint8"))
+
+    return result_image, color_mask
+
+
+def extract_line_mask(
+    img_cropped, line_color, saturation_factor, gap_fill_size, noise_threshold
+):
+    # Boost Saturation
+    hsv_pre = cv2.cvtColor(img_cropped, cv2.COLOR_BGR2HSV)
+    h, s, v = cv2.split(hsv_pre)
+    s = np.clip(s.astype(np.float32) * saturation_factor, 0, 255).astype(np.uint8)
+    hsv = cv2.merge((h, s, v))
+
+    # Convert OpenCV BGR (boosted) to PIL RGB
+    boosted_bgr = cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)
+    img_rgb = cv2.cvtColor(boosted_bgr, cv2.COLOR_BGR2RGB)
+    pil_image = Image.fromarray(img_rgb)
+
+    target_color = "green"
+    if line_color == "Red":
+        target_color = "red"
+    elif line_color == "Blue (Cyan)":
+        target_color = "blue"
+
+    diff_val = 20
+    if line_color == "Green":
+        diff_val = 30
+
+    _, color_mask = extract_color_pixels(
+        pil_image,
+        color=target_color,
+        mode="difference",
+        threshold=40,
+        difference=diff_val,
+    )
+
+    # Convert boolean mask to uint8
+    mask = np.zeros_like(img_cropped[:, :, 0], dtype=np.uint8)
+    mask[color_mask] = 255
+
+    debug_image = None
+
+    # Additional processing for Green (White removal)
+    if line_color == "Green":
+        original_bgr = img_cropped
+        original_hsv = cv2.cvtColor(original_bgr, cv2.COLOR_BGR2HSV)
+        _, orig_s, orig_v = cv2.split(original_hsv)
+        white_mask = (orig_v > 200) & (orig_s < 50)
+
+        mask_before_white_removal = mask.copy()
+        mask[white_mask] = 0
+
+        # Create debug visualization
+        debug_image = img_cropped.copy()
+        debug_image[mask > 0] = [0, 255, 0]
+        removed_white = white_mask & (mask_before_white_removal > 0)
+        debug_image[removed_white] = [0, 0, 255]
+
+    if mask is None:
+        return None, None
+
+    # Noise/Gap cleanup
+    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    mask_clean = np.zeros_like(mask)
+    for cnt in contours:
+        if cv2.contourArea(cnt) > (noise_threshold * 0.5):
+            cv2.drawContours(mask_clean, [cnt], -1, 255, -1)
+    mask = mask_clean
+
+    if gap_fill_size > 0:
+        k_h = np.ones((1, gap_fill_size), np.uint8)
+        close_h = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, k_h)
+        k_v = np.ones((gap_fill_size, 1), np.uint8)
+        close_v = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, k_v)
+        mask = cv2.bitwise_or(close_h, close_v)
+        mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, np.ones((2, 2), np.uint8))
+
+    return mask, debug_image
+
+
+def generate_curve_data(mask, name_upper, name_lower):
+    height, width = mask.shape
+    data = []
+
+    for x in range(width):
+        col = mask[:, x]
+        indices = np.where(col > 0)[0]
+        val_top, val_bot = None, None
+
+        if len(indices) > 0:
+            y_min, y_max = indices[0], indices[-1]
+            graph_y_top = height - y_min
+            graph_y_bot = height - y_max
+            val_top = graph_y_top
+            val_bot = graph_y_bot
+
+        data.append({"X": x, name_upper: val_top, name_lower: val_bot})
+
+    df = pd.DataFrame(data)
+    df[name_upper] = df[name_upper].interpolate(
+        method="linear", limit=3, limit_area="inside"
+    )
+    df[name_lower] = df[name_lower].interpolate(
+        method="linear", limit=3, limit_area="inside"
+    )
+    df[name_upper] = df[name_upper].bfill().ffill()
+    df[name_lower] = df[name_lower].bfill().ffill()
+
+    return df
+
+
+def process_uploaded_image(
+    file_bytes,
+    sat_factor,
+    gap_size,
+    noise_threshold,
+    crop_enabled,
+    total_duration,
+    travel_gradient_threshold=30,
+):
+    file_bytes = np.asarray(bytearray(file_bytes), dtype=np.uint8)
+    img_orig = cv2.imdecode(file_bytes, 1)
+
+    debug_img_bounds = img_orig.copy()
+    sx, ex = 0, img_orig.shape[1]
+
+    if crop_enabled:
+        sx, ex, debug_img_bounds = detect_graph_boundaries(img_orig)
+        img_working = img_orig[:, sx:ex]
+    else:
+        img_working = img_orig
+
+    if img_working.shape[1] == 0:
+        return None, None, None, "Crop failed.", {}
+
+    configs = [
+        ("Red", "Red", ("Travel", "C1")),
+        ("Green", "Green", ("Resistance", "C2")),
+        ("Blue (Cyan)", "Blue", ("Current", "C3")),
+    ]
+
+    dfs = []
+    debug_images = {}
+    debug_images["Boundaries"] = debug_img_bounds
+    height, width = img_working.shape[:2]
+
+    for color_key, _, col_names in configs:
+        mask, debug_img = extract_line_mask(
+            img_working, color_key, sat_factor, gap_size, noise_threshold
+        )
+
+        if mask is not None:
+            if debug_img is not None and color_key == "Green":
+                debug_images[color_key + " (White Removal)"] = cv2.cvtColor(
+                    debug_img, cv2.COLOR_BGR2RGB
+                )
+                colored_mask_clean = np.zeros_like(img_working)
+                colored_mask_clean[mask > 0] = [0, 255, 0]
+                overlay_clean = cv2.addWeighted(
+                    img_working, 0.7, colored_mask_clean, 0.3, 0
+                )
+                debug_images[color_key + " (Cleaned Overlay)"] = cv2.cvtColor(
+                    overlay_clean, cv2.COLOR_BGR2RGB
+                )
+
+            colored_mask = np.zeros_like(img_working)
+            colored_mask[mask > 0] = [0, 255, 0]
+            overlay = cv2.addWeighted(img_working, 0.7, colored_mask, 0.3, 0)
+            debug_images[color_key] = cv2.cvtColor(overlay, cv2.COLOR_BGR2RGB)
+
+            df_curve = generate_curve_data(mask, col_names[0], col_names[1])
+            dfs.append(df_curve)
+        else:
+            df_empty = pd.DataFrame(
+                {"X": range(width), col_names[0]: np.nan, col_names[1]: np.nan}
+            )
+            dfs.append(df_empty)
+
+    if dfs:
+        final_df = reduce(
+            lambda left, right: pd.merge(left, right, on="X", how="outer"), dfs
+        )
+
+        cols = ["X", "Travel", "C1", "Resistance", "C2", "Current", "C3"]
+        existing_cols = [c for c in cols if c in final_df.columns]
+
+        if "X" in final_df.columns:
+            # === UPDATED TIME CALCULATION ===
+            # Calculates strict linear time: Pixel 0 = 0ms, Pixel Last = total_duration
+            final_df["Time (ms)"] = (final_df["X"] / (width - 1)) * total_duration
+            existing_cols.insert(1, "Time (ms)")
+        else:
+            return None, None, None, "X-axis alignment failed.", {}
+
+        # IMPROVED BASELINE CLEANUP - Remove dotted reference lines
+        baselines = {}
+
+        for col in ["Travel", "Current"]:
+            if col in final_df.columns:
+                # Calculate baseline from first 60 entries
+                first_60 = final_df[col].head(60)
+
+                if first_60.notna().any():
+                    initial_baseline = first_60.mean(skipna=True)
+
+                    if col == "Travel":
+                        # Identify outliers: points < 98% of initial baseline
+                        outlier_threshold = initial_baseline * 0.98
+                        valid_points = first_60[first_60 >= outlier_threshold]
+
+                        if valid_points.notna().any():
+                            baseline_val = valid_points.mean(skipna=True)
+                        else:
+                            baseline_val = initial_baseline
+                    else:
+                        baseline_val = initial_baseline
+                else:
+                    valid_idx = final_df[col].first_valid_index()
+                    if valid_idx is not None:
+                        baseline_val = final_df.loc[valid_idx, col]
+                    else:
+                        continue
+
+                baselines[col] = baseline_val
+
+                # Find minimum value (dotted reference line level)
+                min_val = final_df[col].min(skipna=True)
+                # Set values near minimum to NaN
+                threshold = min_val + (baseline_val - min_val) * 0.15
+                final_df.loc[final_df[col] < threshold, col] = np.nan
+
+                # Abrupt Change (Gradient) Filter
+                if col == "Travel":
+                    gradient_threshold = travel_gradient_threshold
+                    diff = final_df[col].diff().abs()
+                    mask_abrupt = diff > gradient_threshold
+                    final_df.loc[mask_abrupt, col] = np.nan
+
+                # Time-Based Baseline Tolerances
+                # 1. Start (0-30ms)
+                mask_start = final_df["Time (ms)"] < 30
+                threshold_start = baseline_val * 0.98
+                mask_remove_start = mask_start & (final_df[col] < threshold_start)
+                final_df.loc[mask_remove_start, col] = np.nan
+
+                # 2. End (Last 50ms)
+                max_time = final_df["Time (ms)"].max()
+                mask_end = final_df["Time (ms)"] > (max_time - 50)
+                threshold_end = baseline_val * 0.98
+                mask_remove_end = mask_end & (final_df[col] < threshold_end)
+                final_df.loc[mask_remove_end, col] = np.nan
+
+                # 3. Center (100-300ms)
+                mask_center = (final_df["Time (ms)"] >= 100) & (
+                    final_df["Time (ms)"] <= 300
+                )
+                threshold_center = baseline_val * 1.05
+                mask_remove_center = mask_center & (final_df[col] < threshold_center)
+                final_df.loc[mask_remove_center, col] = np.nan
+
+                # 4. Main (30-350ms) excluding Center
+                mask_main_pre = (final_df["Time (ms)"] >= 30) & (
+                    final_df["Time (ms)"] < 100
+                )
+                mask_main_post = (final_df["Time (ms)"] > 300) & (
+                    final_df["Time (ms)"] <= 350
+                )
+
+                mask_remove_main_pre = mask_main_pre & (final_df[col] < baseline_val)
+                mask_remove_main_post = mask_main_post & (final_df[col] < baseline_val)
+
+                final_df.loc[mask_remove_main_pre, col] = np.nan
+                final_df.loc[mask_remove_main_post, col] = np.nan
+
+                # Fill gaps
+                final_df[col] = (
+                    final_df[col]
+                    .interpolate(method="linear", limit=3, limit_area="inside")
+                    .bfill()
+                    .ffill()
+                )
+
+        # CROSS-CHANNEL BASELINE CONSTRAINTS
+        if "Travel" in baselines:
+            travel_base = baselines["Travel"]
+            if "Current" in final_df.columns:
+                mask = final_df["Current"] < travel_base
+                final_df.loc[mask, "Current"] = np.nan
+                final_df["Current"] = (
+                    final_df["Current"]
+                    .interpolate(method="linear", limit=3, limit_area="inside")
+                    .bfill()
+                    .ffill()
+                )
+
+        # AUXILIARY CURVE LOGIC
+        pairs = [("C1", "Travel"), ("C2", "Resistance"), ("C3", "Current")]
+        for lower, upper in pairs:
+            if lower in final_df.columns and upper in final_df.columns:
+                if not final_df[upper].isnull().all():
+                    invalid_mask = final_df[lower] > final_df[upper]
+                    final_df.loc[invalid_mask, lower] = np.nan
+
+        # Final global cleanup (excluding Resistance)
+        for col in ["Travel", "Current", "C1", "C3"]:
+            if col in final_df.columns:
+                final_df[col] = (
+                    final_df[col]
+                    .interpolate(method="linear", limit=3, limit_area="inside")
+                    .bfill()
+                    .ffill()
+                )
+
+        return final_df[existing_cols], debug_images, (sx, ex), None, baselines
+
+    return None, None, None, "No data extracted.", {}

dcrm/image_processing.py.backup

@@ -0,0 +1,445 @@
+import cv2
+import numpy as np
+import pandas as pd
+from functools import reduce
+
+def detect_graph_boundaries(img):
+    height, width = img.shape[:2]
+    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+    _, thresh = cv2.threshold(gray, 200, 255, cv2.THRESH_BINARY_INV)
+
+    col_sums = np.sum(thresh, axis=0) / 255 
+    is_line = col_sums > (height * 0.40)
+    line_indices = np.where(is_line)[0]
+
+    start_x = 0
+    if len(line_indices) > 0:
+        left_lines = [x for x in line_indices if x < width * 0.2 and x > 5]
+        if left_lines: start_x = left_lines[0]
+
+    end_x = width - 1
+    if len(line_indices) > 0:
+        right_margin = width * 0.95
+        right_lines = [x for x in line_indices if x > right_margin]
+        if right_lines: end_x = right_lines[-1]
+
+    # Create debug image
+    debug_img = img.copy()
+    cv2.line(debug_img, (int(start_x), 0), (int(start_x), height), (0, 255, 0), 3)
+    cv2.line(debug_img, (int(end_x), 0), (int(end_x), height), (0, 0, 255), 3)
+
+    return int(start_x), int(end_x), debug_img
+
+def extract_line_mask(img_cropped, line_color, saturation_factor, gap_fill_size, noise_threshold):
+    # Boost Saturation
+    hsv_pre = cv2.cvtColor(img_cropped, cv2.COLOR_BGR2HSV)
+    h, s, v = cv2.split(hsv_pre)
+    s = np.clip(s.astype(np.float32) * saturation_factor, 0, 255).astype(np.uint8)
+    hsv = cv2.merge((h, s, v))
+    
+    b, g, r = cv2.split(cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR))
+    mask = None
+    
+    if line_color == "Green":
+        lower = np.array([35, 20, 100]); upper = np.array([75, 255, 255])
+        mask_hsv = cv2.inRange(hsv, lower, upper)
+        diff_gb = g.astype(np.int16) - b.astype(np.int16)
+        diff_gr = g.astype(np.int16) - r.astype(np.int16)
+        mask_channel = np.zeros_like(g, dtype=np.uint8)
+        mask_channel[(diff_gb > 20) & (diff_gr > 10)] = 255
+        mask = cv2.bitwise_and(mask_hsv, mask_channel)
+        
+    elif line_color == "Blue (Cyan)":
+        lower = np.array([80, 20, 100]); upper = np.array([100, 255, 255])
+        mask_hsv = cv2.inRange(hsv, lower, upper)
+        diff_br = b.astype(np.int16) - r.astype(np.int16)
+        mask_channel = np.zeros_like(b, dtype=np.uint8)
+        mask_channel[diff_br > 20] = 255
+        mask = cv2.bitwise_and(mask_hsv, mask_channel)
+        
+    elif line_color == "Red":
+        lower1 = np.array([0, 20, 100]); upper1 = np.array([10, 255, 255])
+        lower2 = np.array([170, 20, 100]); upper2 = np.array([180, 255, 255])
+        mask_hsv = cv2.bitwise_or(cv2.inRange(hsv, lower1, upper1), cv2.inRange(hsv, lower2, upper2))
+        diff_rg = r.astype(np.int16) - g.astype(np.int16)
+        diff_rb = r.astype(np.int16) - b.astype(np.int16)
+        mask_channel = np.zeros_like(r, dtype=np.uint8)
+        mask_channel[(diff_rg > 20) & (diff_rb > 20)] = 255
+        mask = cv2.bitwise_and(mask_hsv, mask_channel)
+
+    if mask is None: return None
+
+    # Noise/Gap cleanup
+    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    mask_clean = np.zeros_like(mask)
+    for cnt in contours:
+        # Reduced noise threshold slightly to keep thin spikes
+        if cv2.contourArea(cnt) > (noise_threshold * 0.5): 
+            cv2.drawContours(mask_clean, [cnt], -1, 255, -1)
+    mask = mask_clean
+
+    if gap_fill_size > 0:
+        k_h = np.ones((1, gap_fill_size), np.uint8)
+        close_h = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, k_h)
+        k_v = np.ones((gap_fill_size, 1), np.uint8)
+        close_v = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, k_v)
+        mask = cv2.bitwise_or(close_h, close_v)
+        # Replaced the 3x3 CLOSE with a smaller one to prevent merging nearby spikes too aggressively
+        mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, np.ones((2,2), np.uint8))
+    
+    # --- FIX 1: REMOVED MORPH_OPEN ---
+    # The previous code had: mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, np.ones((2,2), np.uint8))
+    # This erodes the image. If a spike is very sharp (1-2px tip), this line deletes the tip.
+    # We remove it to preserve high-frequency details.
+    
+    return mask
+
+def generate_curve_data(mask, name_upper, name_lower):
+    height, width = mask.shape
+    data = []
+    prev_top, prev_bot = None, None
+    proximity_thresh = 10 
+    
+    for x in range(width):
+        col = mask[:, x]
+        indices = np.where(col > 0)[0]
+        val_top, val_bot = None, None
+        
+        if len(indices) > 0:
+            y_min, y_max = indices[0], indices[-1]  
+            graph_y_top = height - y_min
+            graph_y_bot = height - y_max
+            
+            # If the line is thin, it's a single curve
+            if abs(y_max - y_min) <= proximity_thresh:
+                current_val = height - int((y_min + y_max) / 2)
+                # Simple tracking to decide if it belongs to top or bottom curve if they were split previously
+                if prev_top is None and prev_bot is None: val_top = current_val 
+                elif prev_top is not None and prev_bot is None: val_top = current_val
+                elif prev_top is None and prev_bot is not None: val_bot = current_val
+                else:
+                    if abs(current_val - prev_top) <= abs(current_val - prev_bot): val_top = current_val
+                    else: val_bot = current_val
+            else:
+                # Vertical line (spike) or filled area
+                val_top = graph_y_top
+                val_bot = graph_y_bot
+                
+        if val_top is not None: prev_top = val_top
+        if val_bot is not None: prev_bot = val_bot
+        data.append({"X": x, name_upper: val_top, name_lower: val_bot})
+        
+    df = pd.DataFrame(data)
+    # Using 'pchip' or 'linear' interpolation. 
+    # 'linear' is safer for sharp spikes. 'pchip' can overshoot.
+    df[name_upper] = df[name_upper].interpolate(method='linear', limit_direction='both')
+    df[name_lower] = df[name_lower].interpolate(method='linear', limit_direction='both')
+    return df
+
+def process_uploaded_image(file_bytes, sat_factor, gap_size, noise_threshold, crop_enabled, total_duration):
+    # 1. Decode Image
+    file_bytes = np.asarray(bytearray(file_bytes), dtype=np.uint8)
+    img_orig = cv2.imdecode(file_bytes, 1)
+    
+    # 2. Crop
+    debug_img_bounds = img_orig.copy()
+    sx, ex = 0, img_orig.shape[1]
+    
+    if crop_enabled:
+        sx, ex, debug_img_bounds = detect_graph_boundaries(img_orig)
+        img_working = img_orig[:, sx:ex]
+    else:
+        img_working = img_orig
+
+    if img_working.shape[1] == 0:
+        return None, None, None, "Crop failed."
+
+    # 3. Process Colors
+    configs = [
+        ("Red", "Red", ("Travel", "C1")),
+        ("Green", "Green", ("Resistance", "C2")),
+        ("Blue (Cyan)", "Blue", ("Current", "C3"))
+    ]
+    
+    dfs = []
+    debug_images = {}
+    debug_images["Boundaries"] = debug_img_bounds
+    height, width = img_working.shape[:2]
+
+    for color_key, _, col_names in configs:
+        mask = extract_line_mask(img_working, color_key, sat_factor, gap_size, noise_threshold)
+        
+        if mask is not None:
+            colored_mask = np.zeros_like(img_working)
+            colored_mask[mask > 0] = [0, 255, 0] 
+            overlay = cv2.addWeighted(img_working, 0.7, colored_mask, 0.3, 0)
+            debug_images[color_key] = cv2.cvtColor(overlay, cv2.COLOR_BGR2RGB)
+
+            df_curve = generate_curve_data(mask, col_names[0], col_names[1])
+            dfs.append(df_curve)
+        else:
+            df_empty = pd.DataFrame({"X": range(width), col_names[0]: np.nan, col_names[1]: np.nan})
+            dfs.append(df_empty)
+
+    # 4. Merge
+    if dfs:
+        final_df = reduce(lambda left, right: pd.merge(left, right, on='X', how='outer'), dfs)
+
+        # STEP A: GENERATE TIME COLUMN
+        cols = ['X', 'Travel', 'C1', 'Resistance', 'C2', 'Current', 'C3']
+        existing_cols = [c for c in cols if c in final_df.columns]
+        
+        if 'X' in final_df.columns:
+            time_per_pixel = total_duration / width
+            final_df['Time (ms)'] = final_df['X'] * time_per_pixel
+            existing_cols.insert(1, 'Time (ms)')
+        else:
+            return None, None, None, "X-axis alignment failed."
+
+        # STEP B: CALCULATE BASELINES & CLEANUP
+        for col in ['Current', 'Travel']:
+            if col in final_df.columns:
+                # Baseline - keep this simple to detect zero offset
+                baseline_val = 0
+                start_window = final_df[final_df['Time (ms)'] <= 30]
+                if not start_window.empty and start_window[col].notna().any():
+                    baseline_val = start_window[col].mean()
+                else:
+                    valid_idx = final_df[col].first_valid_index()
+                    if valid_idx is not None: baseline_val = final_df.loc[valid_idx, col]
+
+                # --- FIX 2: Relaxed Baseline Clipping ---
+                # Previous code strictly deleted anything below baseline. 
+                # Spikes often oscillate. We allow small dips now.
+    end_x = width - 1
+    if len(line_indices) > 0:
+        right_margin = width * 0.95
+        right_lines = [x for x in line_indices if x > right_margin]
+        if right_lines: end_x = right_lines[-1]
+
+    # Create debug image
+    debug_img = img.copy()
+    cv2.line(debug_img, (int(start_x), 0), (int(start_x), height), (0, 255, 0), 3)
+    cv2.line(debug_img, (int(end_x), 0), (int(end_x), height), (0, 0, 255), 3)
+
+    return int(start_x), int(end_x), debug_img
+
+def extract_line_mask(img_cropped, line_color, saturation_factor, gap_fill_size, noise_threshold):
+    # Boost Saturation
+    hsv_pre = cv2.cvtColor(img_cropped, cv2.COLOR_BGR2HSV)
+    h, s, v = cv2.split(hsv_pre)
+    s = np.clip(s.astype(np.float32) * saturation_factor, 0, 255).astype(np.uint8)
+    hsv = cv2.merge((h, s, v))
+    
+    b, g, r = cv2.split(cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR))
+    mask = None
+    
+    if line_color == "Green":
+        lower = np.array([35, 20, 100]); upper = np.array([75, 255, 255])
+        mask_hsv = cv2.inRange(hsv, lower, upper)
+        diff_gb = g.astype(np.int16) - b.astype(np.int16)
+        diff_gr = g.astype(np.int16) - r.astype(np.int16)
+        mask_channel = np.zeros_like(g, dtype=np.uint8)
+        mask_channel[(diff_gb > 20) & (diff_gr > 10)] = 255
+        mask = cv2.bitwise_and(mask_hsv, mask_channel)
+        
+    elif line_color == "Blue (Cyan)":
+        lower = np.array([80, 20, 100]); upper = np.array([100, 255, 255])
+        mask_hsv = cv2.inRange(hsv, lower, upper)
+        diff_br = b.astype(np.int16) - r.astype(np.int16)
+        mask_channel = np.zeros_like(b, dtype=np.uint8)
+        mask_channel[diff_br > 20] = 255
+        mask = cv2.bitwise_and(mask_hsv, mask_channel)
+        
+    elif line_color == "Red":
+        lower1 = np.array([0, 20, 100]); upper1 = np.array([10, 255, 255])
+        lower2 = np.array([170, 20, 100]); upper2 = np.array([180, 255, 255])
+        mask_hsv = cv2.bitwise_or(cv2.inRange(hsv, lower1, upper1), cv2.inRange(hsv, lower2, upper2))
+        diff_rg = r.astype(np.int16) - g.astype(np.int16)
+        diff_rb = r.astype(np.int16) - b.astype(np.int16)
+        mask_channel = np.zeros_like(r, dtype=np.uint8)
+        mask_channel[(diff_rg > 20) & (diff_rb > 20)] = 255
+        mask = cv2.bitwise_and(mask_hsv, mask_channel)
+
+    if mask is None: return None
+
+    # Noise/Gap cleanup
+    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    mask_clean = np.zeros_like(mask)
+    for cnt in contours:
+        # Reduced noise threshold slightly to keep thin spikes
+        if cv2.contourArea(cnt) > (noise_threshold * 0.5): 
+            cv2.drawContours(mask_clean, [cnt], -1, 255, -1)
+    mask = mask_clean
+
+    if gap_fill_size > 0:
+        k_h = np.ones((1, gap_fill_size), np.uint8)
+        close_h = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, k_h)
+        k_v = np.ones((gap_fill_size, 1), np.uint8)
+        close_v = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, k_v)
+        mask = cv2.bitwise_or(close_h, close_v)
+        # Replaced the 3x3 CLOSE with a smaller one to prevent merging nearby spikes too aggressively
+        mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, np.ones((2,2), np.uint8))
+    
+    # --- FIX 1: REMOVED MORPH_OPEN ---
+    # The previous code had: mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, np.ones((2,2), np.uint8))
+    # This erodes the image. If a spike is very sharp (1-2px tip), this line deletes the tip.
+    # We remove it to preserve high-frequency details.
+    
+    return mask
+
+def generate_curve_data(mask, name_upper, name_lower):
+    height, width = mask.shape
+    data = []
+    prev_top, prev_bot = None, None
+    proximity_thresh = 10 
+    
+    for x in range(width):
+        col = mask[:, x]
+        indices = np.where(col > 0)[0]
+        val_top, val_bot = None, None
+        
+        if len(indices) > 0:
+            y_min, y_max = indices[0], indices[-1]  
+            graph_y_top = height - y_min
+            graph_y_bot = height - y_max
+            
+            # If the line is thin, it's a single curve
+            if abs(y_max - y_min) <= proximity_thresh:
+                current_val = height - int((y_min + y_max) / 2)
+                # Simple tracking to decide if it belongs to top or bottom curve if they were split previously
+                if prev_top is None and prev_bot is None: val_top = current_val 
+                elif prev_top is not None and prev_bot is None: val_top = current_val
+                elif prev_top is None and prev_bot is not None: val_bot = current_val
+                else:
+                    if abs(current_val - prev_top) <= abs(current_val - prev_bot): val_top = current_val
+                    else: val_bot = current_val
+            else:
+                # Vertical line (spike) or filled area
+                val_top = graph_y_top
+                val_bot = graph_y_bot
+                
+        if val_top is not None: prev_top = val_top
+        if val_bot is not None: prev_bot = val_bot
+        data.append({"X": x, name_upper: val_top, name_lower: val_bot})
+        
+    df = pd.DataFrame(data)
+    # Using 'pchip' or 'linear' interpolation. 
+    # 'linear' is safer for sharp spikes. 'pchip' can overshoot.
+    df[name_upper] = df[name_upper].interpolate(method='linear', limit_direction='both')
+    df[name_lower] = df[name_lower].interpolate(method='linear', limit_direction='both')
+    return df
+
+def process_uploaded_image(file_bytes, sat_factor, gap_size, noise_threshold, crop_enabled, total_duration):
+    # 1. Decode Image
+    file_bytes = np.asarray(bytearray(file_bytes), dtype=np.uint8)
+    img_orig = cv2.imdecode(file_bytes, 1)
+    
+    # 2. Crop
+    debug_img_bounds = img_orig.copy()
+    sx, ex = 0, img_orig.shape[1]
+    
+    if crop_enabled:
+        sx, ex, debug_img_bounds = detect_graph_boundaries(img_orig)
+        img_working = img_orig[:, sx:ex]
+    else:
+        img_working = img_orig
+
+    if img_working.shape[1] == 0:
+        return None, None, None, "Crop failed."
+
+    # 3. Process Colors
+    configs = [
+        ("Red", "Red", ("Travel", "C1")),
+        ("Green", "Green", ("Resistance", "C2")),
+        ("Blue (Cyan)", "Blue", ("Current", "C3"))
+    ]
+    
+    dfs = []
+    debug_images = {}
+    debug_images["Boundaries"] = debug_img_bounds
+    height, width = img_working.shape[:2]
+
+    for color_key, _, col_names in configs:
+        mask = extract_line_mask(img_working, color_key, sat_factor, gap_size, noise_threshold)
+        
+        if mask is not None:
+            colored_mask = np.zeros_like(img_working)
+            colored_mask[mask > 0] = [0, 255, 0] 
+            overlay = cv2.addWeighted(img_working, 0.7, colored_mask, 0.3, 0)
+            debug_images[color_key] = cv2.cvtColor(overlay, cv2.COLOR_BGR2RGB)
+
+            df_curve = generate_curve_data(mask, col_names[0], col_names[1])
+            dfs.append(df_curve)
+        else:
+            df_empty = pd.DataFrame({"X": range(width), col_names[0]: np.nan, col_names[1]: np.nan})
+            dfs.append(df_empty)
+
+    # 4. Merge
+    if dfs:
+        final_df = reduce(lambda left, right: pd.merge(left, right, on='X', how='outer'), dfs)
+
+        # STEP A: GENERATE TIME COLUMN
+        cols = ['X', 'Travel', 'C1', 'Resistance', 'C2', 'Current', 'C3']
+        existing_cols = [c for c in cols if c in final_df.columns]
+        
+        if 'X' in final_df.columns:
+            time_per_pixel = total_duration / width
+            final_df['Time (ms)'] = final_df['X'] * time_per_pixel
+            existing_cols.insert(1, 'Time (ms)')
+        else:
+            return None, None, None, "X-axis alignment failed."
+
+        # STEP B: CALCULATE BASELINES & CLEANUP
+        for col in ['Current', 'Travel']:
+            if col in final_df.columns:
+                # Baseline - keep this simple to detect zero offset
+                baseline_val = 0
+                start_window = final_df[final_df['Time (ms)'] <= 30]
+                if not start_window.empty and start_window[col].notna().any():
+                    baseline_val = start_window[col].mean()
+                else:
+                    valid_idx = final_df[col].first_valid_index()
+                    if valid_idx is not None: baseline_val = final_df.loc[valid_idx, col]
+
+                # --- FIX 2: Relaxed Baseline Clipping ---
+                # Previous code strictly deleted anything below baseline. 
+                # Spikes often oscillate. We allow small dips now.
+                # Only clip if it is essentially noise below 0 (assuming values are positive)
+                # If your graph allows negative values, remove this line entirely.
+                if baseline_val > 0:
+                     final_df.loc[final_df[col] < (baseline_val * 0.8), col] = np.nan
+                
+
+                final_df[col] = final_df[col].interpolate(method='linear', limit_direction='both')
+
+                # --- FIX 3: REMOVED "Middle Section Cleanup" ---
+                # The previous code deleted data between 120ms and 250ms if it was near the baseline.
+                # This was the primary cause of spikes disappearing in that region.
+                # The code block is deleted here.
+
+        # STEP C: AUXILIARY CURVE LOGIC
+        # Purpose: Clean auxiliary curves (C1, C2, C3) that represent the bottom edge of thick lines
+        # The auxiliary curve should never be ABOVE the main curve at the same X position
+        pairs = [('C1', 'Travel'), ('C2', 'Resistance'), ('C3', 'Current')]
+        for lower, upper in pairs:
+            if lower in final_df.columns and upper in final_df.columns:
+                if not final_df[upper].isnull().all():
+                    # FIX: Compare at same X position to preserve spikes
+                    # Previous logic: final_df[lower] > min_upper (global minimum)
+                    #   - This deleted spike data because spike bottoms exceeded the global min
+                    # New logic: final_df[lower] > final_df[upper] (position-wise comparison)
+                    #   - This only deletes truly invalid crossovers at the same X
+                    #   - Preserves spikes where upper and lower legitimately differ
+                    invalid_mask = final_df[lower] > final_df[upper]
+                    final_df.loc[invalid_mask, lower] = np.nan
+
+        # Final global cleanup
+        for col in ['Current', 'Travel', 'C1', 'C2', 'C3']:
+            if col in final_df.columns:
+                final_df[col] = final_df[col].interpolate(method='linear', limit_direction='both')
+
+
+        return final_df[existing_cols], debug_images, (sx, ex), None
+    
+    return None, None, None, "No data extracted."

dcrm/image_zone_analysis.py

@@ -0,0 +1,512 @@
+"""
+Image-Based Zone Analysis Module for DCRM Curves
+
+This module analyzes zones directly from the annotated image with segmentation lines,
+providing visual analysis of each zone based on the actual image content.
+"""
+
+import cv2
+import numpy as np
+from typing import Dict, List, Tuple, Any
+import pandas as pd
+
+
+class ImageZoneAnalyzer:
+    """Analyzes zones directly from the segmented image."""
+    
+    def __init__(self, image: np.ndarray, zones_data: Dict[str, Any], 
+                 bounds: Tuple[int, int], total_duration: float):
+        """
+        Initialize the image-based zone analyzer.
+        
+        Args:
+            image: Original image (BGR format)
+            zones_data: Dictionary containing zone segmentation information
+            bounds: (start_x, end_x) boundaries of the graph
+            total_duration: Total duration in milliseconds
+        """
+        self.image = image
+        self.zones_data = zones_data
+        self.bounds = bounds
+        self.total_duration = total_duration
+        self.analysis_results = {}
+        
+        # Extract graph region
+        sx, ex = bounds
+        self.graph_width = ex - sx
+        self.graph_image = image[:, sx:ex]
+        
+    def analyze_all_zones(self) -> Dict[str, Any]:
+        """
+        Analyze all zones based on image content.
+        
+        Returns:
+            Dictionary containing analysis results for each zone
+        """
+        if 'zones' not in self.zones_data:
+            return {'error': 'No zone data available'}
+        
+        zones = self.zones_data['zones']
+        
+        # Analyze each zone
+        for zone_name, zone_info in zones.items():
+            zone_image = self._extract_zone_image(zone_info)
+            
+            if zone_image is not None and zone_image.shape[1] > 0:
+                analysis = self._analyze_zone_image(zone_name, zone_image, zone_info)
+                self.analysis_results[zone_name] = analysis
+        
+        # Generate overall health assessment
+        overall_health = self._calculate_overall_health()
+        self.analysis_results['overall_health'] = overall_health
+        
+        return self.analysis_results
+    
+    def _extract_zone_image(self, zone_info: Dict) -> np.ndarray:
+        """Extract image region for a specific zone."""
+        start_ms = zone_info.get('start_ms', 0)
+        end_ms = zone_info.get('end_ms', 0)
+        
+        # Convert time to pixel coordinates
+        start_x = int((start_ms / self.total_duration) * self.graph_width)
+        end_x = int((end_ms / self.total_duration) * self.graph_width)
+        
+        # Ensure valid bounds
+        start_x = max(0, min(start_x, self.graph_width - 1))
+        end_x = max(start_x + 1, min(end_x, self.graph_width))
+        
+        return self.graph_image[:, start_x:end_x]
+    
+    def _analyze_zone_image(self, zone_name: str, zone_image: np.ndarray,
+                           zone_info: Dict) -> Dict[str, Any]:
+        """
+        Analyze a zone based on its image content.
+        
+        Args:
+            zone_name: Name of the zone
+            zone_image: Image region for this zone
+            zone_info: Zone metadata
+            
+        Returns:
+            Dictionary with zone analysis results
+        """
+        analysis = {
+            'zone_name': zone_name,
+            'duration_ms': zone_info.get('end_ms', 0) - zone_info.get('start_ms', 0),
+            'health_status': 'Unknown',
+            'health_score': 0.0,
+            'issues': [],
+            'metrics': {}
+        }
+        
+        # Extract color channels for each curve
+        red_mask = self._extract_color_mask(zone_image, 'red')
+        green_mask = self._extract_color_mask(zone_image, 'green')
+        blue_mask = self._extract_color_mask(zone_image, 'blue')
+        
+        # Analyze based on zone type
+        if 'zone_1' in zone_name:
+            analysis.update(self._analyze_zone_1_image(zone_image, red_mask, green_mask, blue_mask))
+        elif 'zone_2' in zone_name:
+            analysis.update(self._analyze_zone_2_image(zone_image, red_mask, green_mask, blue_mask))
+        elif 'zone_3' in zone_name:
+            analysis.update(self._analyze_zone_3_image(zone_image, red_mask, green_mask, blue_mask))
+        elif 'zone_4' in zone_name:
+            analysis.update(self._analyze_zone_4_image(zone_image, red_mask, green_mask, blue_mask))
+        elif 'zone_5' in zone_name:
+            analysis.update(self._analyze_zone_5_image(zone_image, red_mask, green_mask, blue_mask))
+        
+        return analysis
+    
+    def _extract_color_mask(self, image: np.ndarray, color: str) -> np.ndarray:
+        """Extract mask for a specific color curve."""
+        hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
+        
+        if color == 'red':
+            lower1 = np.array([0, 50, 50])
+            upper1 = np.array([10, 255, 255])
+            lower2 = np.array([170, 50, 50])
+            upper2 = np.array([180, 255, 255])
+            mask = cv2.bitwise_or(cv2.inRange(hsv, lower1, upper1), 
+                                 cv2.inRange(hsv, lower2, upper2))
+        elif color == 'green':
+            lower = np.array([35, 50, 50])
+            upper = np.array([85, 255, 255])
+            mask = cv2.inRange(hsv, lower, upper)
+        elif color == 'blue':
+            lower = np.array([90, 50, 50])
+            upper = np.array([130, 255, 255])
+            mask = cv2.inRange(hsv, lower, upper)
+        else:
+            mask = np.zeros(image.shape[:2], dtype=np.uint8)
+        
+        return mask
+    
+    def _analyze_zone_1_image(self, zone_img, red_mask, green_mask, blue_mask):
+        """Analyze Zone 1 from image."""
+        metrics = {}
+        issues = []
+        
+        # Check red curve (travel) progression
+        red_profile = self._get_vertical_profile(red_mask)
+        if len(red_profile) > 0:
+            # Travel should be present and relatively stable/increasing
+            red_coverage = np.sum(red_mask > 0) / red_mask.size * 100
+            metrics['travel_coverage_pct'] = float(red_coverage)
+            
+            if red_coverage < 5:
+                issues.append('Low travel signal visibility - possible data quality issue')
+        
+        # Check blue curve (current) - should be low/baseline
+        blue_profile = self._get_vertical_profile(blue_mask)
+        if len(blue_profile) > 0:
+            blue_coverage = np.sum(blue_mask > 0) / blue_mask.size * 100
+            metrics['current_coverage_pct'] = float(blue_coverage)
+            
+            # Current should start rising towards end
+            if blue_coverage > 20:
+                issues.append('High current activity - possible early contact')
+        
+        health_score = self._calculate_image_health_score(metrics, issues)
+        
+        return {
+            'metrics': metrics,
+            'issues': issues,
+            'health_score': health_score,
+            'health_status': self._get_health_status(health_score)
+        }
+    
+    def _analyze_zone_2_image(self, zone_img, red_mask, green_mask, blue_mask):
+        """Analyze Zone 2 from image - Arcing engagement."""
+        metrics = {}
+        issues = []
+        
+        # Check green curve (resistance) for spikes
+        green_profile = self._get_vertical_profile(green_mask)
+        if len(green_profile) > 0:
+            # Detect spikes in resistance
+            spike_count = self._count_spikes_in_mask(green_mask)
+            metrics['resistance_spike_count'] = spike_count
+            
+            green_coverage = np.sum(green_mask > 0) / green_mask.size * 100
+            metrics['resistance_coverage_pct'] = float(green_coverage)
+            
+            # Check for excessive spiking
+            if spike_count > 10:
+                issues.append(f'Excessive resistance spikes ({spike_count}) - possible contact damage')
+            
+            # Check vertical spread (indicates spike height)
+            vertical_spread = self._get_vertical_spread(green_mask)
+            metrics['resistance_vertical_spread'] = float(vertical_spread)
+            
+            if vertical_spread > zone_img.shape[0] * 0.5:
+                issues.append('Very high resistance spikes - severe arcing')
+        
+        # Check blue curve (current) activity
+        blue_coverage = np.sum(blue_mask > 0) / blue_mask.size * 100
+        metrics['current_coverage_pct'] = float(blue_coverage)
+        
+        health_score = self._calculate_image_health_score(metrics, issues)
+        
+        return {
+            'metrics': metrics,
+            'issues': issues,
+            'health_score': health_score,
+            'health_status': self._get_health_status(health_score)
+        }
+    
+    def _analyze_zone_3_image(self, zone_img, red_mask, green_mask, blue_mask):
+        """Analyze Zone 3 from image - Main conduction (most critical)."""
+        metrics = {}
+        issues = []
+        
+        # Green curve (resistance) should be low and stable
+        if np.sum(green_mask) > 0:
+            # Check vertical spread (should be minimal - flat line)
+            vertical_spread = self._get_vertical_spread(green_mask)
+            metrics['resistance_vertical_spread'] = float(vertical_spread)
+            
+            # Calculate stability (lower spread = more stable)
+            height = zone_img.shape[0]
+            stability_score = max(0, 100 - (vertical_spread / height * 100))
+            metrics['resistance_stability_score'] = float(stability_score)
+            
+            if vertical_spread > height * 0.15:
+                issues.append(f'Unstable resistance (spread: {vertical_spread:.0f}px) - poor contact quality')
+            
+            # Check for oscillations
+            oscillation_count = self._count_oscillations(green_mask)
+            metrics['resistance_oscillation_count'] = oscillation_count
+            
+            if oscillation_count > 5:
+                issues.append(f'Excessive oscillations ({oscillation_count}) - contact bouncing')
+            
+            # Check coverage (should be continuous)
+            green_coverage = np.sum(green_mask > 0) / green_mask.size * 100
+            metrics['resistance_coverage_pct'] = float(green_coverage)
+            
+            if green_coverage < 10:
+                issues.append('Low resistance signal - possible data extraction issue')
+        
+        # Red curve (travel) should be stable at plateau
+        if np.sum(red_mask) > 0:
+            travel_spread = self._get_vertical_spread(red_mask)
+            metrics['travel_vertical_spread'] = float(travel_spread)
+            
+            if travel_spread > height * 0.1:
+                issues.append('Travel not stable - mechanical issue during conduction')
+        
+        health_score = self._calculate_image_health_score(metrics, issues)
+        
+        return {
+            'metrics': metrics,
+            'issues': issues,
+            'health_score': health_score,
+            'health_status': self._get_health_status(health_score)
+        }
+    
+    def _analyze_zone_4_image(self, zone_img, red_mask, green_mask, blue_mask):
+        """Analyze Zone 4 from image - Parting."""
+        metrics = {}
+        issues = []
+        
+        # Green curve (resistance) should be increasing
+        if np.sum(green_mask) > 0:
+            # Check for upward trend
+            green_profile = self._get_vertical_profile(green_mask)
+            if len(green_profile) > 2:
+                # Compare left vs right side vertical positions
+                left_avg = np.mean(green_profile[:len(green_profile)//3])
+                right_avg = np.mean(green_profile[-len(green_profile)//3:])
+                
+                # Lower pixel value = higher on graph
+                if left_avg < right_avg:
+                    metrics['resistance_trend'] = 'decreasing'
+                    issues.append('Resistance decreasing during parting - abnormal behavior')
+                else:
+                    metrics['resistance_trend'] = 'increasing'
+            
+            # Check for parting spikes
+            spike_count = self._count_spikes_in_mask(green_mask)
+            metrics['parting_spike_count'] = spike_count
+            
+            vertical_spread = self._get_vertical_spread(green_mask)
+            metrics['resistance_vertical_spread'] = float(vertical_spread)
+            
+            if spike_count > 15:
+                issues.append(f'Excessive parting spikes ({spike_count}) - severe arcing')
+        
+        # Red curve (travel) should be decreasing (opening)
+        if np.sum(red_mask) > 0:
+            red_profile = self._get_vertical_profile(red_mask)
+            if len(red_profile) > 2:
+                left_avg = np.mean(red_profile[:len(red_profile)//3])
+                right_avg = np.mean(red_profile[-len(red_profile)//3:])
+                
+                # Higher pixel value = lower on graph (opening)
+                if left_avg > right_avg:
+                    issues.append('Travel not decreasing - mechanical opening issue')
+        
+        health_score = self._calculate_image_health_score(metrics, issues)
+        
+        return {
+            'metrics': metrics,
+            'issues': issues,
+            'health_score': health_score,
+            'health_status': self._get_health_status(health_score)
+        }
+    
+    def _analyze_zone_5_image(self, zone_img, red_mask, green_mask, blue_mask):
+        """Analyze Zone 5 from image - Final open state."""
+        metrics = {}
+        issues = []
+        
+        # Green curve (resistance) should be high and stable
+        if np.sum(green_mask) > 0:
+            vertical_spread = self._get_vertical_spread(green_mask)
+            metrics['resistance_vertical_spread'] = float(vertical_spread)
+            
+            if vertical_spread > zone_img.shape[0] * 0.1:
+                issues.append('Unstable final resistance - incomplete opening')
+            
+            green_coverage = np.sum(green_mask > 0) / green_mask.size * 100
+            metrics['resistance_coverage_pct'] = float(green_coverage)
+        
+        # Blue curve (current) should be minimal
+        if np.sum(blue_mask) > 0:
+            blue_coverage = np.sum(blue_mask > 0) / blue_mask.size * 100
+            metrics['current_coverage_pct'] = float(blue_coverage)
+            
+            if blue_coverage > 10:
+                issues.append('Elevated current in open state - possible leakage')
+        
+        health_score = self._calculate_image_health_score(metrics, issues)
+        
+        return {
+            'metrics': metrics,
+            'issues': issues,
+            'health_score': health_score,
+            'health_status': self._get_health_status(health_score)
+        }
+    
+    def _get_vertical_profile(self, mask: np.ndarray) -> np.ndarray:
+        """Get vertical position profile across horizontal axis."""
+        profile = []
+        for x in range(mask.shape[1]):
+            col = mask[:, x]
+            if np.sum(col) > 0:
+                # Get center of mass in this column
+                indices = np.where(col > 0)[0]
+                center = np.mean(indices)
+                profile.append(center)
+        return np.array(profile)
+    
+    def _get_vertical_spread(self, mask: np.ndarray) -> float:
+        """Calculate vertical spread of a mask (height of signal)."""
+        if np.sum(mask) == 0:
+            return 0.0
+        
+        # Find min and max y coordinates where mask is active
+        y_coords = np.where(mask > 0)[0]
+        if len(y_coords) == 0:
+            return 0.0
+        
+        return float(np.max(y_coords) - np.min(y_coords))
+    
+    def _count_spikes_in_mask(self, mask: np.ndarray) -> int:
+        """Count number of spikes in a mask."""
+        profile = self._get_vertical_profile(mask)
+        if len(profile) < 3:
+            return 0
+        
+        # Detect peaks
+        spike_count = 0
+        for i in range(1, len(profile) - 1):
+            # Peak if lower than neighbors (remember: lower y = higher on graph)
+            if profile[i] < profile[i-1] and profile[i] < profile[i+1]:
+                # Check if significant
+                if abs(profile[i] - profile[i-1]) > 5 or abs(profile[i] - profile[i+1]) > 5:
+                    spike_count += 1
+        
+        return spike_count
+    
+    def _count_oscillations(self, mask: np.ndarray) -> int:
+        """Count oscillations in the signal."""
+        profile = self._get_vertical_profile(mask)
+        if len(profile) < 5:
+            return 0
+        
+        # Simple moving average smoothing (no scipy needed)
+        window_size = min(5, len(profile) // 3)
+        if window_size < 2:
+            smoothed = profile
+        else:
+            smoothed = np.convolve(profile, np.ones(window_size)/window_size, mode='same')
+        
+        # Count direction changes
+        oscillations = 0
+        direction = 0  # 0: none, 1: up, -1: down
+        
+        for i in range(1, len(smoothed)):
+            diff = smoothed[i] - smoothed[i-1]
+            if abs(diff) > 2:  # Threshold for significant change
+                new_direction = 1 if diff > 0 else -1
+                if direction != 0 and new_direction != direction:
+                    oscillations += 1
+                direction = new_direction
+        
+        return oscillations
+    
+    def _calculate_image_health_score(self, metrics: Dict, issues: List[str]) -> float:
+        """Calculate health score based on image analysis."""
+        score = 100.0
+        
+        # Deduct for issues
+        score -= len(issues) * 15
+        
+        # Additional deductions based on metrics
+        if 'resistance_vertical_spread' in metrics:
+            spread = metrics['resistance_vertical_spread']
+            if spread > 100:
+                score -= 20
+            elif spread > 50:
+                score -= 10
+        
+        if 'resistance_spike_count' in metrics:
+            spikes = metrics['resistance_spike_count']
+            if spikes > 15:
+                score -= 25
+            elif spikes > 10:
+                score -= 15
+        
+        return max(0.0, min(100.0, score))
+    
+    def _get_health_status(self, score: float) -> str:
+        """Convert health score to status label."""
+        if score >= 85:
+            return 'Excellent'
+        elif score >= 70:
+            return 'Good'
+        elif score >= 50:
+            return 'Fair'
+        elif score >= 30:
+            return 'Poor'
+        else:
+            return 'Critical'
+    
+    def _calculate_overall_health(self) -> Dict[str, Any]:
+        """Calculate overall health assessment."""
+        if not self.analysis_results:
+            return {'status': 'No data', 'score': 0.0}
+        
+        zone_scores = []
+        all_issues = []
+        
+        for zone_name, analysis in self.analysis_results.items():
+            if isinstance(analysis, dict) and 'health_score' in analysis:
+                zone_scores.append(analysis['health_score'])
+                all_issues.extend(analysis.get('issues', []))
+        
+        if not zone_scores:
+            return {'status': 'Unknown', 'score': 0.0}
+        
+        # Weighted average
+        weights = {
+            'zone_1_pre_contact': 0.15,
+            'zone_2_arcing_engagement': 0.20,
+            'zone_3_main_conduction': 0.35,
+            'zone_4_parting': 0.20,
+            'zone_5_final_open': 0.10
+        }
+        
+        weighted_score = 0.0
+        total_weight = 0.0
+        
+        for zone_name, analysis in self.analysis_results.items():
+            if isinstance(analysis, dict) and 'health_score' in analysis:
+                weight = weights.get(zone_name, 0.2)
+                weighted_score += analysis['health_score'] * weight
+                total_weight += weight
+        
+        overall_score = weighted_score / total_weight if total_weight > 0 else 0.0
+        
+        return {
+            'overall_score': round(overall_score, 2),
+            'status': self._get_health_status(overall_score),
+            'total_issues': len(all_issues),
+            'critical_issues': [issue for issue in all_issues if 'severe' in issue.lower() or 'critical' in issue.lower()],
+            'recommendation': self._generate_recommendation(overall_score, all_issues)
+        }
+    
+    def _generate_recommendation(self, score: float, issues: List[str]) -> str:
+        """Generate maintenance recommendation."""
+        if score >= 85:
+            return 'Circuit breaker is in excellent condition. Continue regular monitoring.'
+        elif score >= 70:
+            return 'Circuit breaker is in good condition. Schedule routine maintenance as planned.'
+        elif score >= 50:
+            return 'Circuit breaker shows signs of wear. Increase monitoring frequency and plan maintenance.'
+        elif score >= 30:
+            return 'Circuit breaker condition is poor. Schedule maintenance soon to prevent failure.'
+        else:
+            return 'CRITICAL: Circuit breaker requires immediate attention. Risk of failure is high.'

dcrm/llm.py

@@ -0,0 +1,341 @@
+# llm.py
+import google.generativeai as genai
+import json
+import PIL.Image
+import io
+
+def get_dcrm_prompt(data_str):
+    return f"""
+    I have extracted data from a DCRM (Dynamic Contact Resistance Measurement) graph.
+    Data (Sampled): {data_str}
+    
+    The columns are:
+    - 'time': Time in milliseconds.
+    - 'curr': Current signal amplitude (Blue curve) - represents the test current flowing through the contacts.
+    - 'res': Dynamic Resistance amplitude (Green curve) - represents the contact resistance in micro-ohms (µΩ).
+    - 'travel': Travel signal amplitude (Red curve) - represents the mechanical position/displacement of the moving contact.
+
+    IMPORTANT: Higher values mean the signal is HIGHER on the graph.
+    
+    I have also provided the image of the graph. Use the visual information from the image to cross-reference with the data.
+
+    === HEALTHY DCRM SIGNATURE REFERENCE ===
+    
+    **Resistance (Green) - Healthy Characteristics:**
+    - Pre-contact: Infinite/Very High (off-scale or flat at top)
+    - Arcing engagement: Drops sharply with moderate spikes (arcing activity), typically 100-500 µΩ
+    - Main conduction: LOW and STABLE (30-80 µΩ for healthy contacts), minimal oscillation (<10 µΩ variance)
+    - Parting: Sharp rise with spikes (arcing during separation)
+    - Final open: Returns to infinite/very high (off-scale)
+    
+    **Current (Blue) - Healthy Characteristics:**
+    - Pre-contact: Near zero baseline
+    - Arcing engagement: Begins rising as circuit closes
+    - Main conduction: Stable at test current level (plateau)
+    - Parting: Maintained until final separation
+    - Final open: Drops to zero
+    
+    **Travel (Red) - Healthy Characteristics:**
+    - Pre-contact: Increasing linearly (contacts approaching)
+    - Arcing engagement: Continues increasing
+    - Main conduction: Reaches MAXIMUM and plateaus (fully closed position)
+    - Parting: Decreases linearly (contacts separating)
+    - Final open: Stabilizes at minimum (fully open position)
+
+    === TASK: SEGMENT INTO 5 KINEMATIC ZONES ===
+    
+    Use ALL THREE curves together for accurate boundary detection. Each zone represents a distinct physical state of the circuit breaker.
+    
+    **Zone 1: Pre-Contact Travel (Initial Closing Motion)**
+    *   **Physical Meaning**: The moving contact is traveling toward the stationary contact but has NOT yet made electrical contact. This is pure mechanical motion with no current flow.
+    *   **Start**: time = 0 ms
+    *   **End Boundary**: Detect when CURRENT (blue) FIRST starts rising significantly from baseline.
+        *   Cross-reference: Resistance (green) should still be very high/infinite
+        *   Cross-reference: Travel (red) should be steadily increasing
+        *   **Typical Duration**: 80-120 ms
+        *   **Detection Logic**: Find the point where 'curr' rises above baseline noise (e.g., >5% of max current)
+    
+    **Zone 2: Arcing Contact Engagement (Initial Electrical Contact)**
+    *   **Physical Meaning**: The arcing contacts (W-Cu tips) make first contact and establish an electrical path. Current begins flowing through a small contact area, causing arcing and resistance fluctuations. This is the "make" transition.
+    *   **Start**: End of Zone 1
+    *   **End Boundary**: Detect when resistance SETTLES after initial spike activity.
+        *   Primary indicator: Resistance (green) drops from high values, exhibits spikes, then STABILIZES to low plateau
+        *   Cross-reference: Current (blue) should be rising/stabilizing
+        *   Cross-reference: Travel (red) continues increasing toward maximum
+        *   **Typical Duration**: 20-40 ms (Zone 2 typically ends around 110-150 ms total time)
+        *   **Detection Logic**: Find where 'res' completes its descent and spike activity, settling into a stable low range
+    
+    **Zone 3: Main Contact Conduction (Fully Closed State)**
+    *   **Physical Meaning**: The main contacts (Ag-plated) are fully engaged, providing a large, stable contact area. This is the "healthy contact" signature zone - resistance should be at its MINIMUM and STABLE. The breaker is in its fully closed, current-carrying state.
+    *   **Start**: End of Zone 2
+    *   **End Boundary**: Detect when the breaker begins OPENING (travel reverses direction).
+        *   Primary indicator: Travel (red) reaches MAXIMUM and starts to DESCEND
+        *   Cross-reference: Resistance (green) should remain low and stable throughout this zone
+        *   Cross-reference: Current (blue) should be stable at test level
+        *   **Typical Duration**: 100-200 ms (this is the longest zone, representing the dwell time)
+        *   **Detection Logic**: Find the peak of 'travel' curve and the point where it starts decreasing
+    
+    **Zone 4: Main Contact Parting (Breaking/Opening Transition)**
+    *   **Physical Meaning**: The main contacts are separating. As the contact area decreases, resistance rises sharply. Arcing occurs during the final separation of the arcing contacts. This is the "break" transition - the most critical phase for fault detection.
+    *   **Start**: End of Zone 3
+    *   **End Boundary**: Detect when resistance STABILIZES at high value after parting spikes.
+        *   Primary indicator: Resistance (green) shoots UP, exhibits parting spikes, then STABILIZES at high/infinite value
+        *   Cross-reference: Travel (red) should be decreasing (opening motion)
+        *   Cross-reference: Current (blue) may drop or fluctuate during final arc extinction
+        *   **Typical Duration**: 40-80 ms (Zone 4 typically ends around 280-340 ms total time)
+        *   **Detection Logic**: Find where 'res' completes its rise and spike activity, becoming constant at high value
+        *   **CRITICAL**: Do NOT extend this zone too long - end AS SOON AS resistance stabilizes
+    
+    **Zone 5: Final Open State (Fully Open)**
+    *   **Physical Meaning**: The contacts are fully separated with an air gap. No current flows, resistance is infinite. The breaker is in its fully open, non-conducting state.
+    *   **Start**: End of Zone 4
+    *   **End**: The last time point in the dataset
+    *   **Characteristics**: 
+        *   Resistance (green): Very high/infinite (flat line at top)
+        *   Current (blue): Zero or near-zero
+        *   Travel (red): Stable at minimum (fully open position)
+
+    **MULTI-CURVE ANALYSIS STRATEGY:**
+    1. Use Current (blue) to identify Zone 1 → Zone 2 transition (first current rise)
+    2. Use Resistance (green) to identify Zone 2 → Zone 3 transition (resistance settles to low plateau)
+    3. Use Travel (red) to identify Zone 3 → Zone 4 transition (travel peak and reversal)
+    4. Use Resistance (green) to identify Zone 4 → Zone 5 transition (resistance stabilizes at high value)
+    5. Always cross-validate boundaries using all three curves for consistency
+
+    **OUTPUT FORMAT (Strict JSON)**
+    Return ONLY this JSON object:
+    {{
+      "zones": {{
+        "zone_1_pre_contact": {{ "start_ms": float, "end_ms": float, "justification": "string (explain which curve indicators were used)" }},
+        "zone_2_arcing_engagement": {{ "start_ms": float, "end_ms": float, "justification": "string (explain which curve indicators were used)" }},
+        "zone_3_main_conduction": {{ "start_ms": float, "end_ms": float, "justification": "string (explain which curve indicators were used)" }},
+        "zone_4_parting": {{ "start_ms": float, "end_ms": float, "justification": "string (explain which curve indicators were used)" }},
+        "zone_5_final_open": {{ "start_ms": float, "end_ms": float, "justification": "string (explain which curve indicators were used)" }}
+      }},
+      "report_card": {{
+        "opening_speed": {{ "status": "Pass"|"Warning"|"Fail", "comment": "Assessment of travel curve steepness" }},
+        "contact_wear": {{ "status": "Pass"|"Warning"|"Fail", "comment": "Based on resistance fluctuations in Zone 2/4" }},
+        "timing_consistency": {{ "status": "Pass"|"Warning"|"Fail", "comment": "Are phases within expected ranges?" }},
+        "overall_health": {{ "status": "Healthy"|"Needs Review"|"Critical", "comment": "Overall summary" }}
+      }},
+      "detailed_analysis": "Provide a comprehensive technical analysis (in Markdown)..."
+    }}
+    """
+
+def ask_llm_for_breakage(df, api_key, model_name, image_bytes=None):
+    """
+    Sends the DataFrame and optional image to LLM (Gemini) for segmentation.
+    Returns (df, result_json) where df has a new 'Zone' column.
+    """
+    if not api_key: return df, None
+
+    try:
+        genai.configure(api_key=api_key)
+        
+        # Configure safety settings
+        safety_settings = [
+            {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "BLOCK_NONE"},
+            {"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "BLOCK_NONE"},
+            {"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT", "threshold": "BLOCK_NONE"},
+            {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_NONE"},
+        ]
+        
+        model = genai.GenerativeModel(
+            model_name=model_name,
+            safety_settings=safety_settings
+        )
+    except Exception as e:
+        return df, {"error": f"Failed to initialize Gemini API: {str(e)}"} 
+
+    # Prepare Data
+    # Rename columns for LLM clarity
+    df_llm = df[['Time (ms)', 'Current', 'Resistance', 'Travel']].copy()
+    df_llm.columns = ['time', 'curr', 'res', 'travel']
+    
+    # Round values
+    df_llm = df_llm.round(1)
+    
+    # Sample to keep prompt size manageable (e.g., every 5th row)
+    # User's code used df.to_string(index=False), implying they might not have sampled, 
+    # but for safety with large CSVs, we'll keep sampling but use to_string format.
+    df_sampled = df_llm.iloc[::5, :]
+    
+    data_str = df_sampled.to_string(index=False)
+    
+    prompt = get_dcrm_prompt(data_str)
+
+    content = [prompt]
+    if image_bytes:
+        try:
+            image = PIL.Image.open(io.BytesIO(image_bytes))
+            content.append(image)
+        except Exception as e:
+            return df, {"error": f"Failed to process image: {str(e)}"}
+
+    try:
+        response = model.generate_content(content)
+        
+        if not response.text:
+            if hasattr(response, 'prompt_feedback'):
+                return df, {
+                    "error": "Response blocked by safety filters",
+                    "raw_response": str(response.prompt_feedback)
+                }
+            return df, {"error": "LLM returned empty response"}
+        
+        result = response.text.strip()
+        
+        # Remove markdown code blocks
+        if "```json" in result:
+            result = result.split("```json")[1].split("```")[0].strip()
+        elif "```" in result:
+             result = result.split("```")[1].split("```")[0].strip()
+        
+        # Parse JSON
+        try:
+            result_json = json.loads(result)
+            zones = result_json.get("zones", {})
+            
+            # Enrich DataFrame with Zones
+            df['Zone'] = "Unknown"
+            
+            for zone_name, details in zones.items():
+                start = details.get("start_ms")
+                end = details.get("end_ms")
+                if start is not None and end is not None:
+                    # Map zone name to a simpler label (e.g., "Zone 1")
+                    short_name = zone_name.split('_')[1] # "1", "2", etc.
+                    mask = (df['Time (ms)'] >= start) & (df['Time (ms)'] <= end)
+                    df.loc[mask, 'Zone'] = f"Zone {short_name}"
+            
+            return df, result_json
+            
+        except json.JSONDecodeError as je:
+            return df, {
+                "error": f"JSON parsing failed: {str(je)}",
+                "raw_response": result[:1000]
+            }
+            
+    except Exception as e:
+        return df, {"error": f"LLM API error: {str(e)}"}
+
+def analyze_health_with_llm(image_bytes, api_key, model_name, numerical_context=None):
+    """
+    Sends the DCRM image to Gemini for expert diagnostic analysis.
+    Numerical context is a dict of extracted values (e.g. min resistance) to prevent hallucination.
+    """
+    if not api_key or not image_bytes: return None
+
+    try:
+        genai.configure(api_key=api_key)
+        
+        safety_settings = [
+            {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "BLOCK_NONE"},
+            {"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "BLOCK_NONE"},
+            {"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT", "threshold": "BLOCK_NONE"},
+            {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_NONE"},
+        ]
+        
+        model = genai.GenerativeModel(
+            model_name=model_name,
+            safety_settings=safety_settings
+        )
+        
+        # Build context string
+        context_str = ""
+        if numerical_context:
+            context_str = f"""
+            NUMERICAL DATA CONTEXT (From Raw Extraction):
+            - Minimum Static Resistance Found: {numerical_context.get('min_resistance', 'N/A')} µΩ
+            - Median Resistance Found: {numerical_context.get('median_resistance', 'N/A')} µΩ
+            
+            NOTE: If the extracted resistance is HIGH (e.g. >200 uOhm) but the curve looks flat and healthy, 
+            it indicates the data extraction scale is uncalibrated, but the relative health is good. 
+            Trust the SHAPE (flatness/noise) over the absolute number if they conflict, but mention the value.
+            """
+
+        prompt = f"""
+        System Role: Principal DCRM & Kinematic Analyst
+        Role:
+        You are an expert High-Voltage Circuit Breaker Diagnostician. Your task is to interpret Dynamic Contact Resistance (DCRM) traces to detect specific electrical and mechanical faults.
+        
+        {context_str}
+
+        Critical "Anti-Overfitting" Directive:
+        You must distinguish between Systematic Defects and Artifacts.
+        Sensor/Manufacturing Noise: A totally flat line is rare in real-world data. Slight "fuzz" or very minute "grassiness" (amplitude < 10 μΩ) is often sensor noise, ADC quantization, or normal manufacturing surface variance. Do not flag this as a defect.
+        True Degradation: Flag issues only when the visual signature is statistically significant and exceeds the "noise floor."
+        
+        Capability:
+        Identify Multiple Concurrent Issues if present. (e.g., A breaker can have both misalignment and contact wear).
+        there will mostly be 3 line charts in the input
+        green resistance profile
+        blue current profile 
+        red travel profile
+        
+        1. Diagnostic Heuristics & Defect Taxonomy
+        Map the visual DCRM trace to ONLY the following defect types. Use the specific Visual Heuristics to confirm detection.
+        
+        Defect Type | Visual Heuristic (The "Hint") | Mechanical Significance (Root Cause)
+        --- | --- | ---
+        Main Contact Issue (Corrosion/Oxidation) | "The Significant Grass"<br>In the fully closed plateau, look for pronounced, erratic instability. <br>• Ignore: Uniform, low-amplitude fuzz (sensor noise).<br>• Flag: Jagged, irregular peaks/valleys with significant amplitude (e.g., > 15–20 μΩ variance). The trace looks like a "rough rocky road," not just a "gravel path." | Surface Pathology: The Silver (Ag) plating is compromised (fretting corrosion) or heavy oxidation has occurred. The current path is constantly shifting through microscopic non-conductive spots.
+        Arcing Contact Wear | "Big Spikes & Short Wipe"<br>Resistance spikes are frequent and significantly large (high amplitude). Crucially, the duration of the arcing zone (the time between first touch and main contact touch) is noticeably shorter than expected. | Ablation: The Tungsten-Copper (W-Cu) tips are heavily eroded. The contact length has physically diminished, risking failure to commutate current during opening.
+        Misalignment (Main) | "The Struggle to Settle"<br>There are significant, high-amplitude peaks just before the trace tries to settle into the stable plateau. These are not bounces; they are "struggles" to mate that persist longer than 3-5ms. | Mechanical Centering: The moving contact pin is hitting the side or edge of the stationary rosette fingers before forcing its way in. Caused by loose nuts, kinematic play, or guide ring failure.
+        Misalignment (Arcing) | "Rough Entry"<br>Erratic resistance spikes occurring specifically during the initial entry (commutation), well before the main contacts engage. | Tip Eccentricity: The arcing pin is not entering the nozzle concentrically. It is scraping the nozzle throat or hitting the side, indicating a bent rod or skewed interrupter.
+        Slow Mechanism | "Stretched Time"<br>The entire resistance profile is elongated along the X-axis. Events happen later than normal. | Energy Starvation: Low spring charge, hydraulic pressure loss, or high friction due to hardened grease in the linkage.
+        
+        2. Analysis Logic (The "Signal-to-Noise" Filter)
+        Before declaring a defect, run these logic checks:
+        The "Noise Floor" Test (For Main Contacts):
+        Is the plateau variance uniform and small (< 10 μΩ)? -> Classify as Healthy (Sensor/Manufacturing artifact).
+        Is the variance erratic, jagged, and large (> 15 μΩ)? -> Classify as Corrosion/Oxidation.
+        The "Duration" Test (For Misalignment):
+        Are the pre-plateau peaks < 2ms? -> Ignore (Benign Bounce).
+        Do the peaks persist > 3-5ms before settling? -> Classify as Misalignment.
+        The "Combination" Check:
+        Does the trace show both "Rough Entry" AND "Stretched Time"? -> Report Both (Misalignment + Slow Mechanism).
+        
+        3. Output Structure
+        Provide a concise Executive Lead followed by the JSON.
+        
+        Executive Lead (3-4 Lines)
+        Status: Healthy | Warning | Critical.
+        Key Findings: Summary of valid defects found (ignoring sensor noise).
+        Action: "Return to service" or specific repair instruction.
+        
+        JSON Schema
+        ```json
+        {
+          "image_url": "string",
+          "overall_condition": "Healthy|Warning|Critical",
+          "health_score": "integer (0-100) where 100 is perfect condition",
+          "detected_issues": [
+            {
+              "issue_type": "Main Contact Issue (Corrosion/Oxidation)|Arcing Contact Wear|Misalignment (Main)|Misalignment (Arcing)|Slow Mechanism",
+              "confidence": "High|Medium|Low",
+              "visual_evidence": "string (e.g., 'Plateau instability >20 micro-ohms detected, exceeding sensor noise threshold.')",
+              "mechanical_significance": "string (Root cause from table)",
+              "severity": "Low|Medium|High"
+            }
+          ],
+          "analysis_metrics": {
+            "static_resistance_Rp_uOhm": "float",
+            "signal_noise_level": "Low (Sensor/Mfg)|High (Defect)",
+            "wipe_quality": "Normal|Short|Erratic"
+          },
+          "maintenance_recommendation": "string"
+        }
+        ```
+        """
+        
+        image = PIL.Image.open(io.BytesIO(image_bytes))
+        
+        response = model.generate_content([prompt, image])
+        
+        if not response.text:
+            return {"error": "LLM returned empty response"}
+            
+        return response.text
+        
+    except Exception as e:
+        return {"error": f"LLM Analysis Error: {str(e)}"}

dcrm/llm_copy.py

@@ -0,0 +1,323 @@
+import google.generativeai as genai
+import json
+import PIL.Image
+import io
+
+def get_dcrm_prompt(data_str):
+    return f"""
+    I have extracted data from a DCRM (Dynamic Contact Resistance Measurement) graph.
+    Data (Sampled): {data_str}
+    
+    The columns are:
+    - 'time': Time in milliseconds.
+    - 'curr': Current signal amplitude (Blue curve) - represents the test current flowing through the contacts.
+    - 'res': Dynamic Resistance amplitude (Green curve) - represents the contact resistance in micro-ohms (µΩ).
+    - 'travel': Travel signal amplitude (Red curve) - represents the mechanical position/displacement of the moving contact.
+
+    IMPORTANT: Higher values mean the signal is HIGHER on the graph.
+    
+    I have also provided the image of the graph. Use the visual information from the image to cross-reference with the data.
+
+    === HEALTHY DCRM SIGNATURE REFERENCE ===
+    
+    **Resistance (Green) - Healthy Characteristics:**
+    - Pre-contact: Infinite/Very High (off-scale or flat at top)
+    - Arcing engagement: Drops sharply with moderate spikes (arcing activity), typically 100-500 µΩ
+    - Main conduction: LOW and STABLE (30-80 µΩ for healthy contacts), minimal oscillation (<10 µΩ variance)
+    - Parting: Sharp rise with spikes (arcing during separation)
+    - Final open: Returns to infinite/very high (off-scale)
+    
+    **Current (Blue) - Healthy Characteristics:**
+    - Pre-contact: Near zero baseline
+    - Arcing engagement: Begins rising as circuit closes
+    - Main conduction: Stable at test current level (plateau)
+    - Parting: Maintained until final separation
+    - Final open: Drops to zero
+    
+    **Travel (Red) - Healthy Characteristics:**
+    - Pre-contact: Increasing linearly (contacts approaching)
+    - Arcing engagement: Continues increasing
+    - Main conduction: Reaches MAXIMUM and plateaus (fully closed position)
+    - Parting: Decreases linearly (contacts separating)
+    - Final open: Stabilizes at minimum (fully open position)
+
+    === TASK: SEGMENT INTO 5 KINEMATIC ZONES ===
+    
+    Use ALL THREE curves together for accurate boundary detection. Each zone represents a distinct physical state of the circuit breaker.
+    
+    **Zone 1: Pre-Contact Travel (Initial Closing Motion)**
+    *   **Physical Meaning**: The moving contact is traveling toward the stationary contact but has NOT yet made electrical contact. This is pure mechanical motion with no current flow.
+    *   **Start**: time = 0 ms
+    *   **End Boundary**: Detect when CURRENT (blue) FIRST starts rising significantly from baseline.
+        *   Cross-reference: Resistance (green) should still be very high/infinite
+        *   Cross-reference: Travel (red) should be steadily increasing
+        *   **Typical Duration**: 80-120 ms
+        *   **Detection Logic**: Find the point where 'curr' rises above baseline noise (e.g., >5% of max current)
+    
+    **Zone 2: Arcing Contact Engagement (Initial Electrical Contact)**
+    *   **Physical Meaning**: The arcing contacts (W-Cu tips) make first contact and establish an electrical path. Current begins flowing through a small contact area, causing arcing and resistance fluctuations. This is the "make" transition.
+    *   **Start**: End of Zone 1
+    *   **End Boundary**: Detect when resistance SETTLES after initial spike activity.
+        *   Primary indicator: Resistance (green) drops from high values, exhibits spikes, then STABILIZES to low plateau
+        *   Cross-reference: Current (blue) should be rising/stabilizing
+        *   Cross-reference: Travel (red) continues increasing toward maximum
+        *   **Typical Duration**: 20-40 ms (Zone 2 typically ends around 110-150 ms total time)
+        *   **Detection Logic**: Find where 'res' completes its descent and spike activity, settling into a stable low range
+    
+    **Zone 3: Main Contact Conduction (Fully Closed State)**
+    *   **Physical Meaning**: The main contacts (Ag-plated) are fully engaged, providing a large, stable contact area. This is the "healthy contact" signature zone - resistance should be at its MINIMUM and STABLE. The breaker is in its fully closed, current-carrying state.
+    *   **Start**: End of Zone 2
+    *   **End Boundary**: Detect when the breaker begins OPENING (travel reverses direction).
+        *   Primary indicator: Travel (red) reaches MAXIMUM and starts to DESCEND
+        *   Cross-reference: Resistance (green) should remain low and stable throughout this zone
+        *   Cross-reference: Current (blue) should be stable at test level
+        *   **Typical Duration**: 100-200 ms (this is the longest zone, representing the dwell time)
+        *   **Detection Logic**: Find the peak of 'travel' curve and the point where it starts decreasing
+    
+    **Zone 4: Main Contact Parting (Breaking/Opening Transition)**
+    *   **Physical Meaning**: The main contacts are separating. As the contact area decreases, resistance rises sharply. Arcing occurs during the final separation of the arcing contacts. This is the "break" transition - the most critical phase for fault detection.
+    *   **Start**: End of Zone 3
+    *   **End Boundary**: Detect when resistance STABILIZES at high value after parting spikes.
+        *   Primary indicator: Resistance (green) shoots UP, exhibits parting spikes, then STABILIZES at high/infinite value
+        *   Cross-reference: Travel (red) should be decreasing (opening motion)
+        *   Cross-reference: Current (blue) may drop or fluctuate during final arc extinction
+        *   **Typical Duration**: 40-80 ms (Zone 4 typically ends around 280-340 ms total time)
+        *   **Detection Logic**: Find where 'res' completes its rise and spike activity, becoming constant at high value
+        *   **CRITICAL**: Do NOT extend this zone too long - end AS SOON AS resistance stabilizes
+    
+    **Zone 5: Final Open State (Fully Open)**
+    *   **Physical Meaning**: The contacts are fully separated with an air gap. No current flows, resistance is infinite. The breaker is in its fully open, non-conducting state.
+    *   **Start**: End of Zone 4
+    *   **End**: The last time point in the dataset
+    *   **Characteristics**: 
+        *   Resistance (green): Very high/infinite (flat line at top)
+        *   Current (blue): Zero or near-zero
+        *   Travel (red): Stable at minimum (fully open position)
+
+    **MULTI-CURVE ANALYSIS STRATEGY:**
+    1. Use Current (blue) to identify Zone 1 → Zone 2 transition (first current rise)
+    2. Use Resistance (green) to identify Zone 2 → Zone 3 transition (resistance settles to low plateau)
+    3. Use Travel (red) to identify Zone 3 → Zone 4 transition (travel peak and reversal)
+    4. Use Resistance (green) to identify Zone 4 → Zone 5 transition (resistance stabilizes at high value)
+    5. Always cross-validate boundaries using all three curves for consistency
+
+    **OUTPUT FORMAT (Strict JSON)**
+    Return ONLY this JSON object:
+    {{
+      "zones": {{
+        "zone_1_pre_contact": {{ "start_ms": float, "end_ms": float, "justification": "string (explain which curve indicators were used)" }},
+        "zone_2_arcing_engagement": {{ "start_ms": float, "end_ms": float, "justification": "string (explain which curve indicators were used)" }},
+        "zone_3_main_conduction": {{ "start_ms": float, "end_ms": float, "justification": "string (explain which curve indicators were used)" }},
+        "zone_4_parting": {{ "start_ms": float, "end_ms": float, "justification": "string (explain which curve indicators were used)" }},
+        "zone_5_final_open": {{ "start_ms": float, "end_ms": float, "justification": "string (explain which curve indicators were used)" }}
+      }},
+      "report_card": {{
+        "opening_speed": {{ "status": "Pass"|"Warning"|"Fail", "comment": "Assessment of travel curve steepness" }},
+        "contact_wear": {{ "status": "Pass"|"Warning"|"Fail", "comment": "Based on resistance fluctuations in Zone 2/4" }},
+        "timing_consistency": {{ "status": "Pass"|"Warning"|"Fail", "comment": "Are phases within expected ranges?" }},
+        "overall_health": {{ "status": "Healthy"|"Needs Review"|"Critical", "comment": "Overall summary" }}
+      }},
+      "detailed_analysis": "Provide a comprehensive technical analysis (in Markdown)..."
+    }}
+    """
+
+def ask_llm_for_breakage(df, api_key, model_name, image_bytes=None):
+    """
+    Sends the DataFrame and optional image to LLM (Gemini) for segmentation.
+    Returns (df, result_json) where df has a new 'Zone' column.
+    """
+    if not api_key: return df, None
+
+    try:
+        genai.configure(api_key=api_key)
+        
+        # Configure safety settings
+        safety_settings = [
+            {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "BLOCK_NONE"},
+            {"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "BLOCK_NONE"},
+            {"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT", "threshold": "BLOCK_NONE"},
+            {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_NONE"},
+        ]
+        
+        model = genai.GenerativeModel(
+            model_name=model_name,
+            safety_settings=safety_settings
+        )
+    except Exception as e:
+        return df, {"error": f"Failed to initialize Gemini API: {str(e)}"} 
+
+    # Prepare Data
+    # Rename columns for LLM clarity
+    df_llm = df[['Time (ms)', 'Current', 'Resistance', 'Travel']].copy()
+    df_llm.columns = ['time', 'curr', 'res', 'travel']
+    
+    # Round values
+    df_llm = df_llm.round(1)
+    
+    # Sample to keep prompt size manageable (e.g., every 5th row)
+    # User's code used df.to_string(index=False), implying they might not have sampled, 
+    # but for safety with large CSVs, we'll keep sampling but use to_string format.
+    df_sampled = df_llm.iloc[::5, :]
+    
+    data_str = df_sampled.to_string(index=False)
+    
+    prompt = get_dcrm_prompt(data_str)
+
+    content = [prompt]
+    if image_bytes:
+        try:
+            image = PIL.Image.open(io.BytesIO(image_bytes))
+            content.append(image)
+        except Exception as e:
+            return df, {"error": f"Failed to process image: {str(e)}"}
+
+    try:
+        response = model.generate_content(content)
+        
+        if not response.text:
+            if hasattr(response, 'prompt_feedback'):
+                return df, {
+                    "error": "Response blocked by safety filters",
+                    "raw_response": str(response.prompt_feedback)
+                }
+            return df, {"error": "LLM returned empty response"}
+        
+        result = response.text.strip()
+        
+        # Remove markdown code blocks
+        if "```json" in result:
+            result = result.split("```json")[1].split("```")[0].strip()
+        elif "```" in result:
+             result = result.split("```")[1].split("```")[0].strip()
+        
+        # Parse JSON
+        try:
+            result_json = json.loads(result)
+            zones = result_json.get("zones", {})
+            
+            # Enrich DataFrame with Zones
+            df['Zone'] = "Unknown"
+            
+            for zone_name, details in zones.items():
+                start = details.get("start_ms")
+                end = details.get("end_ms")
+                if start is not None and end is not None:
+                    # Map zone name to a simpler label (e.g., "Zone 1")
+                    short_name = zone_name.split('_')[1] # "1", "2", etc.
+                    mask = (df['Time (ms)'] >= start) & (df['Time (ms)'] <= end)
+                    df.loc[mask, 'Zone'] = f"Zone {short_name}"
+            
+            return df, result_json
+            
+        except json.JSONDecodeError as je:
+            return df, {
+                "error": f"JSON parsing failed: {str(je)}",
+                "raw_response": result[:1000]
+            }
+            
+    except Exception as e:
+        return df, {"error": f"LLM API error: {str(e)}"}
+
+def analyze_health_with_llm(image_bytes, api_key, model_name):
+    """
+    Sends the DCRM image to Gemini for expert diagnostic analysis.
+    """
+    if not api_key or not image_bytes: return None
+
+    try:
+        genai.configure(api_key=api_key)
+        
+        safety_settings = [
+            {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "BLOCK_NONE"},
+            {"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "BLOCK_NONE"},
+            {"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT", "threshold": "BLOCK_NONE"},
+            {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_NONE"},
+        ]
+        
+        model = genai.GenerativeModel(
+            model_name=model_name,
+            safety_settings=safety_settings
+        )
+        
+        prompt = """
+        System Role: Principal DCRM & Kinematic Analyst
+        Role:
+        You are an expert High-Voltage Circuit Breaker Diagnostician. Your task is to interpret Dynamic Contact Resistance (DCRM) traces to detect specific electrical and mechanical faults.
+        
+        Critical "Anti-Overfitting" Directive:
+        You must distinguish between Systematic Defects and Artifacts.
+        Sensor/Manufacturing Noise: A totally flat line is rare in real-world data. Slight "fuzz" or very minute "grassiness" (amplitude < 10 μΩ) is often sensor noise, ADC quantization, or normal manufacturing surface variance. Do not flag this as a defect.
+        True Degradation: Flag issues only when the visual signature is statistically significant and exceeds the "noise floor."
+        
+        Capability:
+        Identify Multiple Concurrent Issues if present. (e.g., A breaker can have both misalignment and contact wear).
+        there will mostly be 3 line charts in the input
+        green resistance profile
+        blue current profile 
+        red travel profile
+        
+        1. Diagnostic Heuristics & Defect Taxonomy
+        Map the visual DCRM trace to ONLY the following defect types. Use the specific Visual Heuristics to confirm detection.
+        
+        Defect Type | Visual Heuristic (The "Hint") | Mechanical Significance (Root Cause)
+        --- | --- | ---
+        Main Contact Issue (Corrosion/Oxidation) | "The Significant Grass"<br>In the fully closed plateau, look for pronounced, erratic instability. <br>• Ignore: Uniform, low-amplitude fuzz (sensor noise).<br>• Flag: Jagged, irregular peaks/valleys with significant amplitude (e.g., > 15–20 μΩ variance). The trace looks like a "rough rocky road," not just a "gravel path." | Surface Pathology: The Silver (Ag) plating is compromised (fretting corrosion) or heavy oxidation has occurred. The current path is constantly shifting through microscopic non-conductive spots.
+        Arcing Contact Wear | "Big Spikes & Short Wipe"<br>Resistance spikes are frequent and significantly large (high amplitude). Crucially, the duration of the arcing zone (the time between first touch and main contact touch) is noticeably shorter than expected. | Ablation: The Tungsten-Copper (W-Cu) tips are heavily eroded. The contact length has physically diminished, risking failure to commutate current during opening.
+        Misalignment (Main) | "The Struggle to Settle"<br>There are significant, high-amplitude peaks just before the trace tries to settle into the stable plateau. These are not bounces; they are "struggles" to mate that persist longer than 3-5ms. | Mechanical Centering: The moving contact pin is hitting the side or edge of the stationary rosette fingers before forcing its way in. Caused by loose nuts, kinematic play, or guide ring failure.
+        Misalignment (Arcing) | "Rough Entry"<br>Erratic resistance spikes occurring specifically during the initial entry (commutation), well before the main contacts engage. | Tip Eccentricity: The arcing pin is not entering the nozzle concentrically. It is scraping the nozzle throat or hitting the side, indicating a bent rod or skewed interrupter.
+        Slow Mechanism | "Stretched Time"<br>The entire resistance profile is elongated along the X-axis. Events happen later than normal. | Energy Starvation: Low spring charge, hydraulic pressure loss, or high friction due to hardened grease in the linkage.
+        
+        2. Analysis Logic (The "Signal-to-Noise" Filter)
+        Before declaring a defect, run these logic checks:
+        The "Noise Floor" Test (For Main Contacts):
+        Is the plateau variance uniform and small (< 10 μΩ)? -> Classify as Healthy (Sensor/Manufacturing artifact).
+        Is the variance erratic, jagged, and large (> 15 μΩ)? -> Classify as Corrosion/Oxidation.
+        The "Duration" Test (For Misalignment):
+        Are the pre-plateau peaks < 2ms? -> Ignore (Benign Bounce).
+        Do the peaks persist > 3-5ms before settling? -> Classify as Misalignment.
+        The "Combination" Check:
+        Does the trace show both "Rough Entry" AND "Stretched Time"? -> Report Both (Misalignment + Slow Mechanism).
+        
+        3. Output Structure
+        Provide a concise Executive Lead followed by the JSON.
+        
+        Executive Lead (3-4 Lines)
+        Status: Healthy | Warning | Critical.
+        Key Findings: Summary of valid defects found (ignoring sensor noise).
+        Action: "Return to service" or specific repair instruction.
+        
+        JSON Schema
+        ```json
+        {
+          "image_url": "string",
+          "overall_condition": "Healthy|Warning|Critical",
+          "detected_issues": [
+            {
+              "issue_type": "Main Contact Issue (Corrosion/Oxidation)|Arcing Contact Wear|Misalignment (Main)|Misalignment (Arcing)|Slow Mechanism",
+              "confidence": "High|Medium|Low",
+              "visual_evidence": "string (e.g., 'Plateau instability >20 micro-ohms detected, exceeding sensor noise threshold.')",
+              "mechanical_significance": "string (Root cause from table)",
+              "severity": "Low|Medium|High"
+            }
+          ],
+          "analysis_metrics": {
+            "static_resistance_Rp_uOhm": "float",
+            "signal_noise_level": "Low (Sensor/Mfg)|High (Defect)",
+            "wipe_quality": "Normal|Short|Erratic"
+          },
+          "maintenance_recommendation": "string"
+        }
+        ```
+        """
+        
+        image = PIL.Image.open(io.BytesIO(image_bytes))
+        
+        response = model.generate_content([prompt, image])
+        
+        if not response.text:
+            return {"error": "LLM returned empty response"}
+            
+        return response.text
+        
+    except Exception as e:
+        return {"error": f"LLM Analysis Error: {str(e)}"}

dcrm/plotting.py

@@ -0,0 +1,109 @@
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+
+def create_dcrm_plot(df, zones):
+    # Create figure with secondary y-axis
+    fig = make_subplots(specs=[[{"secondary_y": True}]])
+
+    # Add Traces
+    # Ensure column names match what is in the DF (dcrm_llm_app.py uses 'Time (ms)', 'Current', 'Resistance', 'Travel')
+    # The user's code uses 'Time_ms'. I need to be careful here.
+    # process_uploaded_image returns DF with 'Time (ms)', 'Current', 'Resistance', 'Travel'.
+    # I should adapt the plotting code to use the existing column names OR rename columns in the DF.
+    # The user's code expects 'Time_ms'.
+    # I will handle this mapping inside the function to be safe.
+    
+    time_col = 'Time (ms)' if 'Time (ms)' in df.columns else 'Time_ms'
+    
+    fig.add_trace(go.Scatter(x=df[time_col], y=df['Current'], name="Current (A)", line=dict(color='#2980b9', width=2)), secondary_y=False)
+    fig.add_trace(go.Scatter(x=df[time_col], y=df['Resistance'], name="Resistance (uOhm)", line=dict(color='#27ae60', width=2)), secondary_y=False)
+    fig.add_trace(go.Scatter(x=df[time_col], y=df['Travel'], name="Travel (mm)", line=dict(color='#c0392b', width=2)), secondary_y=True)
+
+    # Zone Colors
+    zone_colors = {
+        "zone_1_pre_contact": "rgba(52, 152, 219, 0.1)",
+        "zone_2_arcing_engagement": "rgba(231, 76, 60, 0.1)",
+        "zone_3_main_conduction": "rgba(46, 204, 113, 0.1)",
+        "zone_4_parting": "rgba(155, 89, 182, 0.1)",
+        "zone_5_final_open": "rgba(149, 165, 166, 0.1)"
+    }
+
+    # Add Zone Rectangles
+    # The user's code expects 'zones' to be a dict of zone details.
+    # The result_json has "zones" key.
+    zones_dict = zones.get("zones", {}) if "zones" in zones else zones
+
+    for zone_name, details in zones_dict.items():
+        start = details.get("start_ms")
+        end = details.get("end_ms")
+        color = zone_colors.get(zone_name, "rgba(0,0,0,0)")
+        
+        if start is not None and end is not None:
+            fig.add_vrect(
+                x0=start, x1=end,
+                fillcolor=color, opacity=1,
+                layer="below", line_width=0,
+                annotation_text=zone_name.split('_')[1].upper(),
+                annotation_position="top left",
+                annotation_font_color="#7f8c8d"
+            )
+
+    fig.update_layout(
+        title_text="<b>Main Signals & Zones</b>",
+        height=500,
+        hovermode="x unified",
+        plot_bgcolor="white",
+        paper_bgcolor="white",
+        font=dict(family="Segoe UI, sans-serif"),
+        legend=dict(orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1),
+        margin=dict(l=20, r=20, t=60, b=20)
+    )
+    fig.update_xaxes(showgrid=True, gridwidth=1, gridcolor='#f0f0f0')
+    fig.update_yaxes(title_text="Current / Resistance", secondary_y=False, showgrid=True, gridwidth=1, gridcolor='#f0f0f0')
+    fig.update_yaxes(title_text="Travel", secondary_y=True, showgrid=False)
+
+    return fig
+
+def create_velocity_plot(df):
+    time_col = 'Time (ms)' if 'Time (ms)' in df.columns else 'Time_ms'
+    
+    # Calculate Velocity (Derivative of Travel)
+    # V = d(Travel) / d(Time)
+    # Units: mm/ms = m/s
+    df['Velocity'] = df['Travel'].diff() / df[time_col].diff()
+    
+    fig = go.Figure()
+    fig.add_trace(go.Scatter(x=df[time_col], y=df['Velocity'], name="Velocity (m/s)", line=dict(color='#e67e22', width=2), fill='tozeroy'))
+    
+    fig.update_layout(
+        title_text="<b>Contact Velocity Profile</b>",
+        height=300,
+        hovermode="x unified",
+        plot_bgcolor="white",
+        paper_bgcolor="white",
+        font=dict(family="Segoe UI, sans-serif"),
+        margin=dict(l=20, r=20, t=40, b=20)
+    )
+    fig.update_xaxes(showgrid=True, gridwidth=1, gridcolor='#f0f0f0')
+    fig.update_yaxes(title_text="Velocity (m/s)", showgrid=True, gridwidth=1, gridcolor='#f0f0f0')
+    return fig
+
+def create_resistance_zoom_plot(df):
+    time_col = 'Time (ms)' if 'Time (ms)' in df.columns else 'Time_ms'
+    
+    fig = go.Figure()
+    fig.add_trace(go.Scatter(x=df[time_col], y=df['Resistance'], name="Resistance", line=dict(color='#27ae60', width=2)))
+    
+    fig.update_layout(
+        title_text="<b>Detailed Resistance (Log Scale)</b>",
+        height=300,
+        hovermode="x unified",
+        plot_bgcolor="white",
+        paper_bgcolor="white",
+        font=dict(family="Segoe UI, sans-serif"),
+        yaxis_type="log", # Log scale to see details
+        margin=dict(l=20, r=20, t=40, b=20)
+    )
+    fig.update_xaxes(showgrid=True, gridwidth=1, gridcolor='#f0f0f0')
+    fig.update_yaxes(title_text="Resistance (uOhm)", showgrid=True, gridwidth=1, gridcolor='#f0f0f0')
+    return fig

dcrm/report_generator.py

@@ -0,0 +1,128 @@
+from fpdf import FPDF
+import datetime
+import os
+import tempfile
+
+class PDFReportGenerator(FPDF):
+    def __init__(self):
+        super().__init__()
+        self.set_auto_page_break(auto=True, margin=15)
+        self.add_page()
+        self.set_font("helvetica", size=12)
+
+    def header(self):
+        self.set_font("helvetica", "B", 15)
+        self.cell(0, 10, "DCRM Analysis Report", align="C")
+        self.ln(20)
+
+    def footer(self):
+        self.set_y(-15)
+        self.set_font("helvetica", "I", 8)
+        self.cell(0, 10, f"Page {self.page_no()}", align="C")
+
+    def add_section_title(self, title):
+        self.set_font("helvetica", "B", 12)
+        self.set_fill_color(200, 220, 255)
+        self.cell(0, 10, title, fill=True, ln=True)
+        self.ln(5)
+
+    def sanitize_text(self, text):
+        """Replace unsupported characters with ASCII equivalents."""
+        if not isinstance(text, str):
+            text = str(text)
+        replacements = {
+            "μ": "u",
+            "Ω": "Ohm",
+            "–": "-",
+            "—": "-",
+            "’": "'",
+            "“": '"',
+            "”": '"',
+            "…": "...",
+            "°": "deg"
+        }
+        for char, replacement in replacements.items():
+            text = text.replace(char, replacement)
+        
+        # Final fallback: encode to ascii, ignoring errors, then decode back
+        return text.encode('ascii', 'ignore').decode('ascii')
+
+    def add_key_value(self, key, value):
+        self.set_font("helvetica", "B", 10)
+        self.cell(50, 8, self.sanitize_text(f"{key}:"), border=0)
+        self.set_font("helvetica", "", 10)
+        self.cell(0, 8, self.sanitize_text(str(value)), border=0, ln=True)
+
+    def add_multiline_text(self, text):
+        self.set_font("helvetica", "", 10)
+        self.multi_cell(0, 5, self.sanitize_text(str(text)))
+        self.ln(5)
+
+    def generate_report(self, analysis_data, zone_analysis, graph_image_path=None):
+        # 1. Executive Summary
+        self.add_section_title("Executive Summary")
+        
+        overall = zone_analysis.get('overall_health', {})
+        self.add_key_value("Date", datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
+        self.add_key_value("Overall Condition", overall.get('status', 'Unknown'))
+        self.add_key_value("Health Score", f"{overall.get('overall_score', 0):.1f}/100")
+        self.add_key_value("Recommendation", overall.get('recommendation', 'N/A'))
+        self.ln(5)
+
+        # 2. Visual Evidence (Graph)
+        if graph_image_path and os.path.exists(graph_image_path):
+            self.add_section_title("DCRM Graph Analysis")
+            # Calculate width to fit page
+            page_width = self.w - 2 * self.l_margin
+            self.image(graph_image_path, w=page_width)
+            self.ln(10)
+
+        # 3. Detailed Metrics
+        if analysis_data:
+            self.add_section_title("Key Technical Metrics")
+            metrics = analysis_data.get("analysis_metrics", {})
+            self.add_key_value("Static Resistance", f"{metrics.get('static_resistance_Rp_uOhm', 'N/A')} uOhm")
+            self.add_key_value("Signal Noise", metrics.get('signal_noise_level', 'N/A'))
+            self.add_key_value("Wipe Quality", metrics.get('wipe_quality', 'N/A'))
+            self.ln(5)
+
+            # Issues
+            issues = analysis_data.get("detected_issues", [])
+            if issues:
+                self.add_section_title("Detected Issues")
+                for i, issue in enumerate(issues, 1):
+                    self.set_font("helvetica", "B", 10)
+                    self.cell(0, 8, self.sanitize_text(f"{i}. {issue.get('issue_type', 'Issue')}"), ln=True)
+                    self.set_font("helvetica", "", 10)
+                    self.multi_cell(0, 5, self.sanitize_text(f"Severity: {issue.get('severity')}\nEvidence: {issue.get('visual_evidence')}\nRoot Cause: {issue.get('mechanical_significance')}"))
+                    self.ln(3)
+        
+        # 4. Zone Details
+        self.add_section_title("Zone-by-Zone Analysis")
+        zone_names_display = {
+            'zone_1_pre_contact': '1. Pre-Contact Travel',
+            'zone_2_arcing_engagement': '2. Arcing Contact Engagement',
+            'zone_3_main_conduction': '3. Main Contact Conduction',
+            'zone_4_parting': '4. Main Contact Parting',
+            'zone_5_final_open': '5. Final Open State'
+        }
+        
+        for zone_key, display_name in zone_names_display.items():
+            if zone_key in zone_analysis:
+                z_health = zone_analysis[zone_key]
+                self.set_font("helvetica", "B", 10)
+                self.cell(0, 8, self.sanitize_text(f"{display_name} - {z_health.get('health_status', 'Unknown')}"), ln=True)
+                
+                # Issues in zone
+                if z_health.get('issues'):
+                     self.set_font("helvetica", "I", 9)
+                     for issue in z_health['issues']:
+                         self.cell(10) # Indent
+                         self.cell(0, 5, self.sanitize_text(f"- {issue}"), ln=True)
+                else:
+                    self.set_font("helvetica", "", 9)
+                    self.cell(10)
+                    self.cell(0, 5, "No issues detected.", ln=True)
+                self.ln(2)
+
+        return bytes(self.output())

dcrm/zone_analysis.py

@@ -0,0 +1,658 @@
+"""
+Zone Analysis Module for DCRM Curves
+
+This module analyzes each segmented zone from DCRM graphs and evaluates
+the health characteristics based on industry standards for circuit breaker
+dynamic contact resistance measurements.
+
+Healthy DCRM Curve Characteristics:
+- Smooth resistance profile without excessive spikes
+- Gradual resistance drop during arcing contact engagement
+- Sharp drop to low, stable resistance (30-80 µΩ) during main contact engagement
+- Smooth resistance increase during opening operation
+- Minimal oscillations and no high peaks
+- Reproducible signature over time
+"""
+
+import numpy as np
+import pandas as pd
+from typing import Dict, List, Tuple, Any
+
+
+class ZoneAnalyzer:
+    """Analyzes individual zones of DCRM curves for health assessment."""
+    
+    # Healthy curve thresholds (based on research)
+    HEALTHY_THRESHOLDS = {
+        'main_contact_resistance_max': 80,  # µΩ (micro-ohms) - converted to graph units
+        'main_contact_resistance_min': 30,  # µΩ
+        'max_resistance_spike_ratio': 3.0,  # Max spike should be < 3x baseline
+        'max_oscillation_percentage': 15,   # Max 15% oscillation in stable zones
+        'smoothness_threshold': 0.85,       # Correlation coefficient for smoothness
+        'current_rise_rate_min': 0.5,       # Minimum rate of current rise in Zone 1
+        'travel_stability_threshold': 5,    # Max variation in travel during conduction
+    }
+    
+    def __init__(self, df: pd.DataFrame, zones_data: Dict[str, Any]):
+        """
+        Initialize the zone analyzer.
+        
+        Args:
+            df: DataFrame with columns ['Time (ms)', 'Current', 'Resistance', 'Travel']
+            zones_data: Dictionary containing zone segmentation information
+        """
+        self.df = df
+        self.zones_data = zones_data
+        self.analysis_results = {}
+        
+    def analyze_all_zones(self) -> Dict[str, Any]:
+        """
+        Analyze all zones and return comprehensive health assessment.
+        
+        Returns:
+            Dictionary containing analysis results for each zone
+        """
+        if 'zones' not in self.zones_data:
+            return {'error': 'No zone data available'}
+        
+        zones = self.zones_data['zones']
+        
+        # Analyze each zone
+        for zone_name, zone_info in zones.items():
+            zone_df = self._extract_zone_data(zone_info)
+            
+            if zone_df is not None and len(zone_df) > 0:
+                analysis = self._analyze_zone(zone_name, zone_df, zone_info)
+                self.analysis_results[zone_name] = analysis
+        
+        # Generate overall health assessment
+        overall_health = self._calculate_overall_health()
+        self.analysis_results['overall_health'] = overall_health
+        
+        return self.analysis_results
+    
+    def _extract_zone_data(self, zone_info: Dict) -> pd.DataFrame:
+        """Extract data for a specific zone based on time boundaries."""
+        start_ms = zone_info.get('start_ms', 0)
+        end_ms = zone_info.get('end_ms', 0)
+        
+        mask = (self.df['Time (ms)'] >= start_ms) & (self.df['Time (ms)'] <= end_ms)
+        return self.df[mask].copy()
+    
+    def _analyze_zone(self, zone_name: str, zone_df: pd.DataFrame, 
+                     zone_info: Dict) -> Dict[str, Any]:
+        """
+        Analyze a specific zone based on its characteristics.
+        
+        Args:
+            zone_name: Name of the zone
+            zone_df: DataFrame containing zone data
+            zone_info: Zone metadata
+            
+        Returns:
+            Dictionary with zone analysis results
+        """
+        analysis = {
+            'zone_name': zone_name,
+            'duration_ms': zone_info.get('end_ms', 0) - zone_info.get('start_ms', 0),
+            'health_status': 'Unknown',
+            'health_score': 0.0,
+            'issues': [],
+            'metrics': {}
+        }
+        
+        # Zone-specific analysis
+        if 'zone_1' in zone_name:
+            analysis.update(self._analyze_zone_1_pre_contact(zone_df))
+        elif 'zone_2' in zone_name:
+            analysis.update(self._analyze_zone_2_arcing_engagement(zone_df))
+        elif 'zone_3' in zone_name:
+            analysis.update(self._analyze_zone_3_main_conduction(zone_df))
+        elif 'zone_4' in zone_name:
+            analysis.update(self._analyze_zone_4_parting(zone_df))
+        elif 'zone_5' in zone_name:
+            analysis.update(self._analyze_zone_5_final_open(zone_df))
+        
+        return analysis
+    
+    def _analyze_zone_1_pre_contact(self, zone_df: pd.DataFrame) -> Dict[str, Any]:
+        """
+        Analyze Zone 1: Pre-Contact Travel
+        
+        Expected behavior:
+        - Travel should be increasing (contacts moving)
+        - Current should be near zero (no contact yet)
+        - Resistance should be very high (infinite/open circuit)
+        """
+        metrics = {}
+        issues = []
+        
+        # Check travel progression
+        travel_values = zone_df['Travel'].dropna()
+        if len(travel_values) > 1:
+            travel_trend = np.polyfit(range(len(travel_values)), travel_values, 1)[0]
+            metrics['travel_rate'] = float(travel_trend)
+            
+            if travel_trend < 0.1:
+                issues.append('Travel not increasing properly - possible mechanical issue')
+        
+        # Check current is near baseline
+        current_values = zone_df['Current'].dropna()
+        if len(current_values) > 0:
+            current_mean = current_values.mean()
+            current_std = current_values.std()
+            metrics['current_baseline'] = float(current_mean)
+            metrics['current_stability'] = float(current_std)
+            
+            # Current should rise towards end of zone
+            if len(current_values) > 5:
+                early_current = current_values.iloc[:len(current_values)//3].mean()
+                late_current = current_values.iloc[-len(current_values)//3:].mean()
+                current_rise = late_current - early_current
+                metrics['current_rise'] = float(current_rise)
+                
+                if current_rise < self.HEALTHY_THRESHOLDS['current_rise_rate_min']:
+                    issues.append('Insufficient current rise - delayed contact engagement')
+        
+        # Calculate health score
+        health_score = self._calculate_zone_health_score(metrics, issues, zone_type='zone_1')
+        
+        return {
+            'metrics': metrics,
+            'issues': issues,
+            'health_score': health_score,
+            'health_status': self._get_health_status(health_score)
+        }
+    
+    def _analyze_zone_2_arcing_engagement(self, zone_df: pd.DataFrame) -> Dict[str, Any]:
+        """
+        Analyze Zone 2: Arcing Contact Engagement
+        
+        Expected behavior:
+        - Resistance drops from high to moderate (arcing contacts engaging)
+        - Should see resistance spikes (arcing activity)
+        - Current starts flowing
+        - Smooth gradual drop is healthy
+        """
+        metrics = {}
+        issues = []
+        
+        resistance_values = zone_df['Resistance'].dropna()
+        
+        if len(resistance_values) > 2:
+            # Check for gradual resistance drop
+            res_start = resistance_values.iloc[:3].mean()
+            res_end = resistance_values.iloc[-3:].mean()
+            res_drop = res_start - res_end
+            metrics['resistance_drop'] = float(res_drop)
+            
+            if res_drop < 0:
+                issues.append('Resistance increasing instead of dropping - abnormal arcing')
+            
+            # Analyze resistance spikes (expected during arcing)
+            res_peaks = self._detect_peaks(resistance_values)
+            metrics['spike_count'] = len(res_peaks)
+            
+            if len(res_peaks) > 0:
+                max_spike = resistance_values.iloc[res_peaks].max()
+                baseline = resistance_values.median()
+                spike_ratio = max_spike / baseline if baseline > 0 else 0
+                metrics['max_spike_ratio'] = float(spike_ratio)
+                
+                if spike_ratio > self.HEALTHY_THRESHOLDS['max_resistance_spike_ratio']:
+                    issues.append(f'Excessive resistance spikes ({spike_ratio:.1f}x) - possible contact damage')
+            
+            # Check smoothness of transition
+            smoothness = self._calculate_smoothness(resistance_values)
+            metrics['transition_smoothness'] = float(smoothness)
+            
+            if smoothness < 0.6:  # Lower threshold for arcing zone (spikes expected)
+                issues.append('Erratic resistance pattern - possible contact erosion')
+        
+        # Check current flow
+        current_values = zone_df['Current'].dropna()
+        if len(current_values) > 0:
+            metrics['current_mean'] = float(current_values.mean())
+            metrics['current_max'] = float(current_values.max())
+        
+        health_score = self._calculate_zone_health_score(metrics, issues, zone_type='zone_2')
+        
+        return {
+            'metrics': metrics,
+            'issues': issues,
+            'health_score': health_score,
+            'health_status': self._get_health_status(health_score)
+        }
+    
+    def _analyze_zone_3_main_conduction(self, zone_df: pd.DataFrame) -> Dict[str, Any]:
+        """
+        Analyze Zone 3: Main Contact Conduction
+        
+        Expected behavior:
+        - Resistance should be LOW and STABLE (30-80 µΩ ideal)
+        - Travel should be at maximum (plateau)
+        - Current should be stable
+        - This is the "healthy contact" signature zone
+        """
+        metrics = {}
+        issues = []
+        
+        resistance_values = zone_df['Resistance'].dropna()
+        
+        if len(resistance_values) > 0:
+            res_mean = resistance_values.mean()
+            res_std = resistance_values.std()
+            res_min = resistance_values.min()
+            res_max = resistance_values.max()
+            
+            metrics['resistance_mean'] = float(res_mean)
+            metrics['resistance_std'] = float(res_std)
+            metrics['resistance_range'] = float(res_max - res_min)
+            
+            # Check if resistance is in healthy range
+            # Note: Graph units may not be µΩ, so we check relative stability instead
+            oscillation_pct = (res_std / res_mean * 100) if res_mean > 0 else 0
+            metrics['oscillation_percentage'] = float(oscillation_pct)
+            
+            if oscillation_pct > self.HEALTHY_THRESHOLDS['max_oscillation_percentage']:
+                issues.append(f'Excessive resistance oscillation ({oscillation_pct:.1f}%) - poor contact quality')
+            
+            # Check for stability (should be flat)
+            smoothness = self._calculate_smoothness(resistance_values)
+            metrics['resistance_stability'] = float(smoothness)
+            
+            if smoothness < self.HEALTHY_THRESHOLDS['smoothness_threshold']:
+                issues.append('Unstable resistance - possible contact bouncing or misalignment')
+        
+        # Check travel plateau
+        travel_values = zone_df['Travel'].dropna()
+        if len(travel_values) > 0:
+            travel_variation = travel_values.std()
+            metrics['travel_variation'] = float(travel_variation)
+            
+            if travel_variation > self.HEALTHY_THRESHOLDS['travel_stability_threshold']:
+                issues.append('Travel not stable - mechanical issue during conduction')
+        
+        # Check current stability
+        current_values = zone_df['Current'].dropna()
+        if len(current_values) > 0:
+            current_std = current_values.std()
+            current_mean = current_values.mean()
+            current_stability = (current_std / current_mean * 100) if current_mean > 0 else 0
+            metrics['current_stability_pct'] = float(current_stability)
+        
+        health_score = self._calculate_zone_health_score(metrics, issues, zone_type='zone_3')
+        
+        return {
+            'metrics': metrics,
+            'issues': issues,
+            'health_score': health_score,
+            'health_status': self._get_health_status(health_score)
+        }
+    
+    def _analyze_zone_4_parting(self, zone_df: pd.DataFrame) -> Dict[str, Any]:
+        """
+        Analyze Zone 4: Main Contact Parting (The Break)
+        
+        Expected behavior:
+        - Resistance should INCREASE sharply (contacts separating)
+        - May see resistance spikes (arcing during separation)
+        - Travel should start decreasing (opening)
+        - Smooth increase is healthy
+        """
+        metrics = {}
+        issues = []
+        
+        resistance_values = zone_df['Resistance'].dropna()
+        
+        if len(resistance_values) > 2:
+            # Check for resistance increase
+            res_start = resistance_values.iloc[:3].mean()
+            res_end = resistance_values.iloc[-3:].mean()
+            res_increase = res_end - res_start
+            metrics['resistance_increase'] = float(res_increase)
+            
+            if res_increase < 0:
+                issues.append('Resistance decreasing during parting - abnormal behavior')
+            
+            # Check rate of increase
+            if len(resistance_values) > 1:
+                res_trend = np.polyfit(range(len(resistance_values)), resistance_values, 1)[0]
+                metrics['resistance_rise_rate'] = float(res_trend)
+                
+                if res_trend < 0.1:
+                    issues.append('Slow resistance rise - possible contact sticking')
+            
+            # Analyze spikes during parting (some arcing is normal)
+            res_peaks = self._detect_peaks(resistance_values)
+            metrics['parting_spike_count'] = len(res_peaks)
+            
+            if len(res_peaks) > 0:
+                max_spike = resistance_values.iloc[res_peaks].max()
+                baseline = resistance_values.median()
+                spike_ratio = max_spike / baseline if baseline > 0 else 0
+                metrics['max_parting_spike_ratio'] = float(spike_ratio)
+                
+                if spike_ratio > self.HEALTHY_THRESHOLDS['max_resistance_spike_ratio'] * 1.5:
+                    issues.append(f'Excessive parting spikes ({spike_ratio:.1f}x) - severe arcing or contact damage')
+        
+        # Check travel movement
+        travel_values = zone_df['Travel'].dropna()
+        if len(travel_values) > 1:
+            travel_trend = np.polyfit(range(len(travel_values)), travel_values, 1)[0]
+            metrics['travel_opening_rate'] = float(travel_trend)
+            
+            if travel_trend > -0.1:  # Should be negative (decreasing)
+                issues.append('Travel not decreasing properly - mechanical opening issue')
+        
+        health_score = self._calculate_zone_health_score(metrics, issues, zone_type='zone_4')
+        
+        return {
+            'metrics': metrics,
+            'issues': issues,
+            'health_score': health_score,
+            'health_status': self._get_health_status(health_score)
+        }
+    
+    def _analyze_zone_5_final_open(self, zone_df: pd.DataFrame) -> Dict[str, Any]:
+        """
+        Analyze Zone 5: Final Open State
+        
+        Expected behavior:
+        - Resistance should be very high and stable (infinite/open circuit)
+        - Travel should be stable at minimum (fully open)
+        - Current should be zero
+        """
+        metrics = {}
+        issues = []
+        
+        resistance_values = zone_df['Resistance'].dropna()
+        
+        if len(resistance_values) > 0:
+            res_mean = resistance_values.mean()
+            res_std = resistance_values.std()
+            metrics['final_resistance_mean'] = float(res_mean)
+            metrics['final_resistance_stability'] = float(res_std)
+            
+            # Should be stable (flat line at high value)
+            stability_pct = (res_std / res_mean * 100) if res_mean > 0 else 0
+            metrics['stability_percentage'] = float(stability_pct)
+            
+            if stability_pct > 10:
+                issues.append('Unstable final resistance - possible incomplete opening')
+        
+        # Check travel is stable
+        travel_values = zone_df['Travel'].dropna()
+        if len(travel_values) > 0:
+            travel_std = travel_values.std()
+            metrics['travel_final_stability'] = float(travel_std)
+            
+            if travel_std > 3:
+                issues.append('Travel unstable in final state - mechanical issue')
+        
+        # Check current is near zero
+        current_values = zone_df['Current'].dropna()
+        if len(current_values) > 0:
+            current_mean = current_values.mean()
+            metrics['final_current'] = float(current_mean)
+            
+            # Current should be very low in open state
+            initial_current = self.df['Current'].iloc[:10].mean()  # Baseline from start
+            if current_mean > initial_current * 1.5:
+                issues.append('Elevated current in open state - possible leakage')
+        
+        health_score = self._calculate_zone_health_score(metrics, issues, zone_type='zone_5')
+        
+        return {
+            'metrics': metrics,
+            'issues': issues,
+            'health_score': health_score,
+            'health_status': self._get_health_status(health_score)
+        }
+    
+    def _detect_peaks(self, signal: pd.Series, prominence_factor: float = 0.3) -> List[int]:
+        """
+        Detect peaks in a signal.
+        
+        Args:
+            signal: Input signal
+            prominence_factor: Minimum prominence as fraction of signal range
+            
+        Returns:
+            List of peak indices
+        """
+        if len(signal) < 3:
+            return []
+        
+        values = signal.values
+        signal_range = values.max() - values.min()
+        min_prominence = signal_range * prominence_factor
+        
+        peaks = []
+        for i in range(1, len(values) - 1):
+            if values[i] > values[i-1] and values[i] > values[i+1]:
+                # Check prominence
+                left_min = min(values[max(0, i-5):i])
+                right_min = min(values[i+1:min(len(values), i+6)])
+                prominence = values[i] - max(left_min, right_min)
+                
+                if prominence >= min_prominence:
+                    peaks.append(i)
+        
+        return peaks
+    
+    def _calculate_smoothness(self, signal: pd.Series) -> float:
+        """
+        Calculate smoothness of a signal using correlation with fitted line.
+        
+        Args:
+            signal: Input signal
+            
+        Returns:
+            Smoothness score (0-1, higher is smoother)
+        """
+        if len(signal) < 3:
+            return 0.0
+        
+        x = np.arange(len(signal))
+        y = signal.values
+        
+        # Fit a polynomial (degree 2 for curves, degree 1 for lines)
+        try:
+            coeffs = np.polyfit(x, y, deg=2)
+            fitted = np.polyval(coeffs, x)
+            
+            # Calculate correlation
+            correlation = np.corrcoef(y, fitted)[0, 1]
+            return abs(correlation) if not np.isnan(correlation) else 0.0
+        except:
+            return 0.0
+    
+    def _calculate_zone_health_score(self, metrics: Dict, issues: List[str], 
+                                    zone_type: str) -> float:
+        """
+        Calculate health score for a zone (0-100).
+        
+        Args:
+            metrics: Zone metrics
+            issues: List of detected issues
+            zone_type: Type of zone
+            
+        Returns:
+            Health score (0-100)
+        """
+        # Start with perfect score
+        score = 100.0
+        
+        # Deduct points for each issue
+        score -= len(issues) * 15
+        
+        # Zone-specific scoring adjustments
+        if zone_type == 'zone_3':  # Main conduction - most critical
+            if 'oscillation_percentage' in metrics:
+                osc = metrics['oscillation_percentage']
+                if osc > 20:
+                    score -= 20
+                elif osc > 15:
+                    score -= 10
+            
+            if 'resistance_stability' in metrics:
+                if metrics['resistance_stability'] < 0.85:
+                    score -= 15
+        
+        elif zone_type == 'zone_2' or zone_type == 'zone_4':  # Arcing zones
+            if 'max_spike_ratio' in metrics or 'max_parting_spike_ratio' in metrics:
+                spike_key = 'max_spike_ratio' if 'max_spike_ratio' in metrics else 'max_parting_spike_ratio'
+                spike_ratio = metrics[spike_key]
+                if spike_ratio > 5:
+                    score -= 25
+                elif spike_ratio > 3:
+                    score -= 10
+        
+        # Ensure score is in valid range
+        return max(0.0, min(100.0, score))
+    
+    def _get_health_status(self, score: float) -> str:
+        """Convert health score to status label."""
+        if score >= 85:
+            return 'Excellent'
+        elif score >= 70:
+            return 'Good'
+        elif score >= 50:
+            return 'Fair'
+        elif score >= 30:
+            return 'Poor'
+        else:
+            return 'Critical'
+    
+    def _calculate_overall_health(self) -> Dict[str, Any]:
+        """
+        Calculate overall health assessment across all zones.
+        
+        Returns:
+            Dictionary with overall health metrics
+        """
+        if not self.analysis_results:
+            return {'status': 'No data', 'score': 0.0}
+        
+        # Collect all zone scores
+        zone_scores = []
+        all_issues = []
+        
+        for zone_name, analysis in self.analysis_results.items():
+            if isinstance(analysis, dict) and 'health_score' in analysis:
+                zone_scores.append(analysis['health_score'])
+                all_issues.extend(analysis.get('issues', []))
+        
+        if not zone_scores:
+            return {'status': 'Unknown', 'score': 0.0}
+        
+        # Calculate weighted average (Zone 3 is most important)
+        weights = {
+            'zone_1_pre_contact': 0.15,
+            'zone_2_arcing_engagement': 0.20,
+            'zone_3_main_conduction': 0.35,  # Most critical
+            'zone_4_parting': 0.20,
+            'zone_5_final_open': 0.10
+        }
+        
+        weighted_score = 0.0
+        total_weight = 0.0
+        
+        for zone_name, analysis in self.analysis_results.items():
+            if isinstance(analysis, dict) and 'health_score' in analysis:
+                weight = weights.get(zone_name, 0.2)
+                weighted_score += analysis['health_score'] * weight
+                total_weight += weight
+        
+        overall_score = weighted_score / total_weight if total_weight > 0 else 0.0
+        
+        return {
+            'overall_score': round(overall_score, 2),
+            'status': self._get_health_status(overall_score),
+            'total_issues': len(all_issues),
+            'critical_issues': [issue for issue in all_issues if 'severe' in issue.lower() or 'critical' in issue.lower()],
+            'recommendation': self._generate_recommendation(overall_score, all_issues)
+        }
+    
+    def _generate_recommendation(self, score: float, issues: List[str]) -> str:
+        """Generate maintenance recommendation based on analysis."""
+        if score >= 85:
+            return 'Circuit breaker is in excellent condition. Continue regular monitoring.'
+        elif score >= 70:
+            return 'Circuit breaker is in good condition. Schedule routine maintenance as planned.'
+        elif score >= 50:
+            return 'Circuit breaker shows signs of wear. Increase monitoring frequency and plan maintenance.'
+        elif score >= 30:
+            return 'Circuit breaker condition is poor. Schedule maintenance soon to prevent failure.'
+        else:
+            return 'CRITICAL: Circuit breaker requires immediate attention. Risk of failure is high.'
+
+
+def analyze_zones_with_image(df: pd.DataFrame, zones_data: Dict[str, Any], 
+                             annotated_image: np.ndarray = None) -> Dict[str, Any]:
+    """
+    Convenience function to analyze zones and optionally annotate image.
+    
+    Args:
+        df: DataFrame with DCRM data
+        zones_data: Zone segmentation data
+        annotated_image: Optional image to annotate with analysis results
+        
+    Returns:
+        Complete analysis results
+    """
+    analyzer = ZoneAnalyzer(df, zones_data)
+    results = analyzer.analyze_all_zones()
+    
+    # If image provided, add visual annotations
+    if annotated_image is not None:
+        results['annotated_image'] = _annotate_image_with_health(
+            annotated_image, results, zones_data
+        )
+    
+    return results
+
+
+def _annotate_image_with_health(image: np.ndarray, analysis_results: Dict[str, Any],
+                                zones_data: Dict[str, Any]) -> np.ndarray:
+    """
+    Annotate image with health status for each zone.
+    
+    Args:
+        image: Input image
+        analysis_results: Analysis results from ZoneAnalyzer
+        zones_data: Zone segmentation data
+        
+    Returns:
+        Annotated image
+    """
+    import cv2
+    
+    annotated = image.copy()
+    height = annotated.shape[0]
+    
+    # Color coding for health status
+    status_colors = {
+        'Excellent': (0, 255, 0),    # Green
+        'Good': (144, 238, 144),     # Light Green
+        'Fair': (255, 255, 0),       # Yellow
+        'Poor': (255, 165, 0),       # Orange
+        'Critical': (255, 0, 0)      # Red
+    }
+    
+    if 'zones' in zones_data:
+        for zone_name, zone_info in zones_data['zones'].items():
+            if zone_name in analysis_results:
+                analysis = analysis_results[zone_name]
+                status = analysis.get('health_status', 'Unknown')
+                color = status_colors.get(status, (128, 128, 128))
+                
+                # Add colored indicator at top of zone
+                # This is a simple implementation - can be enhanced
+                y_pos = 30
+                text = f"{status} ({analysis.get('health_score', 0):.0f})"
+                cv2.putText(annotated, text, (10, y_pos), 
+                           cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2)
+    
+    return annotated

flask_app.py

@@ -0,0 +1,517 @@
+# flask_app.py
+"""
+Flask API for DCRM (Dynamic Contact Resistance Measurement) Analysis
+Provides endpoints for uploading DCRM graph images and getting AI-powered analysis.
+"""
+
+from flask import Flask, request, jsonify
+from flask_cors import CORS
+import cv2
+import numpy as np
+import os
+import json
+import re
+import tempfile
+import base64
+from werkzeug.utils import secure_filename
+
+# Import DCRM modules
+from dcrm.image_processing import process_uploaded_image
+from dcrm.llm import ask_llm_for_breakage, analyze_health_with_llm
+from dcrm.zone_analysis import ZoneAnalyzer
+
+app = Flask(__name__)
+CORS(app)  # Enable CORS for all routes
+
+# Configuration
+app.config["MAX_CONTENT_LENGTH"] = 16 * 1024 * 1024  # 16MB max file size
+ALLOWED_EXTENSIONS = {"png", "jpg", "jpeg"}
+
+# Default processing parameters
+DEFAULT_SAT_FACTOR = 3.0
+DEFAULT_GAP_SIZE = 1
+DEFAULT_NOISE_THRESHOLD = 100
+DEFAULT_TOTAL_DURATION = 400
+DEFAULT_CROP_OPTION = True
+DEFAULT_MODEL_NAME = "gemini-2.0-flash"
+
+
+def allowed_file(filename):
+    """Check if file extension is allowed"""
+    return "." in filename and filename.rsplit(".", 1)[1].lower() in ALLOWED_EXTENSIONS
+
+
+def safe_parse_llm_json(llm_response):
+    """Robustly extracts JSON from LLM response, handling markdown and plain text."""
+    try:
+        # Try finding markdown block first
+        json_match = re.search(r"```json\s*(\{.*?\})\s*```", llm_response, re.DOTALL)
+        if json_match:
+            return json.loads(json_match.group(1))
+
+        # Try finding just a JSON object structure
+        json_match_loose = re.search(r"(\{.*\})", llm_response, re.DOTALL)
+        if json_match_loose:
+            return json.loads(json_match_loose.group(1))
+
+        # Try loading the whole string
+        return json.loads(llm_response)
+    except:
+        return None
+
+
+def convert_numpy_types(obj):
+    """Convert numpy types to Python native types for JSON serialization"""
+    if isinstance(obj, dict):
+        return {key: convert_numpy_types(value) for key, value in obj.items()}
+    elif isinstance(obj, list):
+        return [convert_numpy_types(item) for item in obj]
+    elif isinstance(obj, np.integer):
+        return int(obj)
+    elif isinstance(obj, np.floating):
+        return float(obj)
+    elif isinstance(obj, np.ndarray):
+        return obj.tolist()
+    elif hasattr(obj, "item"):  # For numpy scalar types
+        return obj.item()
+    else:
+        return obj
+
+
+def image_to_base64(img_array):
+    """Convert a numpy image array to base64 string"""
+    if img_array is None:
+        return None
+    # Ensure it's in BGR format for encoding
+    if len(img_array.shape) == 3 and img_array.shape[2] == 3:
+        # Convert RGB to BGR if needed (OpenCV expects BGR)
+        img_bgr = cv2.cvtColor(img_array, cv2.COLOR_RGB2BGR)
+    else:
+        img_bgr = img_array
+
+    _, buffer = cv2.imencode(".png", img_bgr)
+    return base64.b64encode(buffer).decode("utf-8")
+
+
+@app.route("/health", methods=["GET"])
+def health_check():
+    """Health check endpoint"""
+    return jsonify({"status": "healthy", "service": "DCRM Analysis API"})
+
+
+@app.route("/analyze", methods=["POST"])
+def analyze_image():
+    """
+    Main endpoint for DCRM image analysis.
+
+    Expects:
+        - image: File upload (multipart/form-data) or base64 encoded image
+        - api_key: Gemini API key (required)
+        - sat_factor: Saturation boost factor (optional, default: 3.0)
+        - gap_size: Gap fill size (optional, default: 1)
+        - noise_threshold: Minimum object area (optional, default: 100)
+        - total_duration: Graph duration in ms (optional, default: 400)
+        - crop_option: Auto-crop option (optional, default: true)
+        - analysis_method: "image" or "csv" (optional, default: "image")
+
+    Returns:
+        JSON response with analysis results
+    """
+    try:
+        # Get API key
+        api_key = (
+            request.form.get("api_key") or request.json.get("api_key")
+            if request.is_json
+            else request.form.get("api_key")
+        )
+
+        if not api_key:
+            # Try to get from environment
+            api_key = os.environ.get("GEMINI_API_KEY") or os.environ.get(
+                "GOOGLE_API_KEY"
+            )
+
+        if not api_key:
+            return (
+                jsonify(
+                    {
+                        "error": "API key is required. Provide 'api_key' in the request or set GEMINI_API_KEY environment variable."
+                    }
+                ),
+                400,
+            )
+
+        # Get image data
+        file_bytes = None
+
+        # Check for file upload
+        if "image" in request.files:
+            file = request.files["image"]
+            if file.filename == "":
+                return jsonify({"error": "No file selected"}), 400
+            if not allowed_file(file.filename):
+                return (
+                    jsonify(
+                        {
+                            "error": f"Invalid file type. Allowed: {', '.join(ALLOWED_EXTENSIONS)}"
+                        }
+                    ),
+                    400,
+                )
+            file_bytes = file.read()
+
+        # Check for base64 image
+        elif request.is_json and "image_base64" in request.json:
+            try:
+                file_bytes = base64.b64decode(request.json["image_base64"])
+            except Exception as e:
+                return jsonify({"error": f"Invalid base64 image: {str(e)}"}), 400
+
+        else:
+            return (
+                jsonify(
+                    {
+                        "error": "No image provided. Use 'image' file upload or 'image_base64' in JSON."
+                    }
+                ),
+                400,
+            )
+
+        # Get processing parameters
+        if request.is_json:
+            params = request.json
+        else:
+            params = request.form
+
+        sat_factor = float(params.get("sat_factor", DEFAULT_SAT_FACTOR))
+        gap_size = int(params.get("gap_size", DEFAULT_GAP_SIZE))
+        noise_threshold = int(params.get("noise_threshold", DEFAULT_NOISE_THRESHOLD))
+        total_duration = int(params.get("total_duration", DEFAULT_TOTAL_DURATION))
+        crop_option = str(params.get("crop_option", "true")).lower() == "true"
+        analysis_method = params.get("analysis_method", "image")
+        model_name = params.get("model_name", DEFAULT_MODEL_NAME)
+        include_debug_images = (
+            str(params.get("include_debug_images", "false")).lower() == "true"
+        )
+
+        # Step 1: Extract curves from image
+        df_result, debug_images, bounds, error_msg, _ = process_uploaded_image(
+            file_bytes,
+            sat_factor,
+            gap_size,
+            noise_threshold,
+            crop_option,
+            total_duration,
+        )
+
+        if error_msg:
+            return (
+                jsonify(
+                    {
+                        "error": f"Curve extraction failed: {error_msg}",
+                        "stage": "extraction",
+                    }
+                ),
+                400,
+            )
+
+        # Step 2: Get LLM segmentation
+        cropped_bytes = None
+        if bounds:
+            try:
+                sx, ex = bounds
+                nparr = np.frombuffer(file_bytes, np.uint8)
+                img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
+                if img is not None:
+                    cropped_img = img[:, sx:ex]
+                    is_success, buffer = cv2.imencode(".jpg", cropped_img)
+                    if is_success:
+                        cropped_bytes = buffer.tobytes()
+            except Exception as e:
+                pass  # Continue without cropped image
+
+        df_result, result_json = ask_llm_for_breakage(
+            df_result, api_key, model_name, image_bytes=cropped_bytes
+        )
+
+        if not result_json or "error" in result_json:
+            return (
+                jsonify(
+                    {
+                        "error": "AI segmentation failed",
+                        "details": (
+                            result_json.get("error") if result_json else "Unknown error"
+                        ),
+                        "stage": "segmentation",
+                    }
+                ),
+                400,
+            )
+
+        # Step 3: Perform zone health analysis
+        zone_analysis = {}
+        analysis_type = ""
+        analysis_data = None
+        executive_lead = None
+        issues = []
+
+        success_expert_image = False
+
+        if analysis_method.lower() == "image":
+            # Image-based analysis
+            numerical_context = {}
+            if "Resistance" in df_result.columns:
+                valid_res = df_result["Resistance"].dropna()
+                if not valid_res.empty:
+                    numerical_context["min_resistance"] = float(valid_res.min())
+                    numerical_context["median_resistance"] = float(valid_res.median())
+
+            img_bytes_for_analysis = cropped_bytes if cropped_bytes else file_bytes
+            llm_response = analyze_health_with_llm(
+                img_bytes_for_analysis, api_key, model_name, numerical_context
+            )
+
+            if isinstance(llm_response, dict) and "error" in llm_response:
+                analysis_type = "Image-Based (Failed) - Fallback to CSV"
+                success_expert_image = False
+            else:
+                analysis_data = safe_parse_llm_json(llm_response)
+
+                if analysis_data:
+                    executive_lead = llm_response.split("{")[0].strip()
+                    if "```json" in executive_lead:
+                        executive_lead = executive_lead.replace("```json", "").strip()
+
+                    issues = analysis_data.get("detected_issues", [])
+
+                    extracted_score = analysis_data.get("health_score")
+                    status = analysis_data.get("overall_condition", "Unknown")
+
+                    if extracted_score is None:
+                        if status == "Healthy":
+                            extracted_score = 100
+                        elif status == "Warning":
+                            extracted_score = 60
+                        elif status == "Critical":
+                            extracted_score = 20
+                        else:
+                            extracted_score = 0
+
+                    zone_analysis = {
+                        "overall_health": {
+                            "status": status,
+                            "overall_score": extracted_score,
+                            "recommendation": analysis_data.get(
+                                "maintenance_recommendation"
+                            ),
+                            "total_issues": len(issues),
+                            "critical_issues": [],
+                        }
+                    }
+                    analysis_type = "Expert Image Diagnostic"
+                    success_expert_image = True
+                else:
+                    analysis_type = "Image-Based (Parse Error) - Fallback to CSV"
+                    success_expert_image = False
+
+        # Fallback to CSV analysis
+        if not success_expert_image:
+            analyzer = ZoneAnalyzer(df_result, result_json)
+            zone_analysis = analyzer.analyze_all_zones()
+            analysis_type = "CSV-Based"
+
+        # Prepare response
+        response_data = {
+            "success": True,
+            "analysis_type": analysis_type,
+            "segmentation": convert_numpy_types(result_json),
+            "zone_analysis": convert_numpy_types(zone_analysis),
+            "curve_data": {
+                "columns": df_result.columns.tolist(),
+                "data": df_result.to_dict(orient="records"),
+                "num_points": len(df_result),
+            },
+            "processing_params": {
+                "sat_factor": sat_factor,
+                "gap_size": gap_size,
+                "noise_threshold": noise_threshold,
+                "total_duration": total_duration,
+                "crop_option": crop_option,
+            },
+        }
+
+        # Add expert analysis details if available
+        if analysis_data:
+            response_data["expert_analysis"] = {
+                "executive_summary": executive_lead,
+                "detailed_analysis": convert_numpy_types(analysis_data),
+                "issues": convert_numpy_types(issues),
+            }
+
+        # Include debug images if requested
+        if include_debug_images and debug_images:
+            response_data["debug_images"] = {}
+            for name, img in debug_images.items():
+                img_b64 = image_to_base64(img)
+                if img_b64:
+                    response_data["debug_images"][name] = img_b64
+
+        return jsonify(convert_numpy_types(response_data))
+
+    except Exception as e:
+        import traceback
+
+        return (
+            jsonify(
+                {
+                    "error": f"Internal server error: {str(e)}",
+                    "traceback": traceback.format_exc(),
+                }
+            ),
+            500,
+        )
+
+
+@app.route("/extract-curves", methods=["POST"])
+def extract_curves():
+    """
+    Lightweight endpoint that only extracts curves without LLM analysis.
+    Useful for quick data extraction without AI processing.
+
+    Expects:
+        - image: File upload (multipart/form-data) or base64 encoded image
+        - sat_factor, gap_size, noise_threshold, total_duration, crop_option (optional)
+
+    Returns:
+        JSON with extracted curve data
+    """
+    try:
+        # Get image data
+        file_bytes = None
+
+        if "image" in request.files:
+            file = request.files["image"]
+            if file.filename == "":
+                return jsonify({"error": "No file selected"}), 400
+            if not allowed_file(file.filename):
+                return (
+                    jsonify(
+                        {
+                            "error": f"Invalid file type. Allowed: {', '.join(ALLOWED_EXTENSIONS)}"
+                        }
+                    ),
+                    400,
+                )
+            file_bytes = file.read()
+
+        elif request.is_json and "image_base64" in request.json:
+            try:
+                file_bytes = base64.b64decode(request.json["image_base64"])
+            except Exception as e:
+                return jsonify({"error": f"Invalid base64 image: {str(e)}"}), 400
+
+        else:
+            return jsonify({"error": "No image provided"}), 400
+
+        # Get processing parameters
+        if request.is_json:
+            params = request.json
+        else:
+            params = request.form
+
+        sat_factor = float(params.get("sat_factor", DEFAULT_SAT_FACTOR))
+        gap_size = int(params.get("gap_size", DEFAULT_GAP_SIZE))
+        noise_threshold = int(params.get("noise_threshold", DEFAULT_NOISE_THRESHOLD))
+        total_duration = int(params.get("total_duration", DEFAULT_TOTAL_DURATION))
+        crop_option = str(params.get("crop_option", "true")).lower() == "true"
+        include_debug_images = (
+            str(params.get("include_debug_images", "false")).lower() == "true"
+        )
+
+        # Extract curves
+        df_result, debug_images, bounds, error_msg, _ = process_uploaded_image(
+            file_bytes,
+            sat_factor,
+            gap_size,
+            noise_threshold,
+            crop_option,
+            total_duration,
+        )
+
+        if error_msg:
+            return jsonify({"error": f"Curve extraction failed: {error_msg}"}), 400
+
+        response_data = {
+            "success": True,
+            "curve_data": {
+                "columns": df_result.columns.tolist(),
+                "data": df_result.to_dict(orient="records"),
+                "num_points": len(df_result),
+            },
+            "bounds": bounds,
+            "processing_params": {
+                "sat_factor": sat_factor,
+                "gap_size": gap_size,
+                "noise_threshold": noise_threshold,
+                "total_duration": total_duration,
+                "crop_option": crop_option,
+            },
+        }
+
+        if include_debug_images and debug_images:
+            response_data["debug_images"] = {}
+            for name, img in debug_images.items():
+                img_b64 = image_to_base64(img)
+                if img_b64:
+                    response_data["debug_images"][name] = img_b64
+
+        return jsonify(convert_numpy_types(response_data))
+
+    except Exception as e:
+        import traceback
+
+        return (
+            jsonify(
+                {
+                    "error": f"Internal server error: {str(e)}",
+                    "traceback": traceback.format_exc(),
+                }
+            ),
+            500,
+        )
+
+
+@app.errorhandler(413)
+def too_large(e):
+    return jsonify({"error": "File too large. Maximum size is 16MB."}), 413
+
+
+@app.errorhandler(404)
+def not_found(e):
+    return jsonify({"error": "Endpoint not found"}), 404
+
+
+@app.errorhandler(500)
+def internal_error(e):
+    return jsonify({"error": "Internal server error"}), 500
+
+
+if __name__ == "__main__":
+    # Get port from environment or use default (7860 for Hugging Face Spaces)
+    port = int(os.environ.get("PORT", 7860))
+    debug = os.environ.get("FLASK_DEBUG", "false").lower() == "true"
+
+    print(
+        f"""
+    ╔══════════════════════════════════════════════════════════════╗
+    ║          DCRM Analysis API - Flask Server                    ║
+    ╠══════════════════════════════════════════════════════════════╣
+    ║  Endpoints:                                                  ║
+    ║    GET  /health         - Health check                       ║
+    ║    POST /analyze        - Full DCRM analysis with AI         ║
+    ║    POST /extract-curves - Extract curves only (no AI)        ║
+    ╚══════════════════════════════════════════════════════════════╝
+    """
+    )
+
+    app.run(host="0.0.0.0", port=port, debug=debug)

requirements.txt

@@ -0,0 +1,18 @@
+# Core
+flask>=3.0.0
+flask-cors>=4.0.0
+
+# Image Processing
+opencv-python-headless>=4.8.0
+numpy>=1.24.0
+pandas>=2.0.0
+Pillow>=10.0.0
+
+# Google Generative AI (Gemini)
+google-generativeai>=0.3.0
+
+# Plotting
+plotly>=5.17.0
+
+# Utilities
+python-dotenv>=1.0.0