image-to-code 0.1.0 → 0.1.1

package/bin/cli.js

@@ -1,46 +1,41 @@
 #!/usr/bin/env node
 /**
  * image-to-code — npm wrapper.
- * Auto-installs the Python package via pip on first run, then delegates.
+ * Bundles Python source. Installs pip deps on first run, then delegates.
  */
 const { execSync, spawn } = require("child_process");
 const path = require("path");
 
+const MODULE_DIR = path.resolve(__dirname, "..");
 const PYTHON_MODULE = "image_to_code";
-const REQUIRED_DEPS = ["Pillow>=10.0.0", "pytesseract>=0.3.10"];
 
 function checkPython() {
-  try {
-    execSync("python --version", { stdio: "pipe", timeout: 10000 });
-    return "python";
-  } catch {
+  for (const cmd of ["python", "python3"]) {
     try {
-      execSync("python3 --version", { stdio: "pipe", timeout: 10000 });
-      return "python3";
+      execSync(`${cmd} --version`, { stdio: "pipe", timeout: 10000 });
+      return cmd;
     } catch {
-      return null;
+      // try next
     }
   }
+  return null;
 }
 
-function checkPackage(python) {
+function ensurePipDeps(python) {
   try {
-    execSync(`${python} -c "import ${PYTHON_MODULE}"`, {
+    execSync(`${python} -c "import PIL; import pytesseract" 2>${process.platform === "win32" ? "nul" : "/dev/null"}`, {
       stdio: "pipe",
       timeout: 10000,
     });
-    return true;
+    return; // deps already installed
   } catch {
-    return false;
+    // install deps
   }
-}
-
-function installPackage(python) {
-  console.log("→ Installing image-to-code Python package...");
-  execSync(`${python} -m pip install ${PYTHON_MODULE} --upgrade`, {
-    stdio: "inherit",
-    timeout: 120000,
-  });
+  console.log("→ Installing Python dependencies (Pillow, pytesseract)...");
+  execSync(
+    `${python} -m pip install Pillow>=10.0.0 pytesseract>=0.3.10 --quiet`,
+    { stdio: "inherit", timeout: 120000 }
+  );
 }
 
 function main() {
@@ -52,13 +47,15 @@ function main() {
     process.exit(1);
   }
 
-  if (!checkPackage(python)) {
-    installPackage(python);
-  }
+  ensurePipDeps(python);
 
   const args = process.argv.slice(2);
   const child = spawn(python, ["-m", PYTHON_MODULE + ".analyze", ...args], {
     stdio: "inherit",
+    env: {
+      ...process.env,
+      PYTHONPATH: MODULE_DIR + (process.env.PYTHONPATH ? path.delimiter + process.env.PYTHONPATH : ""),
+    },
   });
   child.on("exit", (code) => process.exit(code));
 }

package/image_to_code/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

package/image_to_code/analyze.py

@@ -0,0 +1,224 @@
+"""Main orchestrator: runs color, layout, and OCR analysis, produces combined JSON/CSS report."""
+
+import argparse
+import json
+import sys
+import os
+import tempfile
+from PIL import Image, ImageGrab
+
+from .colors import extract_colors
+from .layout import detect_layout
+from .ocr import extract_text
+
+
+def analyze_image(image_path=None, clipboard=False, ocr_language="tha+eng",
+                  min_confidence=70, sample_count=2000, quantize_tolerance=15,
+                  full=False, json_output=False):
+    """Run full analysis pipeline on an image."""
+    resolved_path = image_path
+
+    if clipboard:
+        try:
+            clip_img = ImageGrab.grabclipboard()
+            if clip_img is None:
+                print("Error: No image found in clipboard", file=sys.stderr)
+                sys.exit(1)
+            temp_dir = os.path.join(tempfile.gettempdir(), "image-to-code")
+            os.makedirs(temp_dir, exist_ok=True)
+            save_path = os.path.join(temp_dir, f"clipboard_{os.urandom(4).hex()}.png")
+            clip_img.save(save_path)
+            resolved_path = save_path
+            print(f"\n[Clipboard image saved to: {save_path}]")
+        except Exception as e:
+            print(f"Error reading clipboard: {e}", file=sys.stderr)
+            sys.exit(1)
+
+    if not resolved_path or not os.path.exists(resolved_path):
+        print("Error: Image path does not exist", file=sys.stderr)
+        sys.exit(1)
+
+    print("Analyzing image...", file=sys.stderr)
+
+    colors = extract_colors(resolved_path, sample_count, quantize_tolerance)
+    is_photo = colors.get("isPhoto", False)
+
+    layout = detect_layout(resolved_path)
+    layout_type = layout.get("layoutType", "unknown")
+
+    ocr_result = extract_text(resolved_path, ocr_language, min_confidence)
+    ocr_boxes = ocr_result.get("boxes", [])
+    ocr_raw_text = ocr_result.get("rawText", "")
+    ocr_by_zone = ocr_result.get("byZone", {})
+
+    w = colors.get("imageWidth", 0)
+    h = colors.get("imageHeight", 0)
+    radius_val = "8px" if "mobile" in layout_type else "6px"
+    vp_val = "width=device-width, initial-scale=1.0" if w <= 430 else ""
+    mq_val = "mobile" if w <= 430 else ("tablet" if w <= 768 else "desktop")
+
+    # Button detection: large boxes in lower area
+    buttons = []
+    search_top = h * 0.25 if h else 0
+    for box in ocr_boxes:
+        if box.get("w", 0) > 30 and box.get("h", 0) > 20 and box.get("conf", 0) > 80 and box.get("y", 0) > search_top:
+            buttons.append({
+                "text": box.get("text", ""),
+                "x": box.get("x", 0),
+                "y": box.get("y", 0),
+                "w": box.get("w", 0),
+                "h": box.get("h", 0),
+                "zone": box.get("zone", ""),
+                "conf": box.get("conf", 0),
+            })
+
+    gradient_info = colors.get("gradient")
+    palette_data = colors.get("palette", [])
+    surface_list = colors.get("surfaces", [])
+    border_color = colors.get("border")
+
+    result = {
+        "imageType": "photo" if is_photo else "ui",
+        "image": {
+            "path": resolved_path,
+            "width": w,
+            "height": h,
+            "aspect": round(w / h, 3) if h else 0,
+        },
+        "colors": {
+            "background": colors.get("background", "#FFFFFF"),
+            "text": colors.get("text", "#1F2937"),
+            "accent": colors.get("button", "#4F46E5"),
+            "border": border_color if border_color else "#E5E7EB",
+            "palette": palette_data,
+            "surfaces": surface_list,
+            "button": colors.get("button"),
+            "textSecondary": colors.get("textSecondary"),
+            "contrastRatio": colors.get("contrastRatio", 0),
+            "harmony": colors.get("harmony", ""),
+            "gradient": gradient_info,
+        },
+        "layout": {
+            "type": layout_type,
+            "sections": layout.get("sections", []),
+            "columns": layout.get("columns", []),
+            "components": layout.get("components", []),
+        },
+        "text": {
+            "words": ocr_result.get("words", 0),
+            "boxes": ocr_boxes,
+            "buttons": buttons,
+            "fullText": ocr_raw_text,
+            "byZone": ocr_by_zone,
+        },
+        "css": {
+            "customProperties": {
+                "--bg": colors.get("background", "#FFFFFF"),
+                "--surface": surface_list[0] if surface_list else colors.get("background", "#FFFFFF"),
+                "--text": colors.get("text", "#1F2937"),
+                "--primary": colors.get("button", "#4F46E5"),
+                "--border": border_color if border_color else "#E5E7EB",
+                "--radius": radius_val,
+            },
+            "surfaces": surface_list,
+            "harmony": colors.get("harmony", ""),
+            "contrastRatio": colors.get("contrastRatio", 0),
+            "gradient": gradient_info,
+            "viewport": vp_val,
+            "mediaQuery": mq_val,
+        },
+    }
+
+    if json_output or full:
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+
+    if not json_output:
+        print()
+        print("=" * 72)
+        print("  IMAGE ANALYSIS REPORT")
+        print("=" * 72)
+        print()
+        print(f"Image: {w}x{h} ({layout_type}, {'photo' if is_photo else 'UI'})")
+        print()
+        print("--- Colors ---")
+        print(f"  Background: {colors.get('background', '')}")
+        print(f"  Surfaces:   {', '.join(str(s) for s in surface_list)}")
+        print(f"  Text:       {colors.get('text', '')}  (contrast: {colors.get('contrastRatio', 0)}:1)")
+        if colors.get("textSecondary"):
+            print(f"  Text(2nd):  {colors['textSecondary']}")
+        print(f"  Button:     {colors.get('button', '')}")
+        print(f"  Border:     {colors.get('border', '')}")
+        print(f"  Harmony:    {colors.get('harmony', '')}")
+        print(f"  Palette:    {len(palette_data)} unique colors")
+        print()
+        print("--- Layout Components ---")
+        for c in layout.get("components", []):
+            print(f"  {c.get('type', ''):16} y={c.get('y_pct', 0):2}% h={c.get('h_pct', 0):2}%  color={c.get('color', '')}")
+        print()
+        print(f"--- OCR Text ({ocr_result.get('words', 0)} words >= {min_confidence}%) ---")
+        if ocr_raw_text:
+            print(ocr_raw_text)
+        else:
+            print(f"  [top]    {ocr_by_zone.get('top', '')}")
+            print(f"  [middle] {ocr_by_zone.get('middle', '')}")
+            print(f"  [bottom] {ocr_by_zone.get('bottom', '')}")
+        print()
+
+        if buttons:
+            print(f"--- UI Buttons ({len(buttons)}) ---")
+            for b in buttons:
+                print(f"  [button] {b.get('text', '')}  (z={b.get('zone', '')}, y={b.get('y', 0)}, c={b.get('conf', 0)}%)")
+            print()
+
+        print("--- CSS Recommendations ---")
+        for key, val in result["css"]["customProperties"].items():
+            print(f"  {key}: {val}")
+        if gradient_info:
+            g = gradient_info
+            print(f"  gradient: {g.get('type', '')} {' -> '.join(str(c) for c in g.get('colors', []))}")
+        print()
+        print("=" * 72)
+
+    if full:
+        print()
+        print("=== Full JSON Output ===")
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+
+    # Clipboard temp cleanup
+    if clipboard and os.path.exists(resolved_path):
+        try:
+            os.remove(resolved_path)
+        except OSError:
+            pass
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Image-to-Code: Extract structured data from images")
+    parser.add_argument("image_path", nargs="?", help="Path to image file")
+    parser.add_argument("--clipboard", "-c", action="store_true", help="Read image from clipboard")
+    parser.add_argument("--lang", "-l", default="tha+eng", help="Tesseract language (default: tha+eng)")
+    parser.add_argument("--min-confidence", "-m", type=int, default=70, help="Minimum OCR confidence (default: 70)")
+    parser.add_argument("--sample-count", type=int, default=2000, help="Color sample count (default: 2000)")
+    parser.add_argument("--quantize-tolerance", type=int, default=15, help="Color quantize tolerance (default: 15)")
+    parser.add_argument("--full", "-f", action="store_true", help="Show full JSON output")
+    parser.add_argument("--json", "-j", action="store_true", help="Output JSON only")
+    args = parser.parse_args()
+
+    if not args.image_path and not args.clipboard:
+        parser.print_help()
+        sys.exit(1)
+
+    analyze_image(
+        image_path=args.image_path,
+        clipboard=args.clipboard,
+        ocr_language=args.lang,
+        min_confidence=args.min_confidence,
+        sample_count=args.sample_count,
+        quantize_tolerance=args.quantize_tolerance,
+        full=args.full,
+        json_output=args.json,
+    )
+
+
+if __name__ == "__main__":
+    main()

package/image_to_code/colors.py

@@ -0,0 +1,252 @@
+"""Color extraction: dominant colors, semantic roles, gradient, harmony."""
+
+import math
+from PIL import Image
+from .utils import hex_to_rgb, rgb_to_hex, luminance, contrast_ratio, saturation
+
+
+def extract_colors(image_path, sample_count=2000, quantize_tolerance=15):
+    img = Image.open(image_path).convert("RGB")
+    w, h = img.size
+
+    coarse_colors = set()
+    lum_vals = []
+    c_step_x = max(1, w // 40)
+    c_step_y = max(1, h // 40)
+    for y in range(0, h, c_step_y):
+        for x in range(0, w, c_step_x):
+            px = img.getpixel((x, y))
+            coarse_hex = f"#{px[0] & 0xF0:02X}{px[1] & 0xF0:02X}{px[2] & 0xF0:02X}"
+            coarse_colors.add(coarse_hex)
+            lum_vals.append(int(0.299 * px[0] + 0.587 * px[1] + 0.114 * px[2]))
+
+    distinct_color_count = len(coarse_colors)
+
+    edge_count = total_pairs = 0
+    for i in range(0, len(lum_vals) - 1, 2):
+        if abs(lum_vals[i] - lum_vals[i + 1]) > 40:
+            edge_count += 1
+        total_pairs += 1
+    edge_ratio = edge_count / total_pairs if total_pairs > 0 else 0
+
+    sorted_lums = sorted(lum_vals)
+    iqr = 0
+    if len(sorted_lums) >= 4:
+        q1 = sorted_lums[len(sorted_lums) // 4]
+        q3 = sorted_lums[len(sorted_lums) * 3 // 4]
+        iqr = q3 - q1
+    lum_range = sorted_lums[-1] - sorted_lums[0] if len(sorted_lums) >= 2 else 0
+
+    is_photo = (
+        distinct_color_count > 50
+        or (distinct_color_count >= 15 and iqr < 80)
+        or (lum_range > 150 and edge_ratio < 0.3)
+    )
+
+    color_counts = {}
+    step_x = max(1, int(w / math.sqrt(sample_count * w / h))) if w and h else 1
+    step_y = max(1, int(h / math.sqrt(sample_count * h / w))) if w and h else 1
+    total_samples = 0
+    for y in range(0, h, step_y):
+        for x in range(0, w, step_x):
+            px = img.getpixel((x, y))
+            rq = round(px[0] / quantize_tolerance) * quantize_tolerance
+            gq = round(px[1] / quantize_tolerance) * quantize_tolerance
+            bq = round(px[2] / quantize_tolerance) * quantize_tolerance
+            rq = max(0, min(255, rq))
+            gq = max(0, min(255, gq))
+            bq = max(0, min(255, bq))
+            hex_c = f"#{rq:02X}{gq:02X}{bq:02X}"
+            color_counts[hex_c] = color_counts.get(hex_c, 0) + 1
+            total_samples += 1
+
+    sorted_palette = sorted(color_counts.items(), key=lambda x: x[1], reverse=True)
+    total = max(1, total_samples)
+    palette = []
+    color_meta = []
+    for hex_c, cnt in sorted_palette:
+        pct = round(cnt / total * 100, 1)
+        palette.append({"hex": hex_c, "pct": pct, "count": cnt})
+        r, g, b = hex_to_rgb(hex_c)
+        lum = luminance(r, g, b)
+        sat = saturation(r, g, b)
+        color_meta.append(
+            {"hex": hex_c, "pct": pct, "r": r, "g": g, "b": b, "lum": lum, "sat": round(sat, 1)}
+        )
+
+    bg_color = palette[0]["hex"] if palette else "#FFFFFF"
+    bg_meta = color_meta[0] if color_meta else None
+    bg_lum = bg_meta["lum"] if bg_meta else 255
+
+    surfaces = []
+    text_primary = None
+    text_secondary = None
+    button_color = None
+    border_color = None
+    border_candidates = []
+
+    if not is_photo:
+        text_candidates = []
+        button_candidates = []
+
+        for cm in color_meta:
+            is_bg = cm["hex"] == bg_color
+            cr = contrast_ratio(bg_lum, cm["lum"])
+            lum_diff = abs(cm["lum"] - bg_lum)
+
+            if not is_bg and cm["pct"] > 1 and lum_diff < 40:
+                surfaces.append(cm)
+            if not is_bg and cr > 1.3 and cm["pct"] < 2 and cm["pct"] > 0.05 and lum_diff > 2:
+                border_candidates.append({"hex": cm["hex"], "contrast": cr, "lum_diff": lum_diff})
+            if not is_bg and cm["sat"] > 20 and cm["lum"] > 30 and cm["pct"] < 5 and cm["pct"] > 0.1:
+                button_candidates.append({"hex": cm["hex"], "sat": cm["sat"], "contrast": cr})
+            if not is_bg and cr > 3 and cm["pct"] < 3:
+                text_candidates.append({"hex": cm["hex"], "contrast": cr, "lum": cm["lum"]})
+
+        surfaces.sort(key=lambda x: x["pct"], reverse=True)
+
+        if text_candidates:
+            text_candidates.sort(key=lambda x: x["contrast"], reverse=True)
+            text_primary = text_candidates[0]["hex"]
+            if len(text_candidates) > 1:
+                text_secondary = text_candidates[1]["hex"]
+        else:
+            text_primary = "#1F2937" if bg_lum > 128 else "#FFFFFF"
+
+        if button_candidates:
+            button_candidates.sort(key=lambda x: x["sat"], reverse=True)
+            button_color = button_candidates[0]["hex"]
+        if border_candidates:
+            border_candidates.sort(key=lambda x: x["lum_diff"], reverse=True)
+            border_color = border_candidates[0]["hex"]
+    else:
+        for cm in color_meta:
+            is_bg = cm["hex"] == bg_color
+            lum_diff = abs(cm["lum"] - bg_lum)
+            if not is_bg and cm["pct"] > 0.5 and lum_diff < 50:
+                surfaces.append(cm)
+        surfaces.sort(key=lambda x: x["pct"], reverse=True)
+        text_primary = "#1F2937" if bg_lum > 128 else "#FFFFFF"
+
+        button_candidates = [
+            cm
+            for cm in color_meta
+            if cm["sat"] > 20 and cm["lum"] > 30 and cm["pct"] > 0.1 and cm["pct"] < 5 and cm["hex"] != bg_color
+        ]
+        if button_candidates:
+            button_candidates.sort(key=lambda x: x["sat"], reverse=True)
+            button_color = button_candidates[0]["hex"]
+
+        for cm in color_meta:
+            is_bg = cm["hex"] == bg_color
+            cr = contrast_ratio(bg_lum, cm["lum"])
+            lum_diff = abs(cm["lum"] - bg_lum)
+            if not is_bg and cr > 1.3 and cm["pct"] < 2 and cm["pct"] > 0.05 and lum_diff > 2:
+                border_candidates.append({"hex": cm["hex"], "contrast": cr, "lum_diff": lum_diff})
+        if border_candidates:
+            border_candidates.sort(key=lambda x: x["lum_diff"], reverse=True)
+            border_color = border_candidates[0]["hex"]
+
+    has_gradient = False
+    gradient_type = "none"
+    gradient_colors = [bg_color]
+    grad_threshold = 30 if is_photo else 50
+
+    def _strip_lum(y_start, y_end, step=2):
+        tl = cnt = 0
+        for yy in range(y_start, min(y_end, h), step):
+            for xx in range(0, w, 20):
+                px = img.getpixel((xx, yy))
+                tl += luminance(px[0], px[1], px[2])
+                cnt += 1
+        return tl / cnt if cnt else 0
+
+    top_lum = _strip_lum(0, min(50, h))
+    mid_lum = _strip_lum(max(0, h // 2 - 25), min(h, h // 2 + 25))
+    bot_lum = _strip_lum(max(0, h - 50), h)
+    grad_range = max(abs(top_lum - bot_lum), abs(top_lum - mid_lum))
+
+    if grad_range > grad_threshold:
+        has_gradient = True
+        gradient_type = "vertical-3tone" if (abs(top_lum - mid_lum) > 15 and abs(mid_lum - bot_lum) > 15) else "vertical"
+
+        def _strip_color(y_pos):
+            r_sum = g_sum = b_sum = cnt = 0
+            for xx in range(w // 3, w * 2 // 3, 10):
+                px = img.getpixel((xx, y_pos))
+                r_sum += px[0]; g_sum += px[1]; b_sum += px[2]; cnt += 1
+            return (r_sum // cnt, g_sum // cnt, b_sum // cnt) if cnt else None
+
+        gradient_colors = []
+        for yp in (5, h // 2, h - 5):
+            c = _strip_color(yp)
+            if c:
+                gradient_colors.append(rgb_to_hex(*c))
+
+    img.close()
+
+    tr, tg, tb = hex_to_rgb(text_primary)
+    text_lum = luminance(tr, tg, tb)
+    br, bg, bb = hex_to_rgb(bg_color)
+    bg_lum_calc = luminance(br, bg, bb)
+    contrast_ratio_val = round(contrast_ratio(text_lum, bg_lum_calc), 1)
+
+    hues = []
+    for cm in color_meta:
+        if cm["pct"] <= 0.5:
+            continue
+        r, g, b = cm["r"], cm["g"], cm["b"]
+        mx = max(r, g, b)
+        mn = min(r, g, b)
+        if mx == mn:
+            continue
+        d = mx - mn
+        if mx == r:
+            hv = ((g - b) / d) % 6
+        elif mx == g:
+            hv = (b - r) / d + 2
+        else:
+            hv = (r - g) / d + 4
+        hd = round(hv * 60)
+        if hd < 0:
+            hd += 360
+        hues.append(hd)
+
+    hue_range = 0
+    if len(hues) > 1:
+        sh = sorted(hues)
+        mg = max(sh[i + 1] - sh[i] for i in range(len(sh) - 1))
+        wg = 360 - sh[-1] + sh[0]
+        if wg > mg:
+            mg = wg
+        hue_range = 360 - mg
+
+    if hue_range <= 30:
+        harmony = "monochromatic"
+    elif hue_range <= 60:
+        harmony = "analogous"
+    elif 150 <= hue_range <= 210:
+        harmony = "complementary"
+    else:
+        harmony = "neutral"
+
+    surface_colors = [s["hex"] for s in surfaces[:3]] or [bg_color]
+
+    return {
+        "imageWidth": w,
+        "imageHeight": h,
+        "isPhoto": is_photo,
+        "distinctColors": distinct_color_count,
+        "totalColors": len(palette),
+        "samples": total_samples,
+        "background": bg_color,
+        "surfaces": surface_colors,
+        "text": text_primary,
+        "textSecondary": text_secondary,
+        "button": button_color,
+        "border": border_color,
+        "contrastRatio": contrast_ratio_val,
+        "harmony": harmony,
+        "gradient": {"type": gradient_type, "colors": gradient_colors} if has_gradient else None,
+        "palette": palette[:20],
+    }

package/image_to_code/layout.py

@@ -0,0 +1,150 @@
+"""Layout detection: horizontal sections, vertical columns, component labeling."""
+
+from PIL import Image
+
+
+def _dominant_color(img, x1, y1, x2, y2, step=8):
+    counts = {}
+    for y in range(y1, y2, step):
+        for x in range(x1, x2, step):
+            px = img.getpixel((x, y))
+            rq = round(px[0] / 20) * 20
+            gq = round(px[1] / 20) * 20
+            bq = round(px[2] / 20) * 20
+            rq = max(0, min(255, rq))
+            gq = max(0, min(255, gq))
+            bq = max(0, min(255, bq))
+            hex_c = f"#{rq:02X}{gq:02X}{bq:02X}"
+            counts[hex_c] = counts.get(hex_c, 0) + 1
+    if not counts:
+        return "#000000"
+    return max(counts, key=counts.get)
+
+
+def detect_layout(image_path):
+    img = Image.open(image_path).convert("RGB")
+    w, h = img.size
+
+    coarse_colors = set()
+    lum_vals = []
+    for y in range(0, h, max(1, h // 30)):
+        for x in range(0, w, max(1, w // 30)):
+            px = img.getpixel((x, y))
+            hex_c = f"#{px[0] & 0xF0:02X}{px[1] & 0xF0:02X}{px[2] & 0xF0:02X}"
+            coarse_colors.add(hex_c)
+            lum_vals.append(int(0.299 * px[0] + 0.587 * px[1] + 0.114 * px[2]))
+
+    edge_count = total_pairs = 0
+    for i in range(0, len(lum_vals) - 1, 2):
+        if abs(lum_vals[i] - lum_vals[i + 1]) > 40:
+            edge_count += 1
+        total_pairs += 1
+    edge_ratio = edge_count / total_pairs if total_pairs > 0 else 0
+
+    sorted_lums = sorted(lum_vals)
+    iqr = 0
+    if len(sorted_lums) >= 4:
+        q1 = sorted_lums[len(sorted_lums) // 4]
+        q3 = sorted_lums[len(sorted_lums) * 3 // 4]
+        iqr = q3 - q1
+    lum_range = sorted_lums[-1] - sorted_lums[0] if len(sorted_lums) >= 2 else 0
+
+    is_photo = (
+        len(coarse_colors) > 50
+        or (len(coarse_colors) >= 15 and iqr < 80)
+        or (lum_range > 150 and edge_ratio < 0.3)
+    )
+
+    scan_resolution = max(8, h // 60) if is_photo else 4
+
+    sections = []
+    prev_color = ""
+    section_start = 0
+
+    for y in range(0, h, scan_resolution):
+        end_y = min(h, y + scan_resolution)
+        row_color = _dominant_color(img, 0, y, w, end_y, 8)
+        if row_color != prev_color and prev_color != "":
+            sections.append({"y": section_start, "h": y - section_start, "color": prev_color})
+            section_start = y
+        prev_color = row_color
+
+    if h - section_start > 2:
+        sections.append({"y": section_start, "h": h - section_start, "color": prev_color})
+
+    columns = []
+    if not is_photo:
+        min_col_w = int(w * 0.08)
+        x_step = max(1, w // 80)
+        prev_col_color = ""
+        col_start = 0
+        for x in range(0, w, x_step):
+            end_x = min(w, x + x_step)
+            col_color = _dominant_color(img, x, 0, end_x, h, 10)
+            if col_color != prev_col_color and prev_col_color != "":
+                col_w = x - col_start
+                if col_w >= min_col_w:
+                    columns.append({"x": col_start, "w": col_w, "color": prev_col_color})
+                col_start = x
+            prev_col_color = col_color
+        if w - col_start > min_col_w:
+            columns.append({"x": col_start, "w": w - col_start, "color": prev_col_color})
+
+    min_height = max(20, int(h * 0.03)) if is_photo else max(8, int(h * 0.02))
+    merged_sections = []
+    buffer = None
+    for s in sections:
+        if s["h"] < min_height:
+            if buffer is not None:
+                buffer["h"] += s["h"]
+            else:
+                buffer = dict(s)
+        else:
+            if buffer is not None:
+                s["y"] = buffer["y"]
+                s["h"] += buffer["h"]
+                buffer = None
+            merged_sections.append(s)
+    if buffer is not None:
+        merged_sections.append(buffer)
+
+    components = []
+    for s in merged_sections:
+        rel_y = round(s["y"] / h * 100)
+        rel_h = round(s["h"] / h * 100)
+
+        if rel_y < 3:
+            label = "hero-padding" if rel_h > 30 else "top-segment"
+        elif rel_y + rel_h > 97:
+            label = "bottom-segment"
+        elif rel_h > 50:
+            label = "large-segment"
+        elif rel_h < 5:
+            label = "thin-band"
+        else:
+            label = "mid-segment"
+
+        components.append(
+            {
+                "type": label,
+                "y_pct": rel_y,
+                "h_pct": rel_h,
+                "y_px": s["y"],
+                "h_px": s["h"],
+                "color": s["color"],
+            }
+        )
+
+    img.close()
+
+    layout_type = "mobile" if w <= 430 else ("landscape/desktop" if w > h else "tablet/mobile")
+
+    return {
+        "imageWidth": w,
+        "imageHeight": h,
+        "isPhoto": is_photo,
+        "layoutType": layout_type,
+        "sections": merged_sections,
+        "columns": columns,
+        "components": components,
+    }

package/image_to_code/ocr.py

@@ -0,0 +1,448 @@
+"""OCR module: Tesseract-based text extraction with preprocessing, footer/branding scans, Thai merging."""
+
+import os
+import re
+import sys
+import subprocess
+import tempfile
+from PIL import Image, ImageFilter, ImageOps
+import pytesseract
+
+from .utils import merge_thai_text
+
+# Auto-detect tesseract binary
+_TESS_CMD = None
+for _candidate in [
+    "tesseract",
+    r"C:\Program Files\Tesseract-OCR\tesseract.exe",
+    r"C:\Program Files (x86)\Tesseract-OCR\tesseract.exe",
+    "/usr/bin/tesseract",
+    "/usr/local/bin/tesseract",
+    "/opt/homebrew/bin/tesseract",
+]:
+    try:
+        subprocess.run([_candidate, "--version"], capture_output=True, timeout=5)
+        _TESS_CMD = _candidate
+        break
+    except (FileNotFoundError, OSError, subprocess.TimeoutExpired):
+        continue
+
+if _TESS_CMD:
+    pytesseract.pytesseract.tesseract_cmd = _TESS_CMD
+
+# Auto-configure tessdata with language download
+_SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+_USER_TESSDATA = os.path.join(_SCRIPT_DIR, "..", "tessdata")
+os.makedirs(_USER_TESSDATA, exist_ok=True)
+os.environ["TESSDATA_PREFIX"] = _USER_TESSDATA
+
+
+def _ensure_lang_data(language):
+    """Download missing traineddata files from GitHub."""
+    for lang in language.split("+"):
+        lang_file = os.path.join(_USER_TESSDATA, f"{lang}.traineddata")
+        if not os.path.exists(lang_file):
+            import urllib.request
+            url = f"https://github.com/tesseract-ocr/tessdata/raw/main/{lang}.traineddata"
+            print(f"Downloading {lang} language data...", file=sys.stderr)
+            try:
+                urllib.request.urlretrieve(url, lang_file)
+            except Exception as e:
+                print(f"Warning: failed to download {lang}: {e}", file=sys.stderr)
+
+
+def _histogram_stretch(img):
+    """Apply histogram stretch to enhance contrast."""
+    gray = img.convert("L")
+    pixels = list(gray.getdata())
+    min_l = min(pixels)
+    max_l = max(pixels)
+    rng = max(1, max_l - min_l)
+    result = Image.new("L", img.size)
+    result.putdata([max(0, min(255, int((p - min_l) / rng * 255))) for p in pixels])
+    return result
+
+
+def _adaptive_threshold(img):
+    """Apply threshold to create high-contrast BW."""
+    gray = img.convert("L")
+    pixels = list(gray.getdata())
+    new_pixels = []
+    for p in pixels:
+        if p < 100:
+            np_val = 0
+        elif p > 160:
+            np_val = 255
+        else:
+            np_val = max(0, min(255, (p - 80) * 3))
+        new_pixels.append(np_val)
+    result = Image.new("L", img.size)
+    result.putdata(new_pixels)
+    return result
+
+
+def _classify_image(img):
+    """Returns (is_photo, lum_vals) for photo vs UI classification."""
+    w, h = img.size
+    color_sample = set()
+    lum_vals = []
+    for y in range(0, h, max(1, h // 50)):
+        for x in range(0, w, max(1, w // 50)):
+            px = img.getpixel((x, y))
+            hex_c = f"#{px[0] & 0xF0:02X}{px[1] & 0xF0:02X}{px[2] & 0xF0:02X}"
+            color_sample.add(hex_c)
+            lum_vals.append(int(0.299 * px[0] + 0.587 * px[1] + 0.114 * px[2]))
+
+    edge_count = total_pairs = 0
+    for i in range(0, len(lum_vals) - 1, 2):
+        if abs(lum_vals[i] - lum_vals[i + 1]) > 40:
+            edge_count += 1
+        total_pairs += 1
+    edge_ratio = edge_count / total_pairs if total_pairs > 0 else 0
+
+    sorted_lums = sorted(lum_vals)
+    iqr = 0
+    if len(sorted_lums) >= 4:
+        q1 = sorted_lums[len(sorted_lums) // 4]
+        q3 = sorted_lums[len(sorted_lums) * 3 // 4]
+        iqr = q3 - q1
+    lum_range = sorted_lums[-1] - sorted_lums[0] if len(sorted_lums) >= 2 else 0
+
+    is_photo = (
+        len(color_sample) > 50
+        or (len(color_sample) >= 15 and iqr < 80)
+        or (lum_range > 150 and edge_ratio < 0.3)
+    )
+    return is_photo, lum_vals, len(color_sample)
+
+
+def _tsv_to_boxes(tsv_text, min_confidence, h, w, y_offset=0):
+    """Parse Tesseract TSV output into structured box list."""
+    boxes = []
+    lines = [l.strip() for l in tsv_text.split("\n") if l.strip()]
+    if len(lines) < 2:
+        return boxes
+
+    header = lines[0].split("\t")
+    col_map = {name: idx for idx, name in enumerate(header)}
+
+    for line in lines[1:]:
+        cols = line.split("\t")
+        if len(cols) < 12:
+            continue
+
+        text = cols[col_map.get("text", -1)] if "text" in col_map else ""
+        conf_str = cols[col_map.get("conf", -1)] if "conf" in col_map else ""
+        conf = 0.0
+        try:
+            conf = float(conf_str)
+        except (ValueError, IndexError):
+            pass
+
+        if not text.strip() or conf < min_confidence:
+            continue
+
+        def _safe_int(idx_key, default=0):
+            try:
+                return int(cols[col_map[idx_key]])
+            except (ValueError, IndexError, KeyError):
+                return default
+
+        bw = _safe_int("width")
+        bh = _safe_int("height")
+        if bw < 8 and bh < 8:
+            continue
+
+        bx = _safe_int("left")
+        by = _safe_int("top") + y_offset
+
+        boxes.append(
+            {
+                "text": text.strip(),
+                "conf": round(conf, 1),
+                "x": bx,
+                "y": by,
+                "w": bw,
+                "h": bh,
+                "zone": "top" if by < h / 3 else ("middle" if by < h * 2 / 3 else "bottom"),
+            }
+        )
+    return boxes
+
+
+def _dedup_boxes(boxes, new_boxes, img_h):
+    """Deduplicate boxes: skip dups/substrings, extend longer versions."""
+    for nb in new_boxes:
+        word = nb["text"]
+        x, y = nb["x"], nb["y"]
+
+        dup = any(
+            b["text"] == word and abs(b["x"] - x) < 40 and abs(b["y"] - y) < 40 for b in boxes
+        )
+        subdup = False
+        if len(word) >= 3:
+            subdup = any(
+                word in b["text"] and abs(b["y"] - y) < 30 for b in boxes
+            )
+        extend = [
+            b
+            for b in boxes
+            if word.startswith(b["text"])
+            and abs(b["y"] - y) < 30
+            and len(word) > len(b["text"])
+        ]
+
+        if extend:
+            for b in boxes:
+                if b in extend:
+                    b["text"] = word
+
+        if not dup and not subdup and not extend:
+            nb["zone"] = "top" if y < img_h / 3 else ("middle" if y < img_h * 2 / 3 else "bottom")
+            boxes.append(nb)
+    return boxes
+
+
+def extract_text(image_path, language="tha+eng", min_confidence=70):
+    """Extract text from image using Tesseract OCR with preprocessing."""
+    _ensure_lang_data(language)
+    img = Image.open(image_path).convert("RGB")
+    w, h = img.size
+
+    is_photo, _, _ = _classify_image(img)
+
+    orig_path = image_path
+    preprocessed_paths = [orig_path]
+
+    if is_photo:
+        pp1 = _histogram_stretch(img)
+        pp1_path = os.path.join(tempfile.gettempdir(), f"img2code_pp1_{os.urandom(4).hex()}.png")
+        pp1.save(pp1_path)
+        pp1.close()
+        preprocessed_paths.append(pp1_path)
+
+        pp2_img = _adaptive_threshold(img)
+        pp2_path = os.path.join(tempfile.gettempdir(), f"img2code_pp2_{os.urandom(4).hex()}.png")
+        pp2_img.save(pp2_path)
+        pp2_img.close()
+        preprocessed_paths.append(pp2_path)
+
+    all_boxes = []
+    psm_modes = [3, 6, 4, 11] if is_photo else [3, 11, 6, 4]
+
+    for pp_path in preprocessed_paths:
+        for psm in psm_modes:
+            try:
+                tsv = pytesseract.image_to_data(
+                    Image.open(pp_path),
+                    lang=language,
+                    config=f"--psm {psm}",
+                    output_type=pytesseract.Output.DICT,
+                )
+            except Exception:
+                continue
+
+            num_items = len(tsv.get("text", []))
+            for i in range(num_items):
+                text = tsv["text"][i] if i < len(tsv["text"]) else ""
+                try:
+                    conf = float(tsv["conf"][i]) if i < len(tsv["conf"]) else -1
+                except (ValueError, TypeError):
+                    conf = -1
+
+                if not text or text.strip() == "" or conf < min_confidence:
+                    continue
+
+                bw = int(tsv["width"][i]) if i < len(tsv["width"]) else 0
+                bh = int(tsv["height"][i]) if i < len(tsv["height"]) else 0
+                if bw < 8 and bh < 8:
+                    continue
+
+                bx = int(tsv["left"][i]) if i < len(tsv["left"]) else 0
+                by = int(tsv["top"][i]) if i < len(tsv["top"]) else 0
+                word = text.strip()
+
+                nb = {"text": word, "conf": round(conf, 1), "x": bx, "y": by, "w": bw, "h": bh}
+                all_boxes = _dedup_boxes(all_boxes, [nb], h)
+
+    # Footer scan: crop bottom 40px for copyright
+    if h > 40:
+        footer_crop = img.crop((0, h - 40, w, h))
+        footer_stretch = _histogram_stretch(footer_crop)
+        footer_paths = [footer_crop, footer_stretch]
+
+        for fc in footer_paths:
+            for psm_f in (11, 6):
+                try:
+                    tsv = pytesseract.image_to_data(
+                        fc,
+                        lang=language,
+                        config=f"--psm {psm_f}",
+                        output_type=pytesseract.Output.DICT,
+                    )
+                except Exception:
+                    continue
+
+                num_items = len(tsv.get("text", []))
+                for i in range(num_items):
+                    text = tsv["text"][i] if i < len(tsv["text"]) else ""
+                    try:
+                        conf = float(tsv["conf"][i]) if i < len(tsv["conf"]) else -1
+                    except (ValueError, TypeError):
+                        conf = -1
+
+                    if not text or text.strip() == "" or conf < min_confidence:
+                        continue
+
+                    fw = int(tsv["width"][i]) if i < len(tsv["width"]) else 0
+                    fh = int(tsv["height"][i]) if i < len(tsv["height"]) else 0
+                    if fw < 8 and fh < 8 or fh > 50:
+                        continue
+                    fx = int(tsv["left"][i]) if i < len(tsv["left"]) else 0
+                    if fx > w * 0.92:
+                        continue
+                    fy = int(tsv["top"][i]) if i < len(tsv["top"]) else 0
+                    fy += h - 40
+
+                    nb = {"text": text.strip(), "conf": round(conf, 1), "x": fx, "y": fy, "w": fw, "h": fh, "src": "footer", "psm": psm_f}
+                    all_boxes = _dedup_boxes(all_boxes, [nb], h)
+
+    # Branding scan: crop bottom 70px for "MADE BY" text
+    if h > 70:
+        mb_crop = img.crop((0, h - 70, w, h))
+        for psm_mb in (8, 7, 13):
+            try:
+                tsv = pytesseract.image_to_data(
+                    mb_crop,
+                    lang=language,
+                    config=f"--psm {psm_mb}",
+                    output_type=pytesseract.Output.DICT,
+                )
+            except Exception:
+                continue
+
+            num_items = len(tsv.get("text", []))
+            for i in range(num_items):
+                text = tsv["text"][i] if i < len(tsv["text"]) else ""
+                try:
+                    conf = float(tsv["conf"][i]) if i < len(tsv["conf"]) else -1
+                except (ValueError, TypeError):
+                    conf = -1
+
+                if not text or text.strip() == "" or conf < min_confidence:
+                    continue
+
+                mw = int(tsv["width"][i]) if i < len(tsv["width"]) else 0
+                mh = int(tsv["height"][i]) if i < len(tsv["height"]) else 0
+                if mw < 8 and mh < 8 or mh > 50:
+                    continue
+                mx = int(tsv["left"][i]) if i < len(tsv["left"]) else 0
+                if mx > w * 0.92:
+                    continue
+                my = int(tsv["top"][i]) if i < len(tsv["top"]) else 0
+                my += h - 70
+
+                nb = {"text": text.strip(), "conf": round(conf, 1), "x": mx, "y": my, "w": mw, "h": mh, "src": "branding", "psm": psm_mb}
+                all_boxes = _dedup_boxes(all_boxes, [nb], h)
+
+    # Retry with preprocessing if word count is low
+    if len(all_boxes) < 5:
+        stretch_full = _histogram_stretch(img)
+        stretch_path = os.path.join(tempfile.gettempdir(), f"img2code_retry_{os.urandom(4).hex()}.png")
+        stretch_full.save(stretch_path)
+        stretch_full.close()
+
+        for psm_r in (3, 6, 11):
+            try:
+                tsv = pytesseract.image_to_data(
+                    Image.open(stretch_path),
+                    lang=language,
+                    config=f"--psm {psm_r}",
+                    output_type=pytesseract.Output.DICT,
+                )
+            except Exception:
+                continue
+
+            num_items = len(tsv.get("text", []))
+            for i in range(num_items):
+                text = tsv["text"][i] if i < len(tsv["text"]) else ""
+                try:
+                    conf = float(tsv["conf"][i]) if i < len(tsv["conf"]) else -1
+                except (ValueError, TypeError):
+                    conf = -1
+
+                if not text or text.strip() == "" or conf < min_confidence:
+                    continue
+
+                rx = int(tsv["left"][i]) if i < len(tsv["left"]) else 0
+                ry = int(tsv["top"][i]) if i < len(tsv["top"]) else 0
+                rw = int(tsv["width"][i]) if i < len(tsv["width"]) else 0
+                rh = int(tsv["height"][i]) if i < len(tsv["height"]) else 0
+                nb = {"text": text.strip(), "conf": round(conf, 1), "x": rx, "y": ry, "w": rw, "h": rh}
+                all_boxes = _dedup_boxes(all_boxes, [nb], h)
+
+        try:
+            os.remove(stretch_path)
+        except OSError:
+            pass
+
+    # Clean up preprocessed temp files
+    for pp in preprocessed_paths[1:]:
+        try:
+            os.remove(pp)
+        except OSError:
+            pass
+
+    # Sort boxes by zone, then y, then x
+    zone_order = {"top": 1, "middle": 2, "bottom": 3}
+    all_boxes.sort(key=lambda b: (zone_order.get(b.get("zone", "middle"), 2), b["y"], b["x"]))
+
+    # Plain-text pass for full text
+    raw_text = ""
+    raw_candidates = {}
+    try:
+        raw_candidates["orig"] = pytesseract.image_to_string(img, lang=language, config="--psm 6").strip()
+    except Exception:
+        pass
+
+    if is_photo or "tha" in language:
+        pp_raw = _histogram_stretch(img)
+        pp_raw_path = os.path.join(tempfile.gettempdir(), f"img2code_raw_{os.urandom(4).hex()}.png")
+        pp_raw.save(pp_raw_path)
+        pp_raw.close()
+        try:
+            raw_candidates["pp"] = pytesseract.image_to_string(
+                Image.open(pp_raw_path), lang=language, config="--psm 6"
+            ).strip()
+        except Exception:
+            pass
+        try:
+            os.remove(pp_raw_path)
+        except OSError:
+            pass
+
+    if raw_candidates:
+        raw_text = max(raw_candidates.values(), key=len)
+
+    raw_text_output = merge_thai_text(raw_text) if raw_text else ""
+
+    img.close()
+
+    # Build byZone
+    def _zone_text(zone_name):
+        return merge_thai_text(
+            " ".join(b["text"] for b in all_boxes if b.get("zone") == zone_name)
+        )
+
+    by_zone = {
+        "top": _zone_text("top"),
+        "middle": _zone_text("middle"),
+        "bottom": _zone_text("bottom"),
+    }
+
+    return {
+        "words": len(all_boxes),
+        "boxes": all_boxes,
+        "rawText": raw_text_output,
+        "byZone": by_zone,
+    }

package/image_to_code/utils.py

@@ -0,0 +1,39 @@
+"""Shared utilities: hex/rgb conversion, luminance, contrast, Thai merging."""
+
+import re
+
+
+def hex_to_rgb(hex_str):
+    r = int(hex_str[1:3], 16)
+    g = int(hex_str[3:5], 16)
+    b = int(hex_str[5:7], 16)
+    return r, g, b
+
+
+def rgb_to_hex(r, g, b):
+    return f"#{r:02X}{g:02X}{b:02X}"
+
+
+def luminance(r, g, b):
+    return 0.299 * r + 0.587 * g + 0.114 * b
+
+
+def contrast_ratio(lum1, lum2):
+    l1 = max(lum1, lum2) + 0.05
+    l2 = min(lum1, lum2) + 0.05
+    return l1 / l2
+
+
+def saturation(r, g, b):
+    max_c = max(r, g, b)
+    min_c = min(r, g, b)
+    if max_c == 0:
+        return 0
+    return (max_c - min_c) / max_c * 100
+
+
+def merge_thai_text(text):
+    """Merge Thai grapheme clusters split by Tesseract into correct words."""
+    if not text:
+        return text
+    return re.sub(r"(?<=[\u0E00-\u0E7F])\s+(?=[\u0E00-\u0E7F])", "", text)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "image-to-code",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Extract structured data (colors, layout, OCR text) from images. No AI vision required.",
   "bin": {
     "image-to-code": "bin/cli.js"
@@ -24,7 +24,9 @@
   "homepage": "https://github.com/phumitchreal/image-to-code#readme",
   "files": [
     "bin/",
+    "image_to_code/",
     "package.json",
-    "README.md"
+    "README.md",
+    "requirements.txt"
   ]
 }

package/requirements.txt

@@ -0,0 +1,2 @@
+Pillow>=10.0.0
+pytesseract>=0.3.10