Upload 4 files

Dockerfile

@@ -0,0 +1,23 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y \
+    libgl1 \
+    libglib2.0-0 \
+    wget \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Download Models
+RUN mkdir -p weights && \
+    wget -O weights/yolo12_cls.pt https://huggingface.co/Subh775/Yolo12-cls.latest_ep15.bsl/resolve/main/weights/best.pt && \
+    mkdir -p /tmp && \
+    wget -O /tmp/checkpoint_best_total.pth https://huggingface.co/Subh775/Seg-Basil-rfdetr/resolve/main/checkpoint_best_total.pth
+
+COPY . .
+
+EXPOSE 7860
+CMD ["python", "app.py"]

app.py

@@ -0,0 +1,122 @@
+import os
+import io
+import base64
+import gc
+import torch
+import numpy as np
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import HTMLResponse
+from pydantic import BaseModel
+from PIL import Image
+from ultralytics import YOLO
+import supervision as sv
+
+# Environment setup for CPU efficiency
+os.environ["CUDA_VISIBLE_DEVICES"] = ""
+os.environ["OMP_NUM_THREADS"] = "4"
+torch.set_num_threads(4)
+
+# Import local RF-DETR wrapper (assuming the library is installed)
+from rfdetr import RFDETRSegPreview
+
+app = FastAPI()
+
+# Model paths and Globals
+SEG_MODEL_PATH = "/tmp/checkpoint_best_total.pth"
+CLS_MODEL_PATH = "weights/yolo12_cls.pt"
+
+models = {"seg": None, "cls": None}
+
+def load_models():
+    if models["seg"] is None:
+        # RF-DETR Initialization
+        models["seg"] = RFDETRSegPreview(pretrain_weights=SEG_MODEL_PATH)
+        models["seg"].optimize_for_inference()
+    if models["cls"] is None:
+        # YOLO12-cls Initialization
+        models["cls"] = YOLO(CLS_MODEL_PATH)
+
+class PredictionConfig(BaseModel):
+    image: str
+    seg_enabled: bool
+    seg_conf: float
+    seg_show_conf: bool
+    cls_enabled: bool
+    cls_show_conf: bool
+    cls_show_label: bool
+
+@app.get("/", response_class=HTMLResponse)
+async def serve_ui():
+    with open("index.html", "r") as f:
+        return f.read()
+
+@app.post("/predict")
+async def predict(config: PredictionConfig):
+    load_models()
+    
+    try:
+        # Decode image
+        header, encoded = config.image.split(",", 1) if "," in config.image else (None, config.image)
+        img_bytes = base64.b64decode(encoded)
+        original_img = Image.open(io.BytesIO(img_bytes)).convert("RGB")
+        
+        # 1. Segmentation Phase
+        detections = models["seg"].predict(original_img, threshold=config.seg_conf)
+        
+        if len(detections) == 0:
+            return {"annotated": config.image, "count": 0}
+
+        # 2. Classification Phase (if enabled)
+        labels = []
+        if config.cls_enabled:
+            for i in range(len(detections.xyxy)):
+                x1, y1, x2, y2 = detections.xyxy[i].astype(int)
+                crop = original_img.crop((x1, y1, x2, y2))
+                cls_res = models["cls"](crop)[0]
+                
+                top1_idx = cls_res.probs.top1
+                name = cls_res.names[top1_idx]
+                conf = float(cls_res.probs.top1conf)
+                
+                label_str = ""
+                if config.cls_show_label: label_str += f"{name} "
+                if config.cls_show_conf: label_str += f"{conf:.2f}"
+                labels.append(label_str.strip())
+        else:
+            # Fallback to generic labels or segmentation conf
+            for conf in detections.confidence:
+                labels.append(f"Leaf {conf:.2f}" if config.seg_show_conf else "Leaf")
+
+        # 3. Annotation Phase
+        palette = sv.ColorPalette.from_hex(["#EA782D", "#FF7A5A", "#FFA382"])
+        mask_annotator = sv.MaskAnnotator(color=palette)
+        label_annotator = sv.LabelAnnotator(
+            color=palette, 
+            text_position=sv.Position.CENTER_OF_MASS,
+            text_scale=0.5
+        )
+
+        annotated_img = original_img.copy()
+        if config.seg_enabled:
+            annotated_img = mask_annotator.annotate(scene=annotated_img, detections=detections)
+        
+        annotated_img = label_annotator.annotate(scene=annotated_img, detections=detections, labels=labels)
+
+        # Encode result
+        buffered = io.BytesIO()
+        annotated_img.save(buffered, format="PNG")
+        encoded_res = base64.b64encode(buffered.getvalue()).decode("ascii")
+        
+        return {
+            "annotated": f"data:image/png;base64,{encoded_res}",
+            "count": len(detections)
+        }
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+    finally:
+        gc.collect()
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)

index.html

@@ -0,0 +1,258 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Tulsi Analytics — DETR & YOLO12</title>
+    <style>
+        :root {
+            --primary-orange: #EA782D;
+            --accent-orange: #FF7A5A;
+            --dark-bg: #121212;
+            --surface: #1E1E2E;
+            --text: #E0E0E0;
+            --border: rgba(255, 255, 255, 0.1);
+        }
+
+        body {
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+            background: var(--dark-bg);
+            color: var(--text);
+            margin: 0;
+            padding: 20px;
+        }
+
+        .container {
+            max-width: 1400px;
+            margin: 0 auto;
+            background: var(--surface);
+            border-radius: 12px;
+            border: 1px solid var(--border);
+            overflow: hidden;
+        }
+
+        header {
+            padding: 25px;
+            text-align: center;
+            border-bottom: 1px solid var(--border);
+            background: rgba(0,0,0,0.2);
+        }
+
+        h1 { color: var(--primary-orange); margin: 0; font-weight: 500; }
+
+        .layout {
+            display: grid;
+            grid-template-columns: 1fr 1fr;
+            gap: 20px;
+            padding: 20px;
+        }
+
+        @media (max-width: 1000px) {
+            .layout { grid-template-columns: 1fr; }
+        }
+
+        .panel {
+            background: rgba(0,0,0,0.15);
+            padding: 20px;
+            border-radius: 10px;
+        }
+
+        .image-view {
+            width: 100%;
+            height: 450px;
+            background: #000;
+            border-radius: 8px;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            margin-bottom: 15px;
+            border: 1px solid var(--border);
+            overflow: hidden;
+        }
+
+        img { max-width: 100%; max-height: 100%; object-fit: contain; }
+
+        .controls {
+            display: flex;
+            flex-direction: column;
+            gap: 15px;
+        }
+
+        .control-row {
+            display: flex;
+            align-items: center;
+            justify-content: space-between;
+            padding: 10px;
+            background: rgba(255,255,255,0.03);
+            border-radius: 6px;
+        }
+
+        .slider-group { padding: 10px; }
+        input[type="range"] { width: 100%; accent-color: var(--primary-orange); }
+
+        /* Toggle Switch */
+        .switch {
+            position: relative;
+            display: inline-block;
+            width: 44px;
+            height: 22px;
+        }
+        .switch input { opacity: 0; width: 0; height: 0; }
+        .slider {
+            position: absolute;
+            cursor: pointer;
+            top: 0; left: 0; right: 0; bottom: 0;
+            background-color: #444;
+            transition: .4s;
+            border-radius: 34px;
+        }
+        .slider:before {
+            position: absolute;
+            content: "";
+            height: 16px; width: 16px;
+            left: 3px; bottom: 3px;
+            background-color: white;
+            transition: .4s;
+            border-radius: 50%;
+        }
+        input:checked + .slider { background-color: var(--primary-orange); }
+        input:checked + .slider:before { transform: translateX(22px); }
+
+        .predict-btn {
+            background: var(--primary-orange);
+            color: white;
+            border: none;
+            padding: 15px;
+            border-radius: 8px;
+            font-weight: 600;
+            cursor: pointer;
+            transition: 0.2s;
+            width: 100%;
+        }
+        .predict-btn:hover { background: var(--accent-orange); }
+        .predict-btn:disabled { opacity: 0.5; cursor: not-allowed; }
+
+        .upload-box {
+            border: 2px dashed var(--border);
+            padding: 20px;
+            text-align: center;
+            cursor: pointer;
+            margin-bottom: 15px;
+        }
+    </style>
+</head>
+<body>
+
+<div class="container">
+    <header>
+        <h1>Tulsi Disease Analyzer</h1>
+    </header>
+
+    <div class="layout">
+        <div class="panel">
+            <div class="upload-box" id="drop-zone">Click or Drop Image Here</div>
+            <input type="file" id="file-input" hidden accept="image/*">
+            
+            <div class="image-view">
+                <img id="input-preview" src="" style="display:none;">
+            </div>
+
+            <div class="controls">
+                <div class="control-row">
+                    <span>Enable Segmentation</span>
+                    <label class="switch"><input type="checkbox" id="seg-enable" checked><span class="slider"></span></label>
+                </div>
+                <div class="slider-group">
+                    <label>Seg. Confidence: <span id="seg-val">0.25</span></label>
+                    <input type="range" id="seg-conf" min="5" max="95" value="25">
+                </div>
+                <div class="control-row">
+                    <span>Show Seg. Confidence</span>
+                    <label class="switch"><input type="checkbox" id="seg-show-conf"><span class="slider"></span></label>
+                </div>
+
+                <div class="control-row">
+                    <span>Enable Classification</span>
+                    <label class="switch"><input type="checkbox" id="cls-enable" checked><span class="slider"></span></label>
+                </div>
+                <div class="control-row">
+                    <span>Show Label</span>
+                    <label class="switch"><input type="checkbox" id="cls-show-label" checked><span class="slider"></span></label>
+                </div>
+                <div class="control-row">
+                    <span>Show Cls. Confidence</span>
+                    <label class="switch"><input type="checkbox" id="cls-show-conf" checked><span class="slider"></span></label>
+                </div>
+
+                <button id="predict-btn" class="predict-btn" disabled>Run Analysis</button>
+            </div>
+        </div>
+
+        <div class="panel">
+            <h3 style="margin-top:0;">Analysis Result</h3>
+            <div class="image-view">
+                <img id="output-preview" src="">
+            </div>
+            <div id="status">Status: Waiting for input</div>
+        </div>
+    </div>
+</div>
+
+<script>
+    const fileInput = document.getElementById('file-input');
+    const dropZone = document.getElementById('drop-zone');
+    const inputImg = document.getElementById('input-preview');
+    const outputImg = document.getElementById('output-preview');
+    const predictBtn = document.getElementById('predict-btn');
+    const segConf = document.getElementById('seg-conf');
+    const segVal = document.getElementById('seg-val');
+
+    segConf.oninput = () => segVal.innerText = (segConf.value / 100).toFixed(2);
+
+    dropZone.onclick = () => fileInput.click();
+    fileInput.onchange = (e) => handleFile(e.target.files[0]);
+
+    function handleFile(file) {
+        if (!file) return;
+        const reader = new FileReader();
+        reader.onload = (e) => {
+            inputImg.src = e.target.result;
+            inputImg.style.display = 'block';
+            predictBtn.disabled = false;
+        };
+        reader.readAsDataURL(file);
+    }
+
+    predictBtn.onclick = async () => {
+        predictBtn.disabled = true;
+        predictBtn.innerText = "Processing...";
+        
+        const payload = {
+            image: inputImg.src,
+            seg_enabled: document.getElementById('seg-enable').checked,
+            seg_conf: segConf.value / 100,
+            seg_show_conf: document.getElementById('seg-show-conf').checked,
+            cls_enabled: document.getElementById('cls-enable').checked,
+            cls_show_conf: document.getElementById('cls-show-conf').checked,
+            cls_show_label: document.getElementById('cls-show-label').checked
+        };
+
+        try {
+            const resp = await fetch('/predict', {
+                method: 'POST',
+                headers: {'Content-Type': 'application/json'},
+                body: JSON.stringify(payload)
+            });
+            const data = await resp.json();
+            outputImg.src = data.annotated;
+            document.getElementById('status').innerText = `Status: Detected ${data.count} leaves`;
+        } catch (e) {
+            alert("Error running inference");
+        } finally {
+            predictBtn.disabled = false;
+            predictBtn.innerText = "Run Analysis";
+        }
+    };
+</script>
+</body>
+</html>

requirements.txt

@@ -0,0 +1,9 @@
+fastapi
+uvicorn
+ultralytics
+supervision
+pillow
+numpy
+torch
+requests
+rfdetr