Add Image Color Classifier Gradio app

.gitignore

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

api.py

@@ -0,0 +1,117 @@
+# api.py
+import cv2 as cv
+import numpy as np
+import json
+from collections import Counter
+from typing import List
+
+from fastapi import FastAPI, File, UploadFile, Query, HTTPException
+from pydantic import BaseModel
+
+# --- Initialize FastAPI App ---
+app = FastAPI(
+    title="Image Color Classifier API",
+    description="Upload an image to classify it as 'rust', 'zinc', or 'normal' based on color heuristics."
+)
+
+# --- Define the Response Model (for OpenAPI docs and validation) ---
+class ClassificationResponse(BaseModel):
+    filename: str
+    classification: str
+    rustish_ratio: float
+    zincish_ratio: float
+    top_colors_rgb: List[List[int]]
+    top_colors_share: List[float]
+
+
+# --- Helper Functions (Copied from your main.py) ---
+
+# Color space conversions
+def bgr_to_rgb(bgr): return cv.cvtColor(bgr, cv.COLOR_BGR2RGB)
+def bgr_to_hsv(bgr): return cv.cvtColor(bgr, cv.COLOR_BGR2HSV)
+def bgr_to_lab(bgr): return cv.cvtColor(bgr, cv.COLOR_BGR2LAB)
+
+# Dominant color extraction using KMeans
+def dominant_colors_kmeans(bgr, k=3, max_iter=10):
+    data = bgr.reshape((-1, 3)).astype(np.float32)
+    criteria = (cv.TERM_CRITERIA_EPS + cv.TERM_CRITERIA_MAX_ITER, max_iter, 1.0)
+    flags = cv.KMEANS_PP_CENTERS
+    _, labels, centers = cv.kmeans(data, k, None, criteria, 3, flags)
+    centers_u8 = np.clip(centers, 0, 255).astype(np.uint8)
+    counts = Counter(labels.flatten())
+    total = float(len(labels))
+
+    idx_sorted = [i for i, _ in counts.most_common()]
+    palette = []
+    for idx in idx_sorted:
+        bgr_c = centers_u8[idx].tolist()
+        rgb_c = bgr_to_rgb(np.array([[bgr_c]], dtype=np.uint8)).reshape(-1).tolist()
+        share = counts[idx] / total
+        palette.append({"share": float(share), "RGB": [int(x) for x in rgb_c]})
+    return palette
+
+# Heuristic calculation for rust/zinc
+def rust_zinc_indicators(bgr, delta=6.0):
+    lab = bgr_to_lab(bgr)
+    _, a, b = cv.split(lab)
+    a_med, b_med = np.median(a), np.median(b)
+    a_thr = a_med + delta
+    b_thr = b_med + delta
+
+    rustish = (a.astype(np.float32) > a_thr).mean()
+    zincish = (b.astype(np.float32) > b_thr).mean()
+    return {"rustish_ratio": float(rustish), "zincish_ratio": float(zincish)}
+
+# Classification logic
+def classify_from_ratios(rustish_ratio, zincish_ratio, rust_thr=0.01, zinc_thr=0.02):
+    if zincish_ratio > zinc_thr:
+        return "zinc"
+    elif rustish_ratio > rust_thr:
+        return "rust"
+    else:
+        return "normal"
+
+# --- API Endpoint ---
+
+@app.post("/classify/", response_model=ClassificationResponse)
+async def classify_image(
+    file: UploadFile = File(..., description="The image file to classify."),
+    k: int = Query(3, description="Number of dominant colors to extract."),
+    rust_thr: float = Query(0.01, description="Threshold for 'rust' classification."),
+    zinc_thr: float = Query(0.02, description="Threshold for 'zinc' classification."),
+    lab_delta: float = Query(6.0, description="Sensitivity for heuristic indicators in Lab color space.")
+):
+    """
+    Accepts an image file and returns a classification based on color analysis.
+    """
+    # 1. Read image bytes from upload
+    contents = await file.read()
+    
+    # 2. Convert bytes to a NumPy array and then to an OpenCV image
+    nparr = np.frombuffer(contents, np.uint8)
+    bgr = cv.imdecode(nparr, cv.IMREAD_COLOR)
+
+    if bgr is None:
+        raise HTTPException(status_code=400, detail="Invalid image file. Could not decode image.")
+
+    # 3. Perform color analysis and classification
+    indicators = rust_zinc_indicators(bgr, delta=lab_delta)
+    classification = classify_from_ratios(
+        rustish_ratio=indicators["rustish_ratio"],
+        zincish_ratio=indicators["zincish_ratio"],
+        rust_thr=rust_thr,
+        zinc_thr=zinc_thr
+    )
+    palette = dominant_colors_kmeans(bgr, k=max(1, k))
+
+    # 4. Format the response
+    response_data = {
+        "filename": file.filename,
+        "classification": classification,
+        "rustish_ratio": round(indicators["rustish_ratio"], 4),
+        "zincish_ratio": round(indicators["zincish_ratio"], 4),
+        "top_colors_rgb": [p["RGB"] for p in palette],
+        "top_colors_share": [round(p["share"], 4) for p in palette]
+    }
+
+    return response_data

app.py

@@ -0,0 +1,112 @@
+# gradio_app.py
+import cv2 as cv
+import numpy as np
+from collections import Counter
+from typing import List, Dict, Any
+import gradio as gr
+
+# --- Helper Functions ---
+
+# Color space conversions
+def bgr_to_rgb(bgr): 
+    return cv.cvtColor(bgr, cv.COLOR_BGR2RGB)
+
+def bgr_to_lab(bgr): 
+    return cv.cvtColor(bgr, cv.COLOR_BGR2LAB)
+
+# Dominant color extraction using KMeans
+def dominant_colors_kmeans(bgr, k=3, max_iter=10):
+    data = bgr.reshape((-1, 3)).astype(np.float32)
+    criteria = (cv.TERM_CRITERIA_EPS + cv.TERM_CRITERIA_MAX_ITER, max_iter, 1.0)
+    flags = cv.KMEANS_PP_CENTERS
+    _, labels, centers = cv.kmeans(data, k, None, criteria, 3, flags)
+    centers_u8 = np.clip(centers, 0, 255).astype(np.uint8)
+    counts = Counter(labels.flatten())
+    total = float(len(labels))
+
+    idx_sorted = [i for i, _ in counts.most_common()]
+    palette = []
+    for idx in idx_sorted:
+        bgr_c = centers_u8[idx].tolist()
+        rgb_c = bgr_to_rgb(np.array([[bgr_c]], dtype=np.uint8)).reshape(-1).tolist()
+        share = counts[idx] / total
+        palette.append({"share": float(share), "RGB": [int(x) for x in rgb_c]})
+    return palette
+
+# Heuristic calculation for rust/zinc
+def rust_zinc_indicators(bgr, delta=6.0):
+    lab = bgr_to_lab(bgr)
+    _, a, b = cv.split(lab)
+    a_med, b_med = np.median(a), np.median(b)
+    a_thr = a_med + delta
+    b_thr = b_med + delta
+
+    rustish = (a.astype(np.float32) > a_thr).mean()
+    zincish = (b.astype(np.float32) > b_thr).mean()
+    return {"rustish_ratio": float(rustish), "zincish_ratio": float(zincish)}
+
+# Classification logic
+def classify_from_ratios(rustish_ratio, zincish_ratio, rust_thr=0.01, zinc_thr=0.02):
+    if zincish_ratio > zinc_thr:
+        return "zinc"
+    elif rustish_ratio > rust_thr:
+        return "rust"
+    else:
+        return "normal"
+
+# --- Gradio Prediction Function ---
+def classify_image_gradio(
+    image: np.ndarray,
+    k: int = 3,
+    rust_thr: float = 0.01,
+    zinc_thr: float = 0.02,
+    lab_delta: float = 6.0
+) -> Dict[str, Any]:
+    """
+    Accepts an image (from Gradio upload) and returns classification and color analysis.
+    """
+    if image is None:
+        return {"error": "No image provided."}
+
+    # Convert RGB (from Gradio) to BGR for OpenCV
+    bgr = cv.cvtColor(image, cv.COLOR_RGB2BGR)
+
+    # Color analysis
+    indicators = rust_zinc_indicators(bgr, delta=lab_delta)
+    classification = classify_from_ratios(
+        rustish_ratio=indicators["rustish_ratio"],
+        zincish_ratio=indicators["zincish_ratio"],
+        rust_thr=rust_thr,
+        zinc_thr=zinc_thr
+    )
+    palette = dominant_colors_kmeans(bgr, k=max(1, k))
+
+    # Format response
+    response_data = {
+        "classification": classification,
+        "rustish_ratio": round(indicators["rustish_ratio"], 4),
+        "zincish_ratio": round(indicators["zincish_ratio"], 4),
+        "top_colors_rgb": [p["RGB"] for p in palette],
+        "top_colors_share": [round(p["share"], 4) for p in palette]
+    }
+
+    return response_data
+
+# --- Gradio Interface ---
+iface = gr.Interface(
+    fn=classify_image_gradio,
+    inputs=[
+        gr.Image(type="numpy", label="Upload Image"),
+        gr.Slider(1, 10, value=3, label="Number of Dominant Colors (k)"),
+        gr.Slider(0.0, 1.0, value=0.01, step=0.01, label="Rust Threshold"),
+        gr.Slider(0.0, 1.0, value=0.02, step=0.01, label="Zinc Threshold"),
+        gr.Slider(0.0, 20.0, value=6.0, step=0.5, label="Lab Delta")
+    ],
+    outputs=gr.JSON(label="Classification Result"),
+    title="Image Color Classifier",
+    description="Upload an image and classify it as 'rust', 'zinc', or 'normal' based on color heuristics."
+)
+
+# Launch Gradio app
+if __name__ == "__main__":
+    iface.launch()

classify.py

@@ -0,0 +1,33 @@
+import json, argparse
+
+def classify_from_ratios(rustish_ratio, zincish_ratio, rust_thr=0.01, zinc_thr=0.02):
+    if zincish_ratio > zinc_thr:
+        return "zinc"
+    elif rustish_ratio > rust_thr:
+        return "rust"
+    else:
+        return "normal"
+
+if __name__ == "__main__":
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--report", required=True, help="path to *_color_report.json from color.py")
+    ap.add_argument("--rust_thr", type=float, default=0.01)
+    ap.add_argument("--zinc_thr", type=float, default=0.02)
+    args = ap.parse_args()
+
+    with open(args.report, "r") as f:
+        rep = json.load(f)
+
+    rustish_ratio = rep["heuristics"]["rustish_ratio"]
+    zincish_ratio = rep["heuristics"]["zincish_ratio"]
+
+    classification = classify_from_ratios(rustish_ratio, zincish_ratio,
+                                          rust_thr=args.rust_thr,
+                                          zinc_thr=args.zinc_thr)
+
+    print({
+        "file": rep["input"],
+        "rustish_ratio": rustish_ratio,
+        "zincish_ratio": zincish_ratio,
+        "classification": classification
+    })

color.py

@@ -0,0 +1,156 @@
+import cv2 as cv
+import numpy as np
+import argparse, os, json
+from collections import Counter
+
+def bgr_to_rgb(bgr): return cv.cvtColor(bgr, cv.COLOR_BGR2RGB)
+def bgr_to_hsv(bgr): return cv.cvtColor(bgr, cv.COLOR_BGR2HSV)
+def bgr_to_lab(bgr): return cv.cvtColor(bgr, cv.COLOR_BGR2LAB)
+
+def img_stats(img, space_name):
+    # img is uint8, shape HxWxC
+    means = img.reshape(-1, img.shape[2]).mean(axis=0)
+    stds  = img.reshape(-1, img.shape[2]).std(axis=0)
+    return {
+        "space": space_name,
+        "mean": [float(x) for x in means],
+        "std":  [float(x) for x in stds]
+    }
+
+def dominant_colors_kmeans(bgr, k=3, max_iter=10, seed=123):
+    # reshape to N x 3
+    data = bgr.reshape((-1, 3)).astype(np.float32)
+
+    # kmeans
+    criteria = (cv.TERM_CRITERIA_EPS + cv.TERM_CRITERIA_MAX_ITER, max_iter, 1.0)
+    flags = cv.KMEANS_PP_CENTERS
+    compactness, labels, centers = cv.kmeans(data, k, None, criteria, 3, flags)
+
+    # centers are BGR float; convert to uint8
+    centers_u8 = np.clip(centers, 0, 255).astype(np.uint8)
+    counts = Counter(labels.flatten())
+    total = float(len(labels))
+
+    # sort by frequency desc
+    idx_sorted = [i for i,_ in counts.most_common()]
+    palette = []
+    for idx in idx_sorted:
+        bgr_c = centers_u8[idx].tolist()
+        rgb_c = bgr_to_rgb(np.array([[bgr_c]], dtype=np.uint8)).reshape(-1).tolist()
+        hsv_c = bgr_to_hsv(np.array([[bgr_c]], dtype=np.uint8)).reshape(-1).tolist()
+        lab_c = bgr_to_lab(np.array([[bgr_c]], dtype=np.uint8)).reshape(-1).tolist()
+        share = counts[idx] / total
+        palette.append({
+            "share": float(share),
+            "BGR": [int(x) for x in bgr_c],
+            "RGB": [int(x) for x in rgb_c],
+            "HSV": [int(x) for x in hsv_c],
+            "Lab": [int(x) for x in lab_c],
+        })
+    return palette
+
+def make_palette_image(palette, width=600, height=80, pad=2):
+    # palette: list of dicts with 'share' and 'RGB'
+    img = np.zeros((height, width, 3), dtype=np.uint8)
+    x = 0
+    for p in palette:
+        w = max(1, int(p["share"] * width))
+        color = tuple(p["RGB"])  # RGB
+        # convert to BGR for OpenCV drawing
+        bgr = (int(color[2]), int(color[1]), int(color[0]))
+        cv.rectangle(img, (x, 0), (min(width-1, x+w-1), height-1), bgr, -1)
+        x += w
+    # thin separators
+    for i in range(1, len(palette)):
+        x_sep = int(sum([pp["share"] for pp in palette[:i]]) * width)
+        cv.line(img, (x_sep, 0), (x_sep, height-1), (30,30,30), 1)
+    return img
+
+def rust_zinc_indicators(bgr):
+    """Heuristic only, NO detection claims. Gives ratios based on Lab chroma tendencies:
+       - 'rustish_ratio': fraction of pixels with a* significantly above median (reddish/brownish)
+       - 'zincish_ratio': fraction of pixels with b* significantly above median (yellowish)
+    """
+    lab = bgr_to_lab(bgr)
+    L, a, b = cv.split(lab)
+    a_med, b_med = np.median(a), np.median(b)
+    a_thr = a_med + 6  # tweak if needed
+    b_thr = b_med + 6
+
+    rustish = (a.astype(np.float32) > a_thr).mean()
+    zincish = (b.astype(np.float32) > b_thr).mean()
+    return {"rustish_ratio": float(rustish), "zincish_ratio": float(zincish),
+            "a_median": float(a_med), "b_median": float(b_med),
+            "a_thresh": float(a_thr), "b_thresh": float(b_thr)}
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--img", required=True, help="path to image")
+    ap.add_argument("--k", type=int, default=3, help="number of dominant colors")
+    ap.add_argument("--resize_max", type=int, default=1200, help="resize longer side to this (0=off)")
+    ap.add_argument("--outdir", default="color_out")
+    args = ap.parse_args()
+
+    os.makedirs(args.outdir, exist_ok=True)
+
+    bgr = cv.imread(args.img, cv.IMREAD_COLOR)
+    if bgr is None:
+        raise RuntimeError(f"Cannot read image: {args.img}")
+
+    # Optional resize to speed up
+    h, w = bgr.shape[:2]
+    if args.resize_max > 0:
+        s = max(h, w)
+        if s > args.resize_max:
+            scale = args.resize_max / float(s)
+            bgr = cv.resize(bgr, (int(w*scale), int(h*scale)), interpolation=cv.INTER_AREA)
+
+    # Color-space stats
+    rgb = bgr_to_rgb(bgr)
+    hsv = bgr_to_hsv(bgr)
+    lab = bgr_to_lab(bgr)
+
+    stats = [
+        img_stats(rgb, "RGB"),  # channels: R,G,B (0-255)
+        img_stats(hsv, "HSV"),  # channels: H(0-179), S(0-255), V(0-255) in OpenCV
+        img_stats(lab, "Lab"),  # channels: L(0-255), a(0-255), b(0-255) in OpenCV's scaled Lab
+    ]
+
+    # Dominant colors (k-means)
+    palette = dominant_colors_kmeans(bgr, k=max(1, args.k))
+
+    # Heuristic indicators (optional)
+    indicators = rust_zinc_indicators(bgr)
+
+    # Save palette image
+    pal_img = make_palette_image(palette)
+    base = os.path.splitext(os.path.basename(args.img))[0]
+    pal_path = os.path.join(args.outdir, f"{base}_palette.png")
+    cv.imwrite(pal_path, pal_img)
+
+    # Build and save JSON
+    report = {
+        "input": os.path.basename(args.img),
+        "size_hw": [int(bgr.shape[0]), int(bgr.shape[1])],
+        "color_stats": stats,
+        "dominant_colors": palette,  # ordered by share desc
+        "heuristics": indicators,
+        "palette_image": pal_path
+    }
+    rep_path = os.path.join(args.outdir, f"{base}_color_report.json")
+    with open(rep_path, "w") as f:
+        json.dump(report, f, indent=2)
+
+    # Print a short summary to console
+    print(json.dumps({
+        "input": report["input"],
+        "top_colors_rgb": [p["RGB"] for p in report["dominant_colors"]],
+        "top_colors_share": [round(p["share"], 4) for p in report["dominant_colors"]],
+        "rustish_ratio": round(report["heuristics"]["rustish_ratio"], 4),
+        "zincish_ratio": round(report["heuristics"]["zincish_ratio"], 4),
+        "report_path": rep_path,
+        "palette_image": pal_path
+    }, indent=2))
+
+if __name__ == "__main__":
+    main()

main.py

@@ -0,0 +1,190 @@
+import cv2 as cv
+import numpy as np
+import argparse, os, json
+from collections import Counter
+
+# ---------------- Conversions ----------------
+def bgr_to_rgb(bgr): return cv.cvtColor(bgr, cv.COLOR_BGR2RGB)
+def bgr_to_hsv(bgr): return cv.cvtColor(bgr, cv.COLOR_BGR2HSV)
+def bgr_to_lab(bgr): return cv.cvtColor(bgr, cv.COLOR_BGR2LAB)
+
+# ---------------- Stats ----------------
+def img_stats(img, space_name):
+    # img is uint8, shape HxWxC
+    means = img.reshape(-1, img.shape[2]).mean(axis=0)
+    stds  = img.reshape(-1, img.shape[2]).std(axis=0)
+    return {
+        "space": space_name,
+        "mean": [float(x) for x in means],
+        "std":  [float(x) for x in stds]
+    }
+
+# ---------------- Dominant colors ----------------
+def dominant_colors_kmeans(bgr, k=3, max_iter=10):
+    data = bgr.reshape((-1, 3)).astype(np.float32)
+    criteria = (cv.TERM_CRITERIA_EPS + cv.TERM_CRITERIA_MAX_ITER, max_iter, 1.0)
+    flags = cv.KMEANS_PP_CENTERS
+    compactness, labels, centers = cv.kmeans(data, k, None, criteria, 3, flags)
+    centers_u8 = np.clip(centers, 0, 255).astype(np.uint8)
+    counts = Counter(labels.flatten())
+    total = float(len(labels))
+
+    idx_sorted = [i for i,_ in counts.most_common()]
+    palette = []
+    for idx in idx_sorted:
+        bgr_c = centers_u8[idx].tolist()
+        rgb_c = bgr_to_rgb(np.array([[bgr_c]], dtype=np.uint8)).reshape(-1).tolist()
+        hsv_c = bgr_to_hsv(np.array([[bgr_c]], dtype=np.uint8)).reshape(-1).tolist()
+        lab_c = bgr_to_lab(np.array([[bgr_c]], dtype=np.uint8)).reshape(-1).tolist()
+        share = counts[idx] / total
+        palette.append({
+            "share": float(share),
+            "BGR": [int(x) for x in bgr_c],
+            "RGB": [int(x) for x in rgb_c],
+            "HSV": [int(x) for x in hsv_c],
+            "Lab": [int(x) for x in lab_c],
+        })
+    return palette
+
+def make_palette_image(palette, width=600, height=80):
+    img = np.zeros((height, width, 3), dtype=np.uint8)
+    x = 0
+    for p in palette:
+        w = max(1, int(p["share"] * width))
+        r,g,b = p["RGB"]  # stored as RGB
+        cv.rectangle(img, (x, 0), (min(width-1, x+w-1), height-1), (b,g,r), -1)  # convert to BGR for draw
+        x += w
+    for i in range(1, len(palette)):
+        x_sep = int(sum([pp["share"] for pp in palette[:i]]) * width)
+        cv.line(img, (x_sep, 0), (x_sep, height-1), (30,30,30), 1)
+    return img
+
+# ---------------- Heuristics ----------------
+def rust_zinc_indicators(bgr, delta=6):
+    """
+    Heuristic only. Uses Lab:
+    - rustish_ratio: fraction of pixels with a* > median(a*) + delta
+    - zincish_ratio: fraction of pixels with b* > median(b*) + delta
+    """
+    lab = bgr_to_lab(bgr)
+    L, a, b = cv.split(lab)
+    a_med, b_med = np.median(a), np.median(b)
+    a_thr = a_med + delta
+    b_thr = b_med + delta
+
+    rustish = (a.astype(np.float32) > a_thr).mean()
+    zincish = (b.astype(np.float32) > b_thr).mean()
+    return {
+        "rustish_ratio": float(rustish),
+        "zincish_ratio": float(zincish),
+        "a_median": float(a_med),
+        "b_median": float(b_med),
+        "a_thresh": float(a_thr),
+        "b_thresh": float(b_thr),
+        "delta": float(delta)
+    }
+
+# ---------------- Classification ----------------
+def classify_from_ratios(rustish_ratio, zincish_ratio, rust_thr=0.002, zinc_thr=0.01):
+    """
+    Your rule:
+    - zinc if zincish_ratio > 0.01
+    - else rust if rustish_ratio > 0.002
+    - else normal
+    """
+    if zincish_ratio > zinc_thr:
+        return "zinc"
+    elif rustish_ratio > rust_thr:
+        return "rust"
+    else:
+        return "normal"
+
+# ---------------- Main ----------------
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--img", required=True, help="path to image")
+    ap.add_argument("--k", type=int, default=3, help="number of dominant colors")
+    ap.add_argument("--resize_max", type=int, default=1200, help="resize longer side to this (0=off)")
+    ap.add_argument("--outdir", default="color_out")
+    # thresholds you defined:
+    ap.add_argument("--rust_thr", type=float, default=0.01)
+    ap.add_argument("--zinc_thr", type=float, default=0.02)
+    # indicator sensitivity (Lab delta)
+    ap.add_argument("--lab_delta", type=float, default=6.0)
+    args = ap.parse_args()
+
+    os.makedirs(args.outdir, exist_ok=True)
+
+    bgr = cv.imread(args.img, cv.IMREAD_COLOR)
+    if bgr is None:
+        raise RuntimeError(f"Cannot read image: {args.img}")
+
+    # optional resize
+    h, w = bgr.shape[:2]
+    if args.resize_max > 0:
+        s = max(h, w)
+        if s > args.resize_max:
+            scale = args.resize_max / float(s)
+            bgr = cv.resize(bgr, (int(w*scale), int(h*scale)), interpolation=cv.INTER_AREA)
+
+    # color stats
+    rgb = bgr_to_rgb(bgr)
+    hsv = bgr_to_hsv(bgr)
+    lab = bgr_to_lab(bgr)
+    stats = [
+        img_stats(rgb, "RGB"),
+        img_stats(hsv, "HSV"),
+        img_stats(lab, "Lab"),
+    ]
+
+    # dominant colors
+    palette = dominant_colors_kmeans(bgr, k=max(1, args.k))
+
+    # heuristics
+    indicators = rust_zinc_indicators(bgr, delta=args.lab_delta)
+
+    # classification using your thresholds
+    cls = classify_from_ratios(
+        rustish_ratio=indicators["rustish_ratio"],
+        zincish_ratio=indicators["zincish_ratio"],
+        rust_thr=args.rust_thr,
+        zinc_thr=args.zinc_thr
+    )
+
+    # save palette image
+    base = os.path.splitext(os.path.basename(args.img))[0]
+    pal_img = make_palette_image(palette)
+    pal_path = os.path.join(args.outdir, f"{base}_palette.png")
+    cv.imwrite(pal_path, pal_img)
+
+    # build + save JSON
+    report = {
+        "input": os.path.basename(args.img),
+        "size_hw": [int(bgr.shape[0]), int(bgr.shape[1])],
+        "color_stats": stats,
+        "dominant_colors": palette,    # ordered by share desc
+        "heuristics": indicators,
+        "classification": cls,
+        "thresholds": {"rust_thr": args.rust_thr, "zinc_thr": args.zinc_thr},
+        "palette_image": pal_path
+    }
+    rep_path = os.path.join(args.outdir, f"{base}_color_report.json")
+    with open(rep_path, "w") as f:
+        json.dump(report, f, indent=2)
+
+    # console summary
+    print(json.dumps({
+        "input": report["input"],
+        "classification": cls,
+        "rustish_ratio": round(indicators["rustish_ratio"], 4),
+        "zincish_ratio": round(indicators["zincish_ratio"], 4),
+        "top_colors_rgb": [p["RGB"] for p in palette],
+        "top_colors_share": [round(p["share"], 4) for p in palette],
+        "report_path": rep_path,
+        "palette_image": pal_path
+    }, indent=2))
+
+
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,4 @@
+"fastapi[all]" 
+opencv-python-headless 
+numpy
+gardio