app.py

# app_demo.py — DEMO (somente interface Gradio, sem executar IA/processamento)
# Requisitos: gradio>=4.26.0
#
# Este app:
# - Mantém a mesma ideia das 5 abas (GPX → Frames → Segmentação → Resize → Inferência)
# - NÃO usa torch/cv2/transformers/pandas/exiftool
# - Gera arquivos “mock” (GPX/ZIP/CSV/GEOJSON) só para download e para a UI ficar funcional

import os
import json
import time
import zipfile
import tempfile
from datetime import datetime
import gradio as gr


STATE = {}  # guarda caminhos dos “artefatos” demo


# -------------------------
# Helpers (gera arquivos falsos)
# -------------------------
def _tmpdir(prefix="demo_"):
    return tempfile.mkdtemp(prefix=prefix)

def _write_text(path, text, encoding="utf-8"):
    os.makedirs(os.path.dirname(path), exist_ok=True)
    with open(path, "w", encoding=encoding) as f:
        f.write(text)

def _create_dummy_gpx(out_path: str, track_name="demo_track"):
    gpx = f"""<?xml version="1.0" encoding="UTF-8"?>
<gpx version="1.1" creator="DEMO - Gradio" xmlns="http://www.topografix.com/GPX/1/1">
  <metadata>
    <name>{track_name}</name>
    <time>{datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%SZ")}</time>
  </metadata>
  <trk>
    <name>{track_name}</name>
    <trkseg>
      <trkpt lat="38.722252" lon="-9.139337"><time>{datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%SZ")}</time></trkpt>
      <trkpt lat="38.722300" lon="-9.139200"><time>{datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%SZ")}</time></trkpt>
      <trkpt lat="38.722380" lon="-9.139050"><time>{datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%SZ")}</time></trkpt>
    </trkseg>
  </trk>
</gpx>
"""
    _write_text(out_path, gpx)

def _create_dummy_zip(out_path: str, kind="frames"):
    """
    kind:
      - "frames": zip com 3 jpg “fake”
      - "segmentacao": zip com pastas class_6_road, class_11_sidewalk, class_9_grass e jpg “fake”
      - "224": zip com as mesmas pastas, mas “redimensionadas”
    """
    tmp = _tmpdir("demo_zip_")
    if kind == "frames":
        files = ["frame_000000_lat_38.722252_lon_-9.139337.jpg",
                 "frame_000030_lat_38.722300_lon_-9.139200.jpg",
                 "frame_000060_lat_38.722380_lon_-9.139050.jpg"]
        for name in files:
            _write_text(os.path.join(tmp, name), "DEMO IMAGE BYTES PLACEHOLDER\n")
    else:
        mapping = {
            "class_6_road": ["img_001_class_6_road.jpg", "img_002_class_6_road.jpg"],
            "class_11_sidewalk": ["img_003_class_11_sidewalk.jpg"],
            "class_9_grass": ["img_004_class_9_grass.jpg"],
        }
        for folder, imgs in mapping.items():
            folder_path = os.path.join(tmp, folder)
            os.makedirs(folder_path, exist_ok=True)
            for img in imgs:
                _write_text(os.path.join(folder_path, img), f"DEMO {kind} PLACEHOLDER\n")

        # incluir um csv fake no zip (no caso de segmentacao/224)
        _write_text(os.path.join(tmp, "resultados_segmentacao.csv"),
                    "imagem,classe_id,classe_nome,latitude,longitude,pixels_classe,pixels_totais,proporcao_classe_%\n"
                    "img_001_class_6_road.jpg,6,road,38.722252,-9.139337,12345,50176,24.60\n")

    # zipar
    with zipfile.ZipFile(out_path, "w", zipfile.ZIP_DEFLATED) as zf:
        for root, _, files in os.walk(tmp):
            for f in files:
                full = os.path.join(root, f)
                arc = os.path.relpath(full, tmp)
                zf.write(full, arc)

def _create_dummy_csv_and_geojson(out_dir: str, classe: str):
    csv_path = os.path.join(out_dir, f"inferencia_{classe}_vit.csv")
    geojson_path = os.path.join(out_dir, f"inferencia_{classe}_vit.geojson")

    csv_text = (
        "imagem,classe_predita,confianca,latitude,longitude,timestamp\n"
        f"img_001_{classe}.jpg,{classe},0.91,38.722252,-9.139337,{datetime.utcnow().isoformat()}\n"
        f"img_002_{classe}.jpg,{classe},0.88,38.722300,-9.139200,{datetime.utcnow().isoformat()}\n"
    )
    _write_text(csv_path, csv_text)

    geo = {
        "type": "FeatureCollection",
        "features": [
            {
                "type": "Feature",
                "geometry": {"type": "Point", "coordinates": [-9.139337, 38.722252]},
                "properties": {"imagem": f"img_001_{classe}.jpg", "classe_predita": classe, "confianca": 0.91}
            },
            {
                "type": "Feature",
                "geometry": {"type": "Point", "coordinates": [-9.139200, 38.722300]},
                "properties": {"imagem": f"img_002_{classe}.jpg", "classe_predita": classe, "confianca": 0.88}
            },
        ],
    }
    _write_text(geojson_path, json.dumps(geo, indent=2, ensure_ascii=False))

    return csv_path, geojson_path


# -------------------------
# Aba 1 — DEMO GPX
# -------------------------
def aba1_demo_extrair_gpx(video_file, exiftool_path, progress=gr.Progress()):
    logs = []
    def log(msg):
        logs.append(msg)
        progress(0.2, desc=msg)

    if not video_file:
        log("❌ DEMO: Nenhum vídeo selecionado.")
        return None, "\n".join(logs)

    # Só para simular
    log("🎬 DEMO: Recebi um vídeo (não será processado).")
    time.sleep(0.2)
    log("🛰️ DEMO: Simulando extração de telemetria...")
    time.sleep(0.2)

    out_dir = _tmpdir("demo_gpx_")
    base = "demo_video"
    out_gpx = os.path.join(out_dir, f"{base}.gpx")
    _create_dummy_gpx(out_gpx, track_name=base)

    STATE["gpx_path"] = out_gpx
    log("✅ DEMO: GPX gerado com sucesso (arquivo mock).")
    progress(1.0, desc="Concluído!")
    return out_gpx, "\n".join(logs)


# -------------------------
# Aba 2 — DEMO Frames ZIP
# -------------------------
def aba2_demo_extrair_frames(video_file, gpx_file, frame_interval, progress=gr.Progress()):
    logs = []
    def log(msg):
        logs.append(msg)

    if not video_file:
        log("❌ DEMO: Nenhum vídeo selecionado.")
        return None, "\n".join(logs)
    if not gpx_file:
        log("❌ DEMO: Nenhum GPX selecionado.")
        return None, "\n".join(logs)

    progress(0.2, desc="DEMO: Simulando extração de frames...")
    time.sleep(0.2)

    zip_path = os.path.join(tempfile.gettempdir(), "frames_georreferenciados_DEMO.zip")
    _create_dummy_zip(zip_path, kind="frames")
    STATE["frames_zip"] = zip_path

    log(f"✅ DEMO: ZIP de frames gerado (mock). Intervalo solicitado: {frame_interval}")
    progress(1.0, desc="Concluído!")
    return zip_path, "\n".join(logs)


# -------------------------
# Aba 3 — DEMO Segmentação ZIP + CSV
# -------------------------
def aba3_demo_segmentacao(zip_file, batch_size, progress=gr.Progress()):
    logs = []
    def log(msg):
        logs.append(msg)

    if not zip_file:
        log("❌ DEMO: Nenhum ZIP selecionado.")
        return None, None, "\n".join(logs)

    progress(0.2, desc="DEMO: Carregando modelo (fake)...")
    time.sleep(0.2)
    progress(0.5, desc="DEMO: Segmentando imagens (fake)...")
    time.sleep(0.2)

    out_dir = _tmpdir("demo_seg_")
    csv_path = os.path.join(out_dir, "resultados_segmentacao.csv")
    _write_text(csv_path,
                "imagem,classe_id,classe_nome,latitude,longitude,pixels_classe,pixels_totais,proporcao_classe_%\n"
                "img_001_class_6_road.jpg,6,road,38.722252,-9.139337,12345,50176,24.60\n"
                "img_003_class_11_sidewalk.jpg,11,sidewalk,38.722300,-9.139200,8000,50176,15.94\n"
                "img_004_class_9_grass.jpg,9,grass,38.722380,-9.139050,6000,50176,11.96\n")

    zip_output = os.path.join(tempfile.gettempdir(), "segmentacao_classes_DEMO.zip")
    _create_dummy_zip(zip_output, kind="segmentacao")

    STATE["segmentacao_zip"] = zip_output
    log(f"✅ DEMO: Segmentação concluída (mock). Batch solicitado: {batch_size}")
    progress(1.0, desc="Concluído!")
    return zip_output, csv_path, "\n".join(logs)


# -------------------------
# Aba 4 — DEMO Resize 224 ZIP + Manifest CSV
# -------------------------
def aba4_demo_redimensionar(zip_file, progress=gr.Progress()):
    logs = []
    def log(msg):
        logs.append(msg)

    if not zip_file:
        log("❌ DEMO: Nenhum ZIP selecionado.")
        return None, None, "\n".join(logs)

    progress(0.3, desc="DEMO: Redimensionando para 224×224 (fake)...")
    time.sleep(0.2)

    out_dir = _tmpdir("demo_224_")
    csv_path = os.path.join(out_dir, "manifest_224x224.csv")
    _write_text(csv_path,
                "original_path,output_path,latitude,longitude,size\n"
                "class_6_road/img_001_class_6_road.jpg,class_6_road/img_001_class_6_road.jpg,38.722252,-9.139337,224x224\n"
                "class_11_sidewalk/img_003_class_11_sidewalk.jpg,class_11_sidewalk/img_003_class_11_sidewalk.jpg,38.722300,-9.139200,224x224\n"
                "class_9_grass/img_004_class_9_grass.jpg,class_9_grass/img_004_class_9_grass.jpg,38.722380,-9.139050,224x224\n")

    zip_output = os.path.join(tempfile.gettempdir(), "segmentacao_224x224_DEMO.zip")
    _create_dummy_zip(zip_output, kind="224")

    STATE["zip_224"] = zip_output
    log("✅ DEMO: ZIP 224×224 gerado (mock).")
    progress(1.0, desc="Concluído!")
    return zip_output, csv_path, "\n".join(logs)


# -------------------------
# Aba 5 — DEMO Preparar ZIPs por classe
# -------------------------
def aba5_demo_preparar_zips(zip_file_224, progress=gr.Progress()):
    logs = []
    def log(msg):
        logs.append(msg)

    if not zip_file_224:
        log("❌ DEMO: Nenhum ZIP 224×224 selecionado.")
        return "\n".join(logs), None, None, None, gr.update(choices=[])

    progress(0.4, desc="DEMO: Preparando ZIPs por classe (fake)...")
    time.sleep(0.2)

    # Criar 3 zips mock
    zip_paths = {}
    for classe in ("road", "sidewalk", "grass"):
        zp = os.path.join(tempfile.gettempdir(), f"{classe}_224x224_DEMO.zip")
        _create_dummy_zip(zp, kind="224")
        zip_paths[classe] = zp

    STATE["class_zips"] = zip_paths

    log("✅ DEMO: ZIPs separados por classe prontos (mock).")
    progress(1.0, desc="Concluído!")
    choices = list(zip_paths.keys())
    return (
        "\n".join(logs),
        zip_paths.get("road"),
        zip_paths.get("sidewalk"),
        zip_paths.get("grass"),
        gr.update(choices=choices, value=choices[0] if choices else None),
    )


# -------------------------
# Aba 5 — DEMO Inferência (gera CSV + GeoJSON)
# -------------------------
def aba5_demo_inferencia(classe_selecionada, model_file, metadata_file, progress=gr.Progress()):
    logs = []
    def log(msg):
        logs.append(msg)

    if not classe_selecionada:
        log("❌ DEMO: Nenhuma classe selecionada.")
        return None, None, "\n".join(logs)

    progress(0.3, desc="DEMO: Carregando modelo ViT (fake)...")
    time.sleep(0.2)
    progress(0.6, desc="DEMO: Inferindo (fake)...")
    time.sleep(0.2)

    out_dir = _tmpdir("demo_infer_")
    csv_path, geojson_path = _create_dummy_csv_and_geojson(out_dir, classe_selecionada)

    log("✅ DEMO: Inferência concluída (mock).")
    log(f"📄 CSV: {os.path.basename(csv_path)}")
    log(f"🗺️  GeoJSON: {os.path.basename(geojson_path)}")
    progress(1.0, desc="Concluído!")
    return csv_path, geojson_path, "\n".join(logs)


# -------------------------
# Interface
# -------------------------
def create_interface():
    with gr.Blocks(title="Processador de Vídeos (DEMO)", theme=gr.themes.Soft()) as app:
        gr.Markdown(
            """
# 🗺️ ROUNDB - Processador de Vídeos - IA (DEMO)

✅ **Este é um DEMO de interface.**  
- Não executa IA, não usa ExifTool, não processa vídeo.  
- Os botões geram **arquivos “mock”** para download (GPX/ZIP/CSV/GeoJSON) e logs para demonstrar o fluxo.

**Fluxo sugerido:** Aba 1 → 2 → 3 → 4 → 5
"""
        )

        with gr.Tabs():
            # -------- Aba 1
            with gr.Tab("1️⃣ Extração de GPX (DEMO)"):
                gr.Markdown("## 📍 Extrator de GPX (DEMO)")
                with gr.Row():
                    with gr.Column():
                        video_input_1 = gr.File(label="📹 Vídeo", file_types=["video"], type="filepath")
                        exiftool_input_1 = gr.Textbox(
                            label="🔧 Caminho do ExifTool (opcional, DEMO)",
                            placeholder="C:/exiftool",
                            value="",
                        )
                        btn1 = gr.Button("🚀 Extrair GPX (DEMO)", variant="primary")
                    with gr.Column():
                        log1 = gr.Textbox(label="📋 Log", lines=16, interactive=False)
                        gpx_out = gr.File(label="📥 Download do GPX (mock)")

                btn1.click(
                    fn=aba1_demo_extrair_gpx,
                    inputs=[video_input_1, exiftool_input_1],
                    outputs=[gpx_out, log1],
                )

            # -------- Aba 2
            with gr.Tab("2️⃣ Frames Georreferenciados (DEMO)"):
                gr.Markdown("## 🎬 Extrator de Frames (DEMO)")
                with gr.Row():
                    with gr.Column():
                        video_input_2 = gr.File(label="📹 Vídeo (mesmo da Aba 1)", file_types=["video"], type="filepath")
                        gpx_input_2 = gr.File(label="🗺️ GPX (gerado na Aba 1)", file_types=[".gpx"], type="filepath")
                        frame_interval = gr.Slider(1, 300, value=30, step=1, label="📸 Intervalo de Frames (DEMO)")
                        btn2 = gr.Button("🚀 Extrair Frames (DEMO)", variant="primary")
                    with gr.Column():
                        log2 = gr.Textbox(label="📋 Log", lines=16, interactive=False)
                        frames_zip = gr.File(label="📥 Download (ZIP frames mock)")

                gpx_out.change(fn=lambda v, g: (v, g), inputs=[video_input_1, gpx_out], outputs=[video_input_2, gpx_input_2])

                btn2.click(
                    fn=aba2_demo_extrair_frames,
                    inputs=[video_input_2, gpx_input_2, frame_interval],
                    outputs=[frames_zip, log2],
                )

            # -------- Aba 3
            with gr.Tab("3️⃣ Segmentação (ADE20K) (DEMO)"):
                gr.Markdown("## 🤖 Segmentação Semântica (DEMO)")
                with gr.Row():
                    with gr.Column():
                        zip_in_3 = gr.File(label="📦 ZIP de frames (Aba 2)", file_types=[".zip"], type="filepath")
                        batch = gr.Slider(1, 16, value=4, step=1, label="📊 Batch size (DEMO)")
                        btn3 = gr.Button("🚀 Processar Segmentação (DEMO)", variant="primary")
                    with gr.Column():
                        log3 = gr.Textbox(label="📋 Log", lines=16, interactive=False)
                        zip_out_3 = gr.File(label="📥 ZIP (segmentação mock)")
                        csv_out_3 = gr.File(label="📊 CSV (mock)")

                frames_zip.change(fn=lambda x: x, inputs=[frames_zip], outputs=[zip_in_3])

                btn3.click(
                    fn=aba3_demo_segmentacao,
                    inputs=[zip_in_3, batch],
                    outputs=[zip_out_3, csv_out_3, log3],
                )

            # -------- Aba 4
            with gr.Tab("4️⃣ Redimensionar 224×224 (DEMO)"):
                gr.Markdown("## 🧰 Redimensionar para 224×224 (DEMO)")
                with gr.Row():
                    with gr.Column():
                        zip_in_4 = gr.File(label="📦 ZIP da Aba 3", file_types=[".zip"], type="filepath")
                        btn4 = gr.Button("🚀 Redimensionar (DEMO)", variant="primary")
                    with gr.Column():
                        log4 = gr.Textbox(label="📋 Log", lines=16, interactive=False)
                        zip_out_4 = gr.File(label="📥 ZIP 224×224 (mock)")
                        csv_out_4 = gr.File(label="📊 Manifest CSV (mock)")

                zip_out_3.change(fn=lambda x: x, inputs=[zip_out_3], outputs=[zip_in_4])

                btn4.click(
                    fn=aba4_demo_redimensionar,
                    inputs=[zip_in_4],
                    outputs=[zip_out_4, csv_out_4, log4],
                )

            # -------- Aba 5
            with gr.Tab("5️⃣ Inferência (ViT) (DEMO)"):
                gr.Markdown(
                    """
## 🧪 Inferência com ViT (DEMO)

**Passo 1:** Preparar ZIPs por classe (mock)  
**Passo 2:** Selecionar classe e gerar CSV/GeoJSON (mock)
"""
                )

                with gr.Row():
                    with gr.Column():
                        gr.Markdown("### 📦 Passo 1: Preparar ZIPs por Classe (DEMO)")
                        zip_in_5 = gr.File(label="📦 ZIP 224×224 (Aba 4)", file_types=[".zip"], type="filepath")
                        btn5_prep = gr.Button("🔧 Preparar ZIPs (DEMO)", variant="secondary")
                    with gr.Column():
                        log5_prep = gr.Textbox(label="📋 Log Preparação", lines=8, interactive=False)
                        road_zip = gr.File(label="🛣️ Road ZIP (mock)", visible=False)
                        sidewalk_zip = gr.File(label="🚶 Sidewalk ZIP (mock)", visible=False)
                        grass_zip = gr.File(label="🌱 Grass ZIP (mock)", visible=False)

                zip_out_4.change(fn=lambda x: x, inputs=[zip_out_4], outputs=[zip_in_5])

                gr.Markdown("---")
                with gr.Row():
                    with gr.Column():
                        gr.Markdown("### 🧠 Passo 2: Executar Inferência (DEMO)")
                        classe_dd = gr.Dropdown(label="🎯 Selecione a Classe", choices=[], value=None, interactive=True)
                        model_in = gr.File(label="🧠 Modelo ViT (.pth) (opcional, ignorado no DEMO)", file_types=[".pth"], type="filepath")
                        meta_in = gr.File(label="📄 metadata.json (opcional, ignorado no DEMO)", file_types=[".json"], type="filepath")
                        btn5_inf = gr.Button("🚀 Executar Inferência (DEMO)", variant="primary")
                    with gr.Column():
                        log5_inf = gr.Textbox(label="📋 Log Inferência", lines=12, interactive=False)
                        csv_out_5 = gr.File(label="📊 CSV Resultados (mock)")
                        geo_out_5 = gr.File(label="🗺️ GeoJSON (mock)")

                btn5_prep.click(
                    fn=aba5_demo_preparar_zips,
                    inputs=[zip_in_5],
                    outputs=[log5_prep, road_zip, sidewalk_zip, grass_zip, classe_dd],
                )

                btn5_inf.click(
                    fn=aba5_demo_inferencia,
                    inputs=[classe_dd, model_in, meta_in],
                    outputs=[csv_out_5, geo_out_5, log5_inf],
                )

        gr.Markdown(
            """
---
### 📖 Observação
Este Space é um **DEMO de interface**. Se você quiser a versão “real” (processamento + segmentação + inferência),
aí sim entra torch/transformers/opencv/exiftool e (idealmente) Docker.
"""
        )

    return app


if __name__ == "__main__":
    app = create_interface()
    app.launch(server_name="0.0.0.0", server_port=7860, share=False, show_error=True)