Initial commit with preprocessing and base64 forwarding

.gitignore

@@ -0,0 +1,12 @@
+# FastAPI / Uvicorn
+__pycache__/
+*.pyc
+
+# Local Config / Testing
+receiver.py
+.env
+
+# Image Preprocessing Debug Output
+*_debug.jpg
+*_binary_debug.jpg
+*_cropped.jpg

Dockerfile

@@ -0,0 +1,19 @@
+# Use Python 3.9 for compatibility with standard HF Docker Spaces
+FROM python:3.9
+
+# Create a non-root user to avoid permission issues
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+# Copy and install requirements
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+# Copy the application code
+COPY --chown=user . /app
+
+# Run the application
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,52 @@
+---
+title: Backend
+emoji: 🐳
+colorFrom: blue
+colorTo: indigo
+sdk: docker
+app_port: 7860
+pinned: false
+---
+
+# SolarumAsteridion-Backend
+
+A minimalist FastAPI application running in a Docker Space that performs **exact image preprocessing** (auto-crop + rotation) and handles **Base64 forwarding**.
+
+## Setup
+1. Go to your **Space Settings** -> **Variables and Secrets**.
+2. Add a new secret named `API_KEY`.
+3. Set its value to your preferred API key.
+
+## Usage
+
+### 1. Uploading an Image (`POST /upload`)
+Send a standard image file using `curl`. The server will preprocess it and encode it to Base64 for the internal receiver.
+
+```bash
+curl -X POST "https://solarumasteridion-backend.hf.space/upload" \
+     -H "X-API-Key: YOUR_API_KEY_HERE" \
+     -F "file=@/path/to/your/image.jpg"
+```
+
+### 2. Python Example
+Using the `requests` library:
+
+```python
+import requests
+
+url = "https://solarumasteridion-backend.hf.space/upload"
+headers = {"X-API-Key": "YOUR_API_KEY_HERE"}
+files = {"file": open("sample.jpg", "rb")}
+
+response = requests.post(url, headers=headers, files=files)
+print(response.json())
+```
+
+---
+
+## Workflow Details
+1. **Authentication**: Checks the `X-API-Key` header against the `API_KEY` environment variable.
+2. **Preprocessing**: Applies the logic from `processor.py` (90° CCW rotation + auto-crop).
+3. **Encoding**: Converts the processed binary image to a **Base64 string**.
+4. **Forwarding**: Sends a JSON payload `{"image_base64": "..."}` to the internal `/receiver`.
+5. **Acknowledgment**: Retries until `/receiver` returns `"YES RECEIVED"`.

app.py

@@ -0,0 +1,80 @@
+import os
+import asyncio
+import httpx
+import base64
+from fastapi import FastAPI, HTTPException, Header, UploadFile, File, Form, Depends
+from fastapi.responses import JSONResponse, PlainTextResponse
+from pydantic import BaseModel
+import uvicorn
+
+# Import the exact processing logic from processor.py
+from processor import auto_crop_process
+
+app = FastAPI()
+
+# API Key from environment variable
+# Ensure it is set in Space Settings
+API_KEY = os.getenv("API_KEY")
+
+class ImageBase64Payload(BaseModel):
+    """Payload for Base64 image data"""
+    image_base64: str
+
+@app.post("/upload")
+async def upload_image(file: UploadFile = File(...), x_api_key: str = Header(None)):
+    """
+    Receives image, processes it via processor.py, 
+    encodes to Base64, and forwards to /receiver.
+    """
+    # Authentication check
+    if API_KEY and x_api_key != API_KEY:
+        raise HTTPException(status_code=401, detail="Unauthorized")
+
+    # Read binary content
+    image_bytes = await file.read()
+    
+    # 1. PREPROCESS using the exact logic in processor.py
+    # (Includes 90-degree CCW rotation and auto-crop)
+    try:
+        processed_bytes = auto_crop_process(image_bytes)
+    except Exception as e:
+        # If preprocessing fails, we stop or log? 
+        # Requirement: "USE THE EXACT LOGIC".
+        raise HTTPException(status_code=500, detail=f"Preprocessing failed: {str(e)}")
+    
+    # 2. CONVERT TO BASE64
+    encoded_image = base64.b64encode(processed_bytes).decode('utf-8')
+    
+    # 3. FORWARD TO /RECEIVER
+    # Minimalist retry loop as requested
+    while True:
+        try:
+            # Using internal httpx call to the app itself
+            async with httpx.AsyncClient(app=app, base_url="http://internal") as client:
+                payload = {"image_base64": encoded_image}
+                response = await client.post("/receiver", json=payload)
+                
+                # Check if receiver said the magic words
+                if response.status_code == 200 and response.text.strip() == "YES RECEIVED":
+                    return JSONResponse(content={
+                        "status": "SUCCESS", 
+                        "message": "Image preprocessed, converted to Base64, and forwarded successfully."
+                    })
+        except Exception:
+            # Silence and wait/retry as per "wait until it does say that"
+            pass
+        
+        # Wait 1 second before retrying
+        await asyncio.sleep(1)
+
+@app.post("/receiver", response_class=PlainTextResponse)
+async def receiver(payload: ImageBase64Payload):
+    """
+    Minimalist receiver that acknowledges the Base64 image.
+    """
+    # The image is available in payload.image_base64
+    return "YES RECEIVED"
+
+if __name__ == "__main__":
+    # For local testing
+    uvicorn.run(app, host="0.0.0.0", port=7860)

processor.py

@@ -0,0 +1,353 @@
+#!/usr/bin/env python3
+"""
+Notebook Auto-Crop Tool v5 — Tight-Crop Fix
+"""
+
+import cv2
+import numpy as np
+import sys
+import os
+from pathlib import Path
+
+
+def order_points(pts):
+    rect = np.zeros((4, 2), dtype="float32")
+    s = pts.sum(axis=1)
+    rect[0] = pts[np.argmin(s)]
+    rect[2] = pts[np.argmax(s)]
+    diff = np.diff(pts, axis=1)
+    rect[1] = pts[np.argmin(diff)]
+    rect[3] = pts[np.argmax(diff)]
+    return rect
+
+
+def four_point_transform(image, pts):
+    rect = order_points(pts)
+    (tl, tr, br, bl) = rect
+    maxW = max(int(max(np.linalg.norm(br - bl), np.linalg.norm(tr - tl))), 1)
+    maxH = max(int(max(np.linalg.norm(tr - br), np.linalg.norm(tl - bl))), 1)
+    dst = np.array([[0, 0], [maxW-1, 0], [maxW-1, maxH-1], [0, maxH-1]], dtype="float32")
+    M = cv2.getPerspectiveTransform(rect, dst)
+    return cv2.warpPerspective(image, M, (maxW, maxH))
+
+
+def is_valid_quad(quad, img_shape):
+    ordered = order_points(quad.astype(np.float32))
+    for i in range(4):
+        v1 = ordered[(i - 1) % 4] - ordered[i]
+        v2 = ordered[(i + 1) % 4] - ordered[i]
+        denom = np.linalg.norm(v1) * np.linalg.norm(v2)
+        if denom < 1e-6:
+            return False
+        angle = np.degrees(np.arccos(np.clip(np.dot(v1, v2) / denom, -1, 1)))
+        if angle < 30 or angle > 150:
+            return False
+    w1 = np.linalg.norm(ordered[1] - ordered[0])
+    w2 = np.linalg.norm(ordered[2] - ordered[3])
+    h1 = np.linalg.norm(ordered[3] - ordered[0])
+    h2 = np.linalg.norm(ordered[2] - ordered[1])
+    avg_w, avg_h = (w1 + w2) / 2, (h1 + h2) / 2
+    if min(avg_w, avg_h) < 1:
+        return False
+    return max(avg_w, avg_h) / min(avg_w, avg_h) <= 5.0
+
+
+def expand_quad(quad, img_shape, margin_frac=0.025):
+    center = quad.mean(axis=0)
+    expanded = quad.copy().astype(np.float32)
+    for i in range(len(quad)):
+        vec = quad[i] - center
+        expanded[i] = quad[i] + vec * margin_frac
+    h, w = img_shape[:2]
+    expanded[:, 0] = np.clip(expanded[:, 0], 0, w - 1)
+    expanded[:, 1] = np.clip(expanded[:, 1], 0, h - 1)
+    return expanded
+
+
+def get_binary_strategies(work_img):
+    gray = cv2.cvtColor(work_img, cv2.COLOR_BGR2GRAY)
+    h, w = gray.shape
+    k_close = np.ones((15, 15), np.uint8)
+    k_open  = np.ones((5, 5),   np.uint8)
+    strats  = []
+
+    blurred = cv2.GaussianBlur(gray, (15, 15), 0)
+    _, otsu = cv2.threshold(blurred, 0, 255,
+                            cv2.THRESH_BINARY + cv2.THRESH_OTSU)
+    otsu = cv2.morphologyEx(otsu, cv2.MORPH_CLOSE, k_close, iterations=3)
+    otsu = cv2.morphologyEx(otsu, cv2.MORPH_OPEN, k_open, iterations=1)
+    strats.append(("Otsu", otsu))
+
+    hsv = cv2.cvtColor(work_img, cv2.COLOR_BGR2HSV)
+    v_ch = cv2.GaussianBlur(hsv[:, :, 2], (15, 15), 0)
+    _, v_t = cv2.threshold(v_ch, 0, 255,
+                           cv2.THRESH_BINARY + cv2.THRESH_OTSU)
+    v_t = cv2.morphologyEx(v_t, cv2.MORPH_CLOSE, k_close, iterations=3)
+    v_t = cv2.morphologyEx(v_t, cv2.MORPH_OPEN, k_open, iterations=1)
+    strats.append(("HSV-V", v_t))
+
+    bilateral = cv2.bilateralFilter(gray, 9, 75, 75)
+    bilateral = cv2.GaussianBlur(bilateral, (11, 11), 0)
+    _, bil_t = cv2.threshold(bilateral, 0, 255,
+                             cv2.THRESH_BINARY + cv2.THRESH_OTSU)
+    bil_t = cv2.morphologyEx(bil_t, cv2.MORPH_CLOSE, k_close, iterations=3)
+    bil_t = cv2.morphologyEx(bil_t, cv2.MORPH_OPEN, k_open, iterations=1)
+    strats.append(("Bilateral", bil_t))
+
+    b2    = cv2.GaussianBlur(gray, (9, 9), 0)
+    edges = cv2.Canny(b2, 25, 80)
+    edges = cv2.dilate(edges, np.ones((7, 7), np.uint8), iterations=3)
+    edges = cv2.morphologyEx(edges, cv2.MORPH_CLOSE,
+                             np.ones((13, 13), np.uint8), iterations=2)
+    flood = edges.copy()
+    fmask = np.zeros((h + 2, w + 2), np.uint8)
+    step  = max(1, min(w, h) // 20)
+    for x in range(0, w, step):
+        if flood[0, x] == 0:
+            cv2.floodFill(flood, fmask, (x, 0), 128)
+        if flood[h - 1, x] == 0:
+            cv2.floodFill(flood, fmask, (x, h - 1), 128)
+    for y in range(0, h, step):
+        if flood[y, 0] == 0:
+            cv2.floodFill(flood, fmask, (0, y), 128)
+        if flood[y, w - 1] == 0:
+            cv2.floodFill(flood, fmask, (w - 1, y), 128)
+    doc = np.where(flood == 128, 0, 255).astype(np.uint8)
+    doc = cv2.morphologyEx(doc, cv2.MORPH_CLOSE, k_close, iterations=2)
+    strats.append(("FloodFill", doc))
+
+    return strats
+
+
+def find_notebook_contour(work_img):
+    strategies   = get_binary_strategies(work_img)
+    img_area     = work_img.shape[0] * work_img.shape[1]
+    best_quad    = None
+    best_area    = 0
+    all_quads    = []
+    is_fallback  = False
+    max_cnt      = None
+    max_cnt_area = 0
+
+    for name, binary in strategies:
+        contours, _ = cv2.findContours(binary, cv2.RETR_EXTERNAL,
+                                       cv2.CHAIN_APPROX_SIMPLE)
+        contours = sorted(contours, key=cv2.contourArea, reverse=True)[:5]
+
+        for cnt in contours:
+            area = cv2.contourArea(cnt)
+            if area > max_cnt_area:
+                max_cnt_area = area
+                max_cnt      = cnt
+            if area < 0.15 * img_area:
+                continue
+
+            peri = cv2.arcLength(cnt, True)
+
+            for eps in np.linspace(0.01, 0.1, 20):
+                approx = cv2.approxPolyDP(cnt, eps * peri, True)
+                if len(approx) == 4:
+                    q = approx.reshape(4, 2).astype(np.float32)
+                    if is_valid_quad(q, work_img.shape):
+                        all_quads.append(q)
+                        if area > best_area:
+                            best_area = area
+                            best_quad = q
+                    break
+                elif len(approx) < 4:
+                    break
+
+            hull   = cv2.convexHull(cnt)
+            peri_h = cv2.arcLength(hull, True)
+            for eps in np.linspace(0.01, 0.1, 20):
+                approx = cv2.approxPolyDP(hull, eps * peri_h, True)
+                if len(approx) == 4:
+                    q = approx.reshape(4, 2).astype(np.float32)
+                    if is_valid_quad(q, work_img.shape):
+                        all_quads.append(q)
+                        if area > best_area:
+                            best_area = area
+                            best_quad = q
+                    break
+                elif len(approx) < 4:
+                    break
+
+            if area > 0.20 * img_area:
+                box = cv2.boxPoints(cv2.minAreaRect(cnt)).astype(np.float32)
+                if is_valid_quad(box, work_img.shape):
+                    all_quads.append(box)
+                    if area * 0.90 > best_area:
+                        best_area = area * 0.90
+                        best_quad = box
+
+    if best_quad is None and max_cnt is not None \
+       and max_cnt_area > 0.10 * img_area:
+        box = cv2.boxPoints(cv2.minAreaRect(max_cnt)).astype(np.float32)
+        best_quad   = box
+        all_quads.append(box)
+        is_fallback = True
+
+    return best_quad, all_quads, is_fallback
+
+
+def draw_debug_image(work_img, corners, all_quads, is_fallback):
+    debug = work_img.copy()
+    h, w  = debug.shape[:2]
+    for q in all_quads:
+        cv2.polylines(debug, [q.astype(np.int32)], True, (0, 255, 255), 1)
+    if corners is not None:
+        color = (0, 165, 255) if is_fallback else (0, 255, 0)
+        cv2.polylines(debug, [corners.astype(np.int32)], True, color, 3)
+        ordered = order_points(corners)
+        for i, (pt, lbl, c) in enumerate(zip(
+                ordered, ["TL","TR","BR","BL"],
+                [(255,0,0),(0,0,255),(255,0,255),(0,255,0)])):
+            cx, cy = int(pt[0]), int(pt[1])
+            cv2.circle(debug, (cx, cy), 8, c, -1)
+            cv2.putText(debug, lbl, (cx+10, cy+5),
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.6, c, 2)
+    cv2.rectangle(debug, (0, 0), (w, 40), (0, 0, 0), -1)
+    if corners is not None:
+        s, c = ("FALLBACK", (0,165,255)) if is_fallback \
+               else ("QUAD DETECTED (green outline)", (0,255,0))
+    else:
+        s, c = "NOTHING DETECTED", (0, 0, 255)
+    cv2.putText(debug, s, (10, 25), cv2.FONT_HERSHEY_SIMPLEX, 0.7, c, 2)
+    return debug
+
+
+def save_binary_debug(work_img, debug_path):
+    strategies = get_binary_strategies(work_img)
+    panels = []
+    tw = 300
+    for name, pan in strategies:
+        r   = tw / pan.shape[1]
+        res = cv2.resize(pan, (tw, int(pan.shape[0] * r)))
+        cp  = cv2.cvtColor(res, cv2.COLOR_GRAY2BGR)
+        cv2.putText(cp, name, (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7,
+                    (0, 255, 0), 2)
+        panels.append(cp)
+    mh = max(p.shape[0] for p in panels)
+    padded = []
+    for p in panels:
+        if p.shape[0] < mh:
+            p = np.vstack([p, np.zeros((mh - p.shape[0], p.shape[1], 3),
+                                       np.uint8)])
+        padded.append(p)
+    cv2.imwrite(debug_path.replace("_debug.", "_binary_debug."),
+                np.hstack(padded), [cv2.IMWRITE_JPEG_QUALITY, 85])
+
+
+def process_image(input_path: str):
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    image = cv2.imread(input_path)
+    if image is None:
+        print(f"[ERROR] Cannot read: {input_path}")
+        return
+
+    rotated = cv2.rotate(image, cv2.ROTATE_90_COUNTERCLOCKWISE)
+
+    orig_h, orig_w = rotated.shape[:2]
+
+    max_dim  = 800.0
+    ratio    = max(orig_h, orig_w) / max_dim
+    work_w   = int(orig_w / ratio)
+    work_h   = int(orig_h / ratio)
+    work_img = cv2.resize(rotated, (work_w, work_h))
+
+    corners, all_quads, is_fallback = find_notebook_contour(work_img)
+    stem       = Path(input_path).stem
+    debug_path = os.path.join(script_dir, f"{stem}_debug.jpg")
+
+    if corners is not None:
+        corners_exp = expand_quad(corners, work_img.shape, margin_frac=0.025)
+
+        scale_x = orig_w / work_w
+        scale_y = orig_h / work_h
+        corners_orig = corners_exp.copy()
+        corners_orig[:, 0] *= scale_x
+        corners_orig[:, 1] *= scale_y
+        corners_orig[:, 0] = np.clip(corners_orig[:, 0], 0, orig_w - 1)
+        corners_orig[:, 1] = np.clip(corners_orig[:, 1], 0, orig_h - 1)
+
+        cropped = four_point_transform(rotated, corners_orig)
+        print("[INFO] Success! Applied crop.")
+    else:
+        print("[WARN] Total failure. Returning full rotated image.")
+        cropped = rotated
+
+    debug_img = draw_debug_image(work_img, corners, all_quads, is_fallback)
+    save_binary_debug(work_img, debug_path)
+    cv2.imwrite(debug_path, debug_img, [cv2.IMWRITE_JPEG_QUALITY, 90])
+
+    out_path = os.path.join(script_dir, f"{stem}_cropped.jpg")
+    cv2.imwrite(out_path, cropped, [cv2.IMWRITE_JPEG_QUALITY, 95])
+    print(f"[INFO] Saved cropped: {out_path}")
+
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        script_dir = os.path.dirname(os.path.abspath(__file__))
+        exts = (".jpg", ".jpeg", ".png", ".bmp", ".webp")
+        skip = ("_cropped", "_debug", "_binary_debug")
+        files = [f for f in os.listdir(script_dir)
+                 if f.lower().endswith(exts)
+                 and not any(s in f for s in skip)]
+        if not files:
+            print("Place images next to script or provide paths.")
+            sys.exit(1)
+        for fn in sorted(files):
+            print(f"\nProcessing: {fn}")
+            process_image(os.path.join(script_dir, fn))
+    else:
+        for p in sys.argv[1:]:
+            print(f"\nProcessing: {p}")
+            process_image(p)
+
+
+def auto_crop_process(image_bytes: bytes) -> bytes:
+    """
+    Exact logic from processor.py, but for in-memory bytes.
+    1. Decode JPEG/PNG bytes.
+    2. Rotate 90 deg CCW.
+    3. Detect and crop.
+    4. Return JPEG bytes.
+    """
+    nparr = np.frombuffer(image_bytes, np.uint8)
+    image = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
+    if image is None:
+        return image_bytes
+
+    # 1. Rotate
+    rotated = cv2.rotate(image, cv2.ROTATE_90_COUNTERCLOCKWISE)
+    orig_h, orig_w = rotated.shape[:2]
+
+    # 2. Resize for detection
+    max_dim = 800.0
+    ratio = max(orig_h, orig_w) / max_dim
+    work_w = int(orig_w / ratio)
+    work_h = int(orig_h / ratio)
+    work_img = cv2.resize(rotated, (work_w, work_h))
+
+    # 3. Find contour
+    corners, all_quads, is_fallback = find_notebook_contour(work_img)
+
+    # 4. Transform
+    if corners is not None:
+        corners_exp = expand_quad(corners, work_img.shape, margin_frac=0.025)
+
+        scale_x = orig_w / work_w
+        scale_y = orig_h / work_h
+        corners_orig = corners_exp.copy()
+        corners_orig[:, 0] *= scale_x
+        corners_orig[:, 1] *= scale_y
+        corners_orig[:, 0] = np.clip(corners_orig[:, 0], 0, orig_w - 1)
+        corners_orig[:, 1] = np.clip(corners_orig[:, 1], 0, orig_h - 1)
+
+        cropped = four_point_transform(rotated, corners_orig)
+    else:
+        cropped = rotated
+
+    # 5. Encode back to bytes
+    _, result_bytes = cv2.imencode('.jpg', cropped, [cv2.IMWRITE_JPEG_QUALITY, 95])
+    return result_bytes.tobytes()

requirements.txt

@@ -0,0 +1,6 @@
+fastapi
+uvicorn[standard]
+python-multipart
+httpx
+opencv-python-headless
+numpy