Delete drishx.py

drishx.py

@@ -1,594 +0,0 @@
-import os
-import time
-import json
-import logging
-import pickle
-import requests
-import imageio.v3 as imageio
-import numpy as np
-import geopandas as gpd
-from datetime import datetime, timedelta
-from typing import List
-from concurrent.futures import ThreadPoolExecutor, as_completed
-from shapely.geometry import LineString
-from requests.adapters import HTTPAdapter
-from urllib3.util.retry import Retry
-
-from fastapi import FastAPI, HTTPException
-from fastapi.responses import StreamingResponse, JSONResponse
-from fastapi.staticfiles import StaticFiles
-from fastapi.middleware.cors import CORSMiddleware
-from pydantic import BaseModel
-import uvicorn
-
-import osmnx as ox
-from sentinelhub import (
-    SHConfig, SentinelHubRequest, DataCollection,
-    BBox, CRS, MimeType, SentinelHubCatalog,
-)
-from dotenv import load_dotenv
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Setup
-# ─────────────────────────────────────────────────────────────────────────────
-
-load_dotenv()
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger("ARGUS")
-
-SECONDS_OFFSET_B02_B04 = 1.01
-
-# Hugging Face Spaces için Storage
-DATA_DIR = os.path.join(os.getcwd(), "data")
-DETECTION_DIR = os.path.join(DATA_DIR, "sentinel_data/detections")
-os.makedirs(DETECTION_DIR, exist_ok=True)
-
-# OSM verileri için cache
-os.makedirs(os.path.join(DATA_DIR, "osm_cache"), exist_ok=True)
-
-OVERPASS_MIRRORS = [
-    "https://lz4.overpass-api.de/api/interpreter",
-    "https://z.overpass-api.de/api/interpreter",
-    "https://overpass.osm.ch/api/interpreter",
-    "https://overpass-api.de/api/interpreter",
-]
-
-_session = requests.Session()
-_retry = Retry(
-    total=2, backoff_factor=1.0,
-    status_forcelist=[429, 500, 502, 503, 504],
-    allowed_methods=["GET", "POST"],
-)
-_adapter = HTTPAdapter(max_retries=_retry)
-_session.mount("http://", _adapter)
-_session.mount("https://", _adapter)
-
-ox.settings.requests_session = _session
-ox.settings.requests_timeout = 30
-ox.settings.overpass_rate_limit = False
-ox.settings.max_query_area_size = 1_000_000_000_000
-ox.settings.log_console = False
-ox.settings.use_cache = True
-ox.settings.cache_folder = os.path.join(DATA_DIR, "osm_cache")
-
-# Copernicus Data Space config - Hugging Face env'den oku
-CONFIG = SHConfig()
-CONFIG.sh_client_id = os.getenv("COPERNICUS_CLIENT_ID", "")
-CONFIG.sh_client_secret = os.getenv("COPERNICUS_CLIENT_SECRET", "")
-CONFIG.sh_base_url = "https://sh.dataspace.copernicus.eu"
-CONFIG.sh_token_url = "https://identity.dataspace.copernicus.eu/auth/realms/CDSE/protocol/openid-connect/token"
-CONFIG.cache_dir = os.path.join(DATA_DIR, "sh_cache")
-os.makedirs(CONFIG.cache_dir, exist_ok=True)
-
-logger.info(f"DrishX Storage Link: {DATA_DIR}")
-
-# Hugging Face Spaces'te token'ı env'den al
-if os.getenv("COPERNICUS_TOKEN"):
-    CONFIG.sh_token = os.getenv("COPERNICUS_TOKEN")
-    logger.info("Copernicus token loaded from environment")
-
-FEATURED_SITES = [
-    {"id": "v1", "name": "Braunschweig A7", "bbox": [52.25, 10.45, 52.32, 10.55], "country": "Germany", "type": "high_volume"},
-    {"id": "v2", "name": "Frankfurt A3", "bbox": [50.05, 8.55, 50.12, 8.65], "country": "Germany", "type": "high_volume"},
-    {"id": "v3", "name": "Karlsruhe A5", "bbox": [48.95, 8.35, 49.05, 8.45], "country": "Germany", "type": "standard"},
-]
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Helper functions (kısaltılmış - aynı kod)
-# ─────────────────────────────────────────────────────────────────────────────
-
-def normalized_ratio(a, b):
-    denom = a + b
-    with np.errstate(divide="ignore", invalid="ignore"):
-        result = np.where(denom != 0, (a - b) / denom, 0.0)
-    return result.astype(np.float32)
-
-def rescale_s2(bands):
-    bands = bands.astype(np.float32)
-    if np.nanmax(bands) > 10:
-        bands /= 10000.0
-    return bands
-
-def pick_arr_subset(arr, y, x, size):
-    size_low = size // 2
-    size_up = size // 2
-    if size_low + size_up < size:
-        size_up += 1
-    ymin = max(0, y - size_low)
-    ymax = max(0, y + size_up)
-    xmin = max(0, x - size_low)
-    xmax = max(0, x + size_up)
-    if arr.ndim == 2:
-        return arr[ymin:ymax, xmin:xmax]
-    elif arr.ndim == 3:
-        return arr[:, ymin:ymax, xmin:xmax]
-    return arr
-
-def build_feature_stack(data):
-    R = data[:, :, 0].astype(np.float32)
-    G = data[:, :, 1].astype(np.float32)
-    B = data[:, :, 2].astype(np.float32)
-    NIR = data[:, :, 3].astype(np.float32)
-    CLM = data[:, :, 4]
-
-    bands = np.stack([R, G, B, NIR], axis=0)
-    bands = rescale_s2(bands)
-    R, G, B, NIR = bands[0], bands[1], bands[2], bands[3]
-
-    cloud = CLM > 0
-    R[cloud] = np.nan
-    G[cloud] = np.nan
-    B[cloud] = np.nan
-    NIR[cloud] = np.nan
-
-    H, W = R.shape
-    fs = np.zeros((7, H, W), dtype=np.float32)
-
-    if np.any(~cloud):
-        import warnings
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore", category=RuntimeWarning)
-            fs[0] = np.nanvar(np.stack([R, G, B], axis=0), axis=0, ddof=0)
-            fs[1] = normalized_ratio(R, B)
-            fs[2] = normalized_ratio(G, B)
-            fs[3] = R - np.nanmean(R)
-            fs[4] = G - np.nanmean(G)
-            fs[5] = B - np.nanmean(B)
-            fs[6] = NIR - np.nanmean(NIR)
-    else:
-        fs.fill(np.nan)
-
-    nan_mask = np.isnan(fs[3])
-    fs[:, nan_mask] = np.nan
-
-    return {
-        "feature_stack": fs,
-        "bands": {"R": R, "G": G, "B": B, "NIR": NIR},
-        "cloud_mask": cloud,
-    }
-
-# ─────────────────────────────────────────────────────────────────────────────
-# RF Model (basitleştirilmiş proxy)
-# ─────────────────────────────────────────────────────────────────────────────
-
-_rf_model = None
-
-def load_rf_model(path=None):
-    global _rf_model
-    return None  # Hugging Face'te model yok, proxy kullan
-
-def proxy_classify(feature_stack, road_mask):
-    fs = feature_stack
-    H, W = fs.shape[1], fs.shape[2]
-    probs = np.zeros((4, H, W), dtype=np.float32)
-
-    centered_R = fs[3]
-    centered_G = fs[4]
-    centered_B = fs[5]
-    var_feat = fs[0]
-    nratio_rb = fs[1]
-    nratio_gb = fs[2]
-
-    rm = road_mask.astype(bool)
-    nan_mask = np.isnan(centered_R)
-
-    blue_score = np.clip(-nratio_rb * 2 + centered_B * 5 + var_feat * 10, 0, None)
-    blue_score[~rm | nan_mask] = 0
-
-    green_score = np.clip(nratio_gb * 2 + centered_G * 5 + var_feat * 10, 0, None)
-    green_score[~rm | nan_mask] = 0
-
-    red_score = np.clip(nratio_rb * 2 + centered_R * 5 + var_feat * 10, 0, None)
-    red_score[~rm | nan_mask] = 0
-
-    total = blue_score + green_score + red_score + 1e-8
-    probs[1] = blue_score / total
-    probs[2] = green_score / total
-    probs[3] = red_score / total
-    probs[0] = 1.0 - np.max(probs[1:], axis=0)
-
-    probs[0][probs[0] < 0.75] = 0
-
-    classification = np.nanargmax(probs, axis=0).astype(np.int8) + 1
-    classification[np.max(probs, axis=0) == 0] = 0
-    classification[nan_mask] = 0
-    classification[~rm] = 0
-
-    return probs, classification
-
-# ─────────────────────────────────────────────────────────────────────────────
-# ObjectExtractor (kısaltılmış)
-# ─────────────────────────────────────────────────────────────────────────────
-
-class ObjectExtractor:
-    def __init__(self, probabilities, lat_arr, lon_arr):
-        self.probabilities = probabilities
-        self.lat = lat_arr
-        self.lon = lon_arr
-
-    def extract(self, predictions_arr):
-        preds = predictions_arr.copy()
-        probs = self.probabilities.copy()
-        preds[preds == 1] = 0
-        blue_ys, blue_xs = np.where(preds == 2)
-        detections = []
-        sub_size = 9
-
-        for i in range(len(blue_ys)):
-            y_blue, x_blue = int(blue_ys[i]), int(blue_xs[i])
-            if preds[y_blue, x_blue] == 0:
-                continue
-
-            subset_9 = pick_arr_subset(preds, y_blue, x_blue, sub_size).copy()
-            subset_3 = pick_arr_subset(preds, y_blue, x_blue, 3).copy()
-            subset_9_probs = pick_arr_subset(probs, y_blue, x_blue, sub_size).copy()
-
-            half_idx_y = y_blue if subset_9.shape[0] < sub_size else subset_9.shape[0] // 2
-            half_idx_x = x_blue if subset_9.shape[1] < sub_size else subset_9.shape[1] // 2
-
-            if not all(v in subset_9 for v in [2, 3, 4]):
-                continue
-
-            det = {
-                "lat": float(self.lat[y_blue]),
-                "lon": float(self.lon[x_blue]),
-                "confidence": 0.7,
-                "speed_kmh": 80.0,
-                "heading": 0.0,
-                "timestamp": datetime.now().isoformat(),
-                "id": f"truck_{int(time.time()*1000)}_{y_blue}_{x_blue}.png",
-            }
-            detections.append(det)
-
-        return detections
-
-# ─���───────────────────────────────────────────────────────────────────────────
-# ARGUS Engine
-# ─────────────────────────────────────────────────────────────────────────────
-
-class ARGUSEngine:
-    def __init__(self):
-        self.history = []
-        self.rf_model = load_rf_model()
-
-    def fetch_roads(self, bbox_coords, progress_cb=None):
-        min_lat, min_lon, max_lat, max_lon = bbox_coords
-        center_lat = (min_lat + max_lat) / 2
-        center_lon = (min_lon + max_lon) / 2
-
-        lat_span = (max_lat - min_lat) * 111000
-        lon_span = (max_lon - min_lon) * 111000 * np.cos(np.radians(center_lat))
-        dist_m = int(max(lat_span, lon_span) * 0.6) + 1000
-
-        for mirror in OVERPASS_MIRRORS:
-            ox.settings.overpass_url = mirror
-            try:
-                graph = ox.graph_from_point(
-                    (center_lat, center_lon), dist=dist_m,
-                    network_type="drive", simplify=True,
-                    retain_all=False, truncate_by_edge=True,
-                )
-                roads = ox.graph_to_gdfs(graph, nodes=False)
-                major_types = ["motorway", "trunk", "primary", "secondary", "motorway_link", "trunk_link"]
-                roads = roads[roads["highway"].isin(major_types)].copy()
-                if not roads.empty:
-                    return roads
-            except Exception as e:
-                logger.warning(f"Mirror failed: {e}")
-                time.sleep(1)
-
-        return gpd.GeoDataFrame()
-
-    def detect_trucks(self, data, bbox_coords, timestamp, road_mask):
-        min_lat, min_lon, max_lat, max_lon = bbox_coords
-        H, W = data.shape[:2]
-
-        feat = build_feature_stack(data)
-        feature_stack = feat["feature_stack"]
-
-        probs, prediction = proxy_classify(feature_stack, road_mask)
-
-        lat_arr = np.linspace(max_lat, min_lat, H)
-        lon_arr = np.linspace(min_lon, max_lon, W)
-
-        extractor = ObjectExtractor(probs, lat_arr, lon_arr)
-        detections = extractor.extract(prediction)
-
-        for det in detections:
-            det["timestamp"] = timestamp
-            self._save_crop(data, det, H, W)
-
-        return detections
-
-    def _save_crop(self, data, det, H, W):
-        try:
-            rgb = data[:20, :20, :3].astype(np.float32)
-            rgb = rescale_s2(rgb)
-            rgb = (np.clip(rgb, 0, 0.3) / 0.3 * 255).astype(np.uint8)
-            path = os.path.join(DETECTION_DIR, det["id"])
-            imageio.imwrite(path, rgb)
-        except Exception as e:
-            logger.warning(f"Could not save crop: {e}")
-
-# ─────────────────────────────────────────────────────────────────────────────
-# FastAPI Application
-# ─────────────────────────────────────────────────────────────────────────────
-
-app = FastAPI(title="ARGUS Corridor Intelligence")
-app.add_middleware(
-    CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"],
-)
-
-engine = ARGUSEngine()
-
-class AnalyzeRequest(BaseModel):
-    bbox: List[float]
-    label: str = "New Mission"
-    months: int = 4
-    max_frames: int = 10
-
-@app.post("/api/analyze")
-async def analyze(req: AnalyzeRequest):
-    async def event_generator():
-        try:
-            def progress(msg, pct):
-                return json.dumps({"type": "progress", "message": msg, "percent": pct}) + "\n"
-
-            yield progress(f"Starting analysis for: {req.label}", 0)
-
-            min_lat, min_lon, max_lat, max_lon = req.bbox
-            if abs(max_lat - min_lat) > 0.5 or abs(max_lon - min_lon) > 0.5:
-                yield json.dumps({"type": "error", "message": "AOI too large."}) + "\n"
-                return
-
-            yield progress("Running Road Discovery Pipeline...", 10)
-            roads = engine.fetch_roads(req.bbox)
-            if roads.empty:
-                yield json.dumps({"type": "error", "message": "No major roads found."}) + "\n"
-                return
-            yield progress(f"Found {len(roads)} road corridors.", 25)
-
-            sh_bbox = BBox(bbox=[min_lon, min_lat, max_lon, max_lat], crs=CRS.WGS84)
-            yield progress("Searching Copernicus catalog...", 30)
-
-            catalog = SentinelHubCatalog(config=CONFIG)
-            end_date = datetime.now()
-            start_date = end_date - timedelta(days=max(1, req.months) * 30)
-
-            cdse_collection = DataCollection.SENTINEL2_L2A.define_from(
-                "s2l2a", service_url=CONFIG.sh_base_url,
-            )
-
-            search_results = list(catalog.search(
-                cdse_collection, bbox=sh_bbox,
-                datetime=f"{start_date.strftime('%Y-%m-%dT00:00:00Z')}/{end_date.strftime('%Y-%m-%dT23:59:59Z')}",
-                filter="eo:cloud_cover < 60",
-                fields={"include": ["properties.datetime", "id"], "exclude": []}
-            ))
-
-            unique_scenes = {}
-            for res in search_results:
-                date_key = res["properties"]["datetime"][:10]
-                if date_key not in unique_scenes:
-                    unique_scenes[date_key] = res
-
-            final_obs = [unique_scenes[d] for d in sorted(unique_scenes.keys(), reverse=True)]
-            final_obs = final_obs[:req.max_frames]
-
-            if not final_obs:
-                yield json.dumps({"type": "error", "message": "No clear imagery found."}) + "\n"
-                return
-
-            yield progress(f"Found {len(final_obs)} unique clear overpasses.", 40)
-
-            # İlk frame'i işle
-            first_obs = final_obs[0]
-            date_str = first_obs["properties"]["datetime"]
-
-            req_sh = SentinelHubRequest(
-                evalscript="""//VERSION=3
-function setup() {
-  return {
-    input: ["B02", "B03", "B04", "B08", "CLM"],
-    output: { id: "default", bands: 5, sampleType: "FLOAT32" }
-  };
-}
-function evaluatePixel(s) {
-  return [s.B04, s.B03, s.B02, s.B08, s.CLM];
-}""",
-                input_data=[SentinelHubRequest.input_data(
-                    data_collection=cdse_collection,
-                    time_interval=(date_str, date_str),
-                )],
-                responses=[SentinelHubRequest.output_response("default", MimeType.TIFF)],
-                bbox=sh_bbox, config=CONFIG,
-                size=(512, 512),  # Hugging Face için boyut sınırı
-            )
-
-            data_list = req_sh.get_data()
-            if not data_list:
-                yield json.dumps({"type": "error", "message": "Failed to get satellite data."}) + "\n"
-                return
-
-            seed_data = data_list[0]
-            h, w = seed_data.shape[:2]
-
-            # Road mask
-            from rasterio import features as rio_features, transform as rio_transform
-            roads_buf = roads.to_crs(epsg=3857).buffer(20).to_crs(epsg=4326)
-            trans = rio_transform.from_bounds(min_lon, min_lat, max_lon, max_lat, w, h)
-            road_mask = rio_features.rasterize(
-                [(geom.__geo_interface__, 1) for geom in roads_buf.geometry],
-                out_shape=(h, w), transform=trans, fill=0, all_touched=True,
-            )
-
-            seed_dets = engine.detect_trucks(seed_data, req.bbox, date_str, road_mask)
-
-            detections = seed_dets
-            mission_id = str(int(time.time()))
-            
-            engine.history.append({
-                "mission_id": mission_id,
-                "label": req.label,
-                "bbox": req.bbox,
-                "road_count": len(roads),
-                "detections": detections,
-                "timestamp": datetime.now().isoformat(),
-            })
-
-            yield json.dumps({
-                "type": "result",
-                "mission_id": mission_id,
-                "road_count": len(roads),
-                "detection_count": len(detections),
-                "message": f"Complete: {len(detections)} truck signatures detected.",
-            }) + "\n"
-
-        except Exception as e:
-            logger.error(f"Stream error: {e}", exc_info=True)
-            yield json.dumps({"type": "error", "message": str(e)}) + "\n"
-
-    return StreamingResponse(event_generator(), media_type="application/x-ndjson")
-
-@app.get("/api/sites")
-async def get_sites():
-    sites = [
-        {
-            "id": s["id"], "name": s["name"],
-            "lat": (s["bbox"][0] + s["bbox"][2]) / 2,
-            "lng": (s["bbox"][1] + s["bbox"][3]) / 2,
-            "bbox": s["bbox"], "country": s["country"], "type": s["type"],
-        }
-        for s in FEATURED_SITES
-    ]
-    for h in engine.history:
-        sites.append({
-            "id": h["mission_id"], "name": h["label"],
-            "lat": (h["bbox"][0] + h["bbox"][2]) / 2,
-            "lng": (h["bbox"][1] + h["bbox"][3]) / 2,
-            "bbox": h["bbox"], "country": "ROI", "type": "history",
-        })
-    return sites
-
-@app.get("/api/detections/{mission_id}")
-async def get_detections(mission_id: str):
-    mission = next((h for h in engine.history if h["mission_id"] == mission_id), None)
-    if not mission:
-        raise HTTPException(status_code=404, detail="Mission not found")
-    return mission["detections"]
-
-@app.get("/api/health")
-async def health_check():
-    return {"status": "healthy", "detections": sum(len(h["detections"]) for h in engine.history)}
-
-# Static files
-os.makedirs("frontend", exist_ok=True)
-with open("frontend/index.html", "w") as f:
-    f.write("""<!DOCTYPE html>
-<html>
-<head><title>ARGUS - DrishX</title>
-<style>
-body { font-family: system-ui; max-width: 800px; margin: 40px auto; padding: 20px; background: #0a0a0f; color: #e0e0e0; }
-h1 { color: #3b82f6; }
-button { background: #3b82f6; color: white; border: none; padding: 12px 24px; border-radius: 8px; cursor: pointer; }
-input, textarea { background: #1a1a2e; color: white; border: 1px solid #333; padding: 8px; border-radius: 4px; width: 100%; margin: 8px 0; }
-.card { background: #1a1a2e; padding: 20px; border-radius: 12px; margin: 16px 0; }
-.status { color: #10b981; }
-</style>
-</head>
-<body>
-<h1>🚛 ARGUS - DrishX</h1>
-<p>Corridor Intelligence & Truck Detection</p>
-
-<div class="card">
-    <h3>Analyze Area</h3>
-    <input id="label" placeholder="Mission Label" value="Test Mission">
-    <textarea id="bbox" rows="2">[52.25, 10.45, 52.32, 10.55]</textarea>
-    <button onclick="analyze()">Start Analysis</button>
-</div>
-
-<div id="result" class="card" style="display:none;"></div>
-<div id="progress" class="card" style="display:none;"></div>
-
-<script>
-async function analyze() {
-    const bbox = JSON.parse(document.getElementById('bbox').value);
-    const label = document.getElementById('label').value;
-    
-    document.getElementById('result').style.display = 'none';
-    document.getElementById('progress').style.display = 'block';
-    document.getElementById('progress').innerHTML = 'Starting analysis...';
-    
-    try {
-        const response = await fetch('/api/analyze', {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ bbox, label, months: 4, max_frames: 3 })
-        });
-        
-        const reader = response.body.getReader();
-        const decoder = new TextDecoder();
-        let result = '';
-        
-        while (true) {
-            const {done, value} = await reader.read();
-            if (done) break;
-            
-            const chunk = decoder.decode(value);
-            const lines = chunk.split('\\n').filter(l => l.trim());
-            
-            for (const line of lines) {
-                try {
-                    const data = JSON.parse(line);
-                    if (data.type === 'progress') {
-                        document.getElementById('progress').innerHTML = 
-                            `<b>${data.percent}%</b> - ${data.message}`;
-                    } else if (data.type === 'result') {
-                        document.getElementById('result').style.display = 'block';
-                        document.getElementById('result').innerHTML = 
-                            `<h3>✅ ${data.message}</h3>
-                            <p>Detections: ${data.detection_count}</p>
-                            <p>Mission ID: ${data.mission_id}</p>`;
-                        document.getElementById('progress').style.display = 'none';
-                    } else if (data.type === 'error') {
-                        document.getElementById('progress').innerHTML = 
-                            `<b style="color:red;">❌ ${data.message}</b>`;
-                    }
-                } catch(e) {}
-            }
-        }
-    } catch(err) {
-        document.getElementById('progress').innerHTML = 
-            `<b style="color:red;">Error: ${err.message}</b>`;
-    }
-}
-</script>
-</body>
-</html>""")
-
-app.mount("/detections", StaticFiles(directory=DETECTION_DIR), name="detections")
-app.mount("/", StaticFiles(directory="frontend", html=True), name="frontend")
-
-if __name__ == "__main__":
-    uvicorn.run(app, host="0.0.0.0", port=7860)