Upload streamlit_app.py

streamlit_app.py

@@ -1,30 +1,38 @@
-# streamlit_app.py — LamboVision (Car) UI
-# Pre-run Sample Preview kartları + Run sonrası sonuç kartları (Packshot/Padded/Composite/Video)
+# streamlit_app.py — LamboVision · AI Car Studio (frontend) v0.6.3
+# Previews: 9:16 cards (Input / Packshot / Padded / Scene / Video)
+# Configurator: model, body color, finish, wheel style, caliper color + Extra prompt
+# Endpoints used:
+#   POST /v1/tryon/chain   (recommended full pipeline)
+#   POST /v1/video/from-image (on-demand video)
+#
+# Env:
+#   AI_LIGHTBOX_API   -> http://host:port (default: http://127.0.0.1:8000)
+#   AI_LIGHTBOX_TOKEN -> Bearer (optional)
 
 import os, io, base64, zipfile, requests, streamlit as st
 from PIL import Image
 
-# ===== Theme (dark + Lamborghini orange) =====
+# ==== Theming (dark + orange) ====
 try:
     st._config.set_option("theme.base", "dark")
-    st._config.set_option("theme.primaryColor", "#ff7a1a")          # dark orange
+    st._config.set_option("theme.primaryColor", "#ff7a1a")
     st._config.set_option("theme.backgroundColor", "#0e0f12")
     st._config.set_option("theme.secondaryBackgroundColor", "#161a1f")
     st._config.set_option("theme.textColor", "#e7e9ed")
 except Exception:
     pass
 
-# ================= Env & API =================
-API_BASE = (os.getenv("AI_LamboVision_API", "http://127.0.0.1:7860") or "http://127.0.0.1:7860").strip().strip("'\"").rstrip("/")
-HF_TOKEN = (os.getenv("AI_LamboVision_TOKEN", "") or "").strip().strip("'\"")
+# ==== Env & API ====
+API_BASE = (os.getenv("AI_LIGHTBOX_API", "http://127.0.0.1:8000") or "http://127.0.0.1:8000").strip().strip("'\"").rstrip("/")
+HF_TOKEN = (os.getenv("AI_LIGHTBOX_TOKEN", "") or "").strip().strip("'\"")
 HEADERS = {"Authorization": f"Bearer {HF_TOKEN}"} if HF_TOKEN else {}
 
 VIDEO_MAX_PX_DEFAULT = int(os.getenv("VIDEO_MAX_PX", "720"))
 VIDEO_RES_OPTIONS = ["512P", "768P"]
 VIDEO_DUR_OPTIONS = ["6", "10"]
-ASPECT_OPTIONS = ["16:9", "9:16", "1:1", "4:3"]
+ASPECT_OPTIONS = ["9:16", "3:4", "1:1"]
 
-# ================= Session =================
+# ==== Session ====
 if "results" not in st.session_state:
     st.session_state["results"] = None
 if "job_counter" not in st.session_state:
@@ -32,19 +40,15 @@ if "job_counter" not in st.session_state:
 if "video_ui_max_px" not in st.session_state:
     st.session_state["video_ui_max_px"] = VIDEO_MAX_PX_DEFAULT
 
-# ================= Helpers =================
+# ==== Backend helpers ====
 def _needs_auth(url: str) -> bool:
     return url.startswith(API_BASE) or url.startswith("outputs/") or url.startswith("/outputs/")
 
 def _abs_backend_url(url_or_path: str) -> str:
-    if not url_or_path:
-        return ""
-    if url_or_path.startswith(("http://","https://")):
-        return url_or_path
-    if url_or_path.startswith("/outputs/"):
-        return f"{API_BASE}{url_or_path}"
-    if url_or_path.startswith("outputs/"):
-        return f"{API_BASE}/{url_or_path}"
+    if not url_or_path: return ""
+    if url_or_path.startswith(("http://","https://")): return url_or_path
+    if url_or_path.startswith("/outputs/"): return f"{API_BASE}{url_or_path}"
+    if url_or_path.startswith("outputs/"):   return f"{API_BASE}/{url_or_path}"
     return f"{API_BASE}/{url_or_path.lstrip('/')}"
 
 def backend_ok() -> bool:
@@ -61,15 +65,16 @@ def post_chain(data: dict, files_payload):
     r.raise_for_status()
     return r.json()
 
-def post_video(image_url: str, duration="6", resolution="768P", prompt_optimizer=False, preview_aspect="16:9", prompt_text=""):
+def post_video(image_url: str, duration="6", resolution="768P", prompt_optimizer=False, preview_aspect="9:16", prompt=None):
     payload = {
         "image_url": image_url,
         "duration": duration,
         "resolution": resolution,
-        "preview_aspect": preview_aspect,
         "prompt_optimizer": "true" if prompt_optimizer else "false",
-        "prompt": prompt_text or "",   # backend boşsa kendi defaults'unu kullanır
+        "preview_aspect": preview_aspect,
     }
+    if prompt is not None:
+        payload["prompt"] = prompt
     r = requests.post(f"{API_BASE}/v1/video/from-image", data=payload, headers=HEADERS, timeout=600)
     r.raise_for_status()
     return r.json()
@@ -123,40 +128,43 @@ def make_zip(named_bytes: list[tuple[str, bytes]]) -> bytes:
             if b: z.writestr(fname, b)
     buf.seek(0); return buf.read()
 
+# ==== Preview helpers (uniform 9:16 cards) ====
 def _parse_aspect_str(s: str):
     try:
         a, b = s.split(":"); return max(1, int(a)), max(1, int(b))
     except Exception:
-        return (16, 9)
+        return (9, 16)
 
 def inject_base_css():
     st.markdown("""
     <style>
       .stApp { background: #0e0f12; }
       header[data-testid="stHeader"] { background: transparent; }
-      .block-container { padding-top: 1.25rem; }
-      h1, .stMarkdown h1 { font-size: 1.85rem; line-height: 1.3; margin-bottom: 0.15rem; }
+      .block-container { padding-top: 1.1rem; }
+      h1, .stMarkdown h1 { font-size: 1.85rem; line-height: 1.25; margin-bottom: 0.1rem; }
       .stMarkdown p { margin-top: 0.15rem; }
       label, .stTextInput label, .stSelectbox label, .stNumberInput label, .stFileUploader label,
       .stCheckbox label, .stSlider label, .stRadio label {
-        color: #ff8a33 !important; font-weight: 600 !important;
+        color: #ff8a33 !important;
+        font-weight: 600 !important;
       }
       .stButton > button[kind="primary"]{
         background: #ff7a1a !important; border: 0 !important; color: #111 !important;
       }
       .stButton > button:hover { filter: brightness(1.05); }
-      .lb-card-title { font-weight: 700; font-size: 1.05rem; margin: 2px 0 8px 0; color: #eaecef; }
-      .lb-frame {
+      .stAlert { border-radius: 10px; }
+      .lv-card-title { font-weight: 700; font-size: 1.05rem; margin: 2px 0 8px 0; color: #eaecef; }
+      .lv-frame {
         position: relative; width: 100%;
         border-radius: 12px; overflow: hidden;
         background: #111419;
         display:flex; align-items:center; justify-content:center;
         box-shadow: 0 0 0 1px rgba(255,122,26,0.15) inset;
       }
-      .lb-frame img { width:100%; height:100%; display:block; }
-      .lb-video { display:flex; justify-content:center; }
-      .lb-video video { border-radius:8px; max-width: 540px; width:100%; height:auto; }
-      .stCaption { color: #ffb07a !important; }
+      .lv-frame img { width:100%; height:100%; display:block; }
+      .lv-video { display:flex; justify-content:center; }
+      .lv-video video { border-radius:8px; max-width: 540px; width:100%; height:auto; }
+      .stCaption, .st-emotion-cache-1r6slb0 { color: #ffb07a !important; }
     </style>
     """, unsafe_allow_html=True)
 
@@ -164,49 +172,13 @@ def inject_preview_css(aspect: str, fit_mode="contain"):
     aw, ah = _parse_aspect_str(aspect)
     st.markdown(f"""
     <style>
-      .lb-frame {{ aspect-ratio: {aw} / {ah}; }}
-      .lb-frame img {{ object-fit:{fit_mode}; }}
+      .lv-frame {{ aspect-ratio: {aw} / {ah}; }}
+      .lv-frame img {{ object-fit:{fit_mode}; }}
     </style>
     """, unsafe_allow_html=True)
 
-def show_tile_card_display_download(
-    col, title,
-    display_url: str | None = None,
-    display_bytes: bytes | None = None,
-    download_url: str | None = None,
-    download_bytes: bytes | None = None,
-    filename_stub: str = "image",
-    key_prefix: str = "",
-):
-    col.markdown(f'<div class="lb-card-title">{title}</div>', unsafe_allow_html=True)
-    if not display_url and not display_bytes:
-        col.markdown('<div class="lb-frame"></div>', unsafe_allow_html=True)
-        col.caption("—"); return None, None
-    if display_bytes is not None:
-        src = image_bytes_to_data_url(display_bytes)
-        col.markdown(f'<div class="lb-frame"><img src="{src}"/></div>', unsafe_allow_html=True)
-    else:
-        abs_url = _abs_backend_url(display_url)
-        col.markdown(f'<div class="lb-frame"><img src="{abs_url}"/></div>', unsafe_allow_html=True)
-
-    native = download_bytes or (fetch_bytes(download_url) if download_url else None)
-    if not native:
-        native = display_bytes
-    if native:
-        sz = image_size_from_bytes(native)
-        if sz: col.caption(f"Real Res: {sz[0]}×{sz[1]} px")
-        ext = infer_ext(native)
-        mime = "image/jpeg" if ext.lower() in [".jpg",".jpeg"] else ("image/png" if ext.lower()==".png" else "image/webp")
-        col.download_button("Download (Full Quality)", data=native,
-                            file_name=f"{filename_stub}{ext if ext!='.bin' else '.jpg'}",
-                            mime=mime, key=f"{key_prefix}_{filename_stub}_dl")
-    else:
-        col.caption("—")
-    return display_url or "data", native
-
 def rgba_to_rgb_on_bg(img_rgba: Image.Image, bg_rgb=(255,255,255)) -> Image.Image:
-    if img_rgba.mode != "RGBA":
-        return img_rgba.convert("RGB")
+    if img_rgba.mode != "RGBA": return img_rgba.convert("RGB")
     bg = Image.new("RGBA", img_rgba.size, (*bg_rgb, 255))
     bg.paste(img_rgba, (0,0), img_rgba)
     return bg.convert("RGB")
@@ -220,11 +192,9 @@ def make_small_jpeg_from_native(native: bytes, target_long_edge: int = 1280, bg_
         im = im.convert("RGBA")
     w, h = im.size
     if w >= h:
-        new_w = min(target_long_edge, w)
-        new_h = max(1, int(h * (new_w / max(1, w))))
+        new_w = min(target_long_edge, w); new_h = max(1, int(h * (new_w / max(1, w))))
     else:
-        new_h = min(target_long_edge, h)
-        new_w = max(1, int(w * (new_h / max(1, h))))
+        new_h = min(target_long_edge, h); new_w = max(1, int(w * (new_h / max(1, h))))
     im2 = im.resize((new_w, new_h), Image.LANCZOS)
     im2_rgb = rgba_to_rgb_on_bg(im2, bg_rgb=bg_rgb)
     out = io.BytesIO(); im2_rgb.save(out, format="JPEG", quality=88, subsampling=1)
@@ -232,13 +202,13 @@ def make_small_jpeg_from_native(native: bytes, target_long_edge: int = 1280, bg_
 
 def make_preview_frame(img_bytes: bytes, aspect: str, long_edge: int, ratio: float, bg_rgb=(255,255,255)) -> bytes:
     im = Image.open(io.BytesIO(img_bytes)).convert("RGBA")
-    a, b = _parse_aspect_str(aspect)
-    if a >= b:
-        W = max(256, min(8192, int(long_edge))); H = max(1, int(W * b / a))
+    aw, ah = _parse_aspect_str(aspect)
+    if aw >= ah:
+        W = max(256, min(8192, int(long_edge))); H = max(1, int(W * ah / aw))
     else:
-        H = max(256, min(8192, int(long_edge))); W = max(1, int(H * a / b))
+        H = max(256, min(8192, int(long_edge))); W = max(1, int(H * aw / ah))
     ratio = max(0.10, min(0.99, float(ratio)))
-    target = int(min(W, H) * ratio if a == b else (H * ratio if a < b else W * ratio))
+    target = int(min(W, H) * ratio if aw == ah else (H * ratio if aw < ah else W * ratio))
     w, h = im.size
     if w >= h: new_w, new_h = target, max(1, int(h * (target / max(1, w))))
     else:      new_h, new_w = target, max(1, int(w * (target / max(1, h))))
@@ -248,126 +218,107 @@ def make_preview_frame(img_bytes: bytes, aspect: str, long_edge: int, ratio: flo
     out = io.BytesIO(); canvas.convert("RGB").save(out, format="JPEG", quality=90, subsampling=1)
     return out.getvalue()
 
-# ================= Local demo assets (optional) =================
+# ==== Local demo files (optional) ====
 def load_local_demo():
     demo = {}
-    for fname in ["input.jpg", "packshot.jpg", "model.jpg", "tryon.mp4"]:
+    for fname in ["input.jpg", "packshot.jpg", "scene.jpg", "tryon.mp4"]:
         if os.path.exists(fname):
             with open(fname, "rb") as f: demo[fname] = f.read()
     return demo
-
 demo_files = load_local_demo()
 
-# ================= Prompt builders =================
-def build_car_prompt(model_name: str, body_color: str, finish: str, wheel_style: str, caliper_color: str, extra: str = "") -> str:
-    base = (
-        "Catalog-ready studio photo of a Lamborghini from a three-quarter front view. "
-        "Neutral studio background, soft rim light, realistic reflections, no text/logos in background. "
-        "Keep true proportions, lens look (35–50mm), and paint micro-highlights. "
-        "IDENTITY & GEOMETRY LOCK: Treat the car as a fixed real object. "
-        "Do NOT redraw or stylize body panels; preserve body lines, panel gaps, reflections and lenses; "
-        "no rotation/mirroring (Δyaw/pitch/roll ≤ 1°); keep wheel circles true, tire sidewalls, brake discs & calipers, ride height; "
-        "preserve badges/logo integrity; no warp or fake text."
-    )
-    cfg = (
-        f" Subject: {model_name}. "
-        f"Change body color to {body_color} with {finish} finish. "
-        f"Wheels: {wheel_style}; brake calipers {caliper_color}. "
-        "Maintain original stance; no suspension changes; no aero additions."
-    )
-    if extra.strip():
-        cfg += " " + extra.strip()
-    return base + " " + cfg
-
+# ==== Configurator data ====
+LAMBOMODELS = [
+    "Revuelto", "Huracán Tecnica", "Huracán Sterrato", "Huracán EVO",
+    "Urus S", "Urus Performante", "Sián", "Aventador SVJ (legacy)"
+]
+FINISHES = ["Gloss", "Matte", "Satin", "Pearl"]
+WHEELS = ["Hexagon Forged", "Narvi", "Minotauro", "Taigete", "Shiny Black", "Graphite Gray"]
+CALIPERS = ["Yellow", "Black", "Red", "Green", "Orange", "Silver"]
+BODY_COLORS = [
+    "Giallo Auge", "Arancio Borealis", "Verde Mantis", "Blu Nila",
+    "Grigio Telesto", "Nero Noctis", "Bianco Monocerus", "Rosso Mars"
+]
 SCENE_PRESETS = {
-    "Monaco Sunset": "Monaco coastal boulevard at golden hour, subtle dolly-in, realistic paint reflections, no artifacts.",
-    "Dubai Night": "Dubai Marina night city lights, gentle lateral parallax, crisp highlights, no motion blur.",
-    "Studio Cinematic": "High-end studio cyclorama, soft rim light, tripod-like stability, micro-motion only."
+    "Studio Clean": "premium studio, neutral gradient backdrop, soft rim light, glossy floor reflections",
+    "Monaco Sunset": "Monaco harbor at golden hour, warm reflections on paint, soft shadows",
+    "Dubai Night": "Dubai skyline at night, neon reflections, high-contrast lighting, luxurious vibe",
+    "Track Day": "race track pit lane, subtle motion cues, realistic asphalt reflections",
+    "Mountain Pass": "alpine pass road, crisp air, cool daylight, cinematic depth"
 }
 
-def build_video_prompt(scene_name: str, extra: str = "") -> str:
-    base = SCENE_PRESETS.get(scene_name, "High-end studio, subtle parallax, natural camera micro-motion.")
-    lock = " Keep logos and wheel circles intact; no wheel warping; no added text; realistic reflections."
-    if extra.strip():
-        return base + " " + lock + " " + extra.strip()
-    return base + " " + lock
-
-# ================= Page =================
-st.set_page_config(page_title="LamboVision · Car Configurator", layout="wide", page_icon="🏎️")
+# ==== App ====
+st.set_page_config(page_title="LamboVision · AI Car Studio", layout="wide", page_icon="🏎️")
 inject_base_css()
 
 st.title("🏎️ LamboVision · AI Car Studio")
-st.caption("Configure your Lamborghini and generate instant cinematic previews for high-intent leads.")
+st.caption("Upload → Configure → Scene → Cinematic")
 
 ok = backend_ok()
 
-# -------- Top control bar --------
-col1, col2, col3, col4, col5, col6, col7 = st.columns([1.6, 1.6, 1.0, 1.2, 0.9, 1.1, 0.9])
+# ---- Top controls ----
+col1, col2, col3, col4, col5, col6, col7 = st.columns([1.6, 1.6, 1.2, 1.4, 1.0, 1.0, 1.2])
 with col1:
     file_list = st.file_uploader("Car Image (Upload)", type=["jpg","jpeg","png","webp"], accept_multiple_files=True, key="file_upl")
 with col2:
     image_url = st.text_input("Or URL", key="image_url", placeholder="https://... (optional)")
 with col3:
-    category = st.selectbox("Category", ["auto","car","vehicle"], index=0, key="category")
+    model_sel = st.selectbox("Model", LAMBOMODELS, index=0, key="lv_model")
 with col4:
-    preview_ratio = st.number_input("Preview Scale (0.10–0.99)", min_value=0.10, max_value=0.99, value=0.60, step=0.01,
-                                    help="Sadece önizleme kadrajında büyüklüğü etkiler.", key="preview_ratio")
+    body_color = st.selectbox("Body Color", BODY_COLORS, index=0, key="lv_color")
 with col5:
-    upscale = st.checkbox("Super Res", False, key="upscale")
+    finish = st.selectbox("Finish", FINISHES, index=0, key="lv_finish")
 with col6:
-    upscale_stage = st.selectbox("SR Step", ["both","final","packshot"], index=0, help="Varsayılan: both", key="upscale_stage")
+    wheel = st.selectbox("Wheel Style", WHEELS, index=0, key="lv_wheel")
 with col7:
-    upscale_factor = st.selectbox("SR Factor", ["2","4"], index=0, key="upscale_factor")
+    caliper = st.selectbox("Caliper Color", CALIPERS, index=0, key="lv_caliper")
 
-colA, colB, colC, colD, colE, colF = st.columns([1.0, 1.0, 1.1, 0.9, 0.9, 1.2])
+colA, colB, colC, colD, colE, colF = st.columns([1.4, 1.4, 1.2, 1.0, 1.2, 1.2])
 with colA:
-    st.info(f"Connection: {'Online' if ok else 'Offline'}", icon="🔌")
+    extra_prompt = st.text_input("Extra (optional)", placeholder="carbon mirrors, dual stripe delete, etc.", key="extra_prompt")
 with colB:
-    identity_lock = st.checkbox("Identity lock", True, key="identity_lock")
+    scene_name = st.selectbox("Scene Preset", list(SCENE_PRESETS.keys()), index=0, key="scene_preset")
 with colC:
-    to_video = st.checkbox("One Click Generate Video", False, key="to_video")
+    preview_ratio = st.number_input("Preview Scale (0.10–0.99)", min_value=0.10, max_value=0.99, value=0.90, step=0.01, key="preview_ratio")
 with colD:
-    duration = st.selectbox("Duration ", VIDEO_DUR_OPTIONS, index=0, key="duration_sel")
+    upscale = st.checkbox("Super Res", False, key="upscale")
 with colE:
-    resolution = st.selectbox("Video Res", VIDEO_RES_OPTIONS, index=1, key="resolution_sel")
+    upscale_stage = st.selectbox("SR Step", ["both","final","packshot"], index=0, help="Default: both", key="upscale_stage")
 with colF:
-    run = st.button("Run 🏁", type="primary", use_container_width=True, key="run_btn")
-
-# -------- Configurator row --------
-st.markdown("### Configurator")
-c1, c2, c3, c4, c5, c6 = st.columns([1.4, 1.0, 0.9, 1.2, 1.0, 1.2])
-with c1:
-    model_name = st.text_input("Model", value="Lamborghini Revuelto", key="cfg_model")
-with c2:
-    body_color = st.text_input("Body color", value="Verde Ithaca", key="cfg_color")
-with c3:
-    finish = st.selectbox("Finish", ["gloss","matte","satin"], index=0, key="cfg_finish")
-with c4:
-    wheel_style = st.text_input("Wheel style", value="lightweight forged", key="cfg_wheels")
-with c5:
-    caliper_color = st.text_input("Caliper", value="yellow", key="cfg_caliper")
-with c6:
-    extra_prompt = st.text_input("Extra (optional)", value="", placeholder="stripe delete, studio floor reflection, ...", key="cfg_extra")
-
-# -------- Scene presets for video --------
-st.markdown("### Scene Presets")
-s1, s2, s3, s4 = st.columns([1.2, 1.2, 1.2, 1.2])
-with s1:
-    scene_name = st.selectbox("Scene", list(SCENE_PRESETS.keys()), index=0, key="scene_name")
-with s2:
-    scene_extra = st.text_input("Scene extra (optional)", value="", key="scene_extra")
-with s3:
+    identity_lock = st.checkbox("Identity lock", True, key="identity_lock")
+
+colT1, colT2, colT3, colT4 = st.columns([1.0, 1.0, 1.0, 1.2])
+with colT1:
     preview_aspect = st.selectbox("Preview Frame Ratio", ASPECT_OPTIONS, index=0, key="preview_aspect")
-with s4:
+with colT2:
     preview_long_edge = st.number_input("Preview Long Edge (px)", min_value=256, max_value=8192, value=1920, step=64, key="preview_long_edge")
+with colT3:
+    fit_mode = st.selectbox("Preview Layout", ["fit","fill"], index=0, help="Affects previews only.", key="fit_mode")
+with colT4:
+    st.info(f"Connection: {'Online' if ok else 'Offline'}", icon="🔌")
 
-fit_mode = st.selectbox("Preview Layout", ["fit","fill"], index=0, help="Sadece önizlemeyi etkiler.", key="fit_mode")
+# Inject CSS for aspect
 inject_preview_css(preview_aspect, fit_mode="contain" if fit_mode=="fit" else "cover")
 
-# ================= PRE-RUN SAMPLE PREVIEWS =================
-st.subheader("Sample Previews")
-col_in, col_pack, col_pad, col_vid = st.columns(4)
-
+# ==== Build edit prompt (cars) ====
+def build_edit_prompt(model, color, finish, wheel, caliper, extra):
+    parts = [
+        f"Lamborghini {model}",
+        f"body color: {color}",
+        f"finish: {finish}",
+        f"wheel style: {wheel}",
+        f"brake calipers: {caliper}",
+        "catalog-clean alignment, keep true geometry, badges and proportions, realistic reflections"
+    ]
+    if extra and extra.strip():
+        parts.append(extra.strip())
+    return ", ".join(parts)
+
+# ==== Pre-run PREVIEWS (5 cards) ====
+st.subheader("Previews (9:16)")
+c_in, c_pack, c_pad, c_scene, c_video = st.columns(5)
+
+# Input bytes
 input_bytes = None
 if file_list:
     try: input_bytes = file_list[0].getvalue()
@@ -377,8 +328,46 @@ elif image_url:
 elif demo_files.get("input.jpg"):
     input_bytes = demo_files["input.jpg"]
 
+def show_tile_card_display_download(
+    col, title,
+    display_url: str | None = None,
+    display_bytes: bytes | None = None,
+    download_url: str | None = None,
+    download_bytes: bytes | None = None,
+    filename_stub: str = "image",
+    key_prefix: str = "",
+):
+    col.markdown(f'<div class="lv-card-title">{title}</div>', unsafe_allow_html=True)
+    if not display_url and not display_bytes:
+        col.markdown('<div class="lv-frame"></div>', unsafe_allow_html=True)
+        col.caption("—"); return None, None
+
+    if display_bytes is not None:
+        src = image_bytes_to_data_url(display_bytes)
+        col.markdown(f'<div class="lv-frame"><img src="{src}"/></div>', unsafe_allow_html=True)
+    else:
+        abs_url = _abs_backend_url(display_url)
+        col.markdown(f'<div class="lv-frame"><img src="{abs_url}"/></div>', unsafe_allow_html=True)
+
+    native = download_bytes or (fetch_bytes(download_url) if download_url else None)
+    if not native:
+        native = display_bytes
+
+    if native:
+        sz = image_size_from_bytes(native)
+        if sz: col.caption(f"Real Res: {sz[0]}×{sz[1]} px")
+        ext = infer_ext(native)
+        mime = "image/jpeg" if ext.lower() in [".jpg",".jpeg"] else ("image/png" if ext.lower()==".png" else "image/webp")
+        col.download_button("Download (Full Quality)", data=native,
+                            file_name=f"{filename_stub}{ext if ext!='.bin' else '.jpg'}",
+                            mime=mime, key=f"{key_prefix}_{filename_stub}_dl")
+    else:
+        col.caption("—")
+
+    return display_url or "data", native
+
 show_tile_card_display_download(
-    col_in, "Sample Input preview",
+    c_in, "Sample Input preview",
     display_bytes=input_bytes if input_bytes else demo_files.get("input.jpg"),
     download_bytes=input_bytes if input_bytes else demo_files.get("input.jpg"),
     filename_stub="input", key_prefix="pre"
@@ -386,7 +375,7 @@ show_tile_card_display_download(
 
 pack_bytes_demo = demo_files.get("packshot.jpg") or input_bytes
 show_tile_card_display_download(
-    col_pack, "Sample Preview",
+    c_pack, "Sample Packshot (Clean/Configured)",
     display_bytes=pack_bytes_demo,
     download_bytes=pack_bytes_demo,
     filename_stub="packshot", key_prefix="pre"
@@ -401,84 +390,101 @@ if pack_bytes_demo:
     except Exception:
         padded_bytes = None
 show_tile_card_display_download(
-    col_pad, "Sample Composite Preview",
+    c_pad, "Sample Padded (9:16 UI)",
     display_bytes=padded_bytes or pack_bytes_demo,
     download_bytes=padded_bytes or pack_bytes_demo,
     filename_stub="padded_ui", key_prefix="pre"
 )
 
+scene_bytes_demo = demo_files.get("scene.jpg") or pack_bytes_demo
+show_tile_card_display_download(
+    c_scene, "Sample Scene Composite",
+    display_bytes=scene_bytes_demo,
+    download_bytes=scene_bytes_demo,
+    filename_stub="scene_composite", key_prefix="pre"
+)
+
+c_video.markdown('<div class="lv-card-title">AI Generated Video Preview</div>', unsafe_allow_html=True)
 vid_demo = demo_files.get("tryon.mp4")
-col_vid.markdown('<div class="lb-card-title">AI Generated Video Preview</div>', unsafe_allow_html=True)
 if vid_demo:
     data_url = "data:video/mp4;base64," + base64.b64encode(vid_demo).decode("ascii")
-    col_vid.markdown(
+    c_video.markdown(
         f"""
-        <div class="lb-frame" style="display:flex;align-items:center;justify-content:center;">
+        <div class="lv-frame" style="display:flex;align-items:center;justify-content:center;">
           <video autoplay loop muted playsinline style="width:100%;height:100%;object-fit:cover;">
             <source src="{data_url}" type="video/mp4">
           </video>
         </div>
         """, unsafe_allow_html=True
     )
-    col_vid.download_button("Download Video (MP4)", data=vid_demo, file_name="tryon.mp4", mime="video/mp4", key="pre_video_dl")
+    c_video.download_button("Download Video (MP4)", data=vid_demo, file_name="sample_tryon.mp4", mime="video/mp4", key="pre_video_dl")
 else:
-    col_vid.markdown('<div class="lb-frame"></div>', unsafe_allow_html=True)
-    col_vid.caption("—")
+    c_video.markdown('<div class="lv-frame"></div>', unsafe_allow_html=True)
+    c_video.caption("—")
 
-# ================= RUN =================
+# ==== Actions ====
+colAct1, colAct2, colAct3, colAct4, colAct5 = st.columns([1.0, 1.0, 1.2, 1.0, 1.2])
+with colAct1:
+    to_video = st.checkbox("One Click Generate Video", False, key="to_video")
+with colAct2:
+    duration = st.selectbox("Duration", VIDEO_DUR_OPTIONS, index=0, key="duration_sel")
+with colAct3:
+    resolution = st.selectbox("Video Res", VIDEO_RES_OPTIONS, index=1, key="resolution_sel")
+with colAct4:
+    do_scene_pass = st.checkbox("Scene Composite", True, key="do_scene_pass")
+with colAct5:
+    run = st.button("Run ▶", type="primary", use_container_width=True, key="run_btn")
+
+# ==== Run pipeline ====
 if run:
     if not ok:
-        st.error("Backend erişilemiyor. API_BASE / TOKEN kontrol edin.")
+        st.error("Backend unreachable. Check API_BASE / TOKEN.")
     elif not (file_list or image_url or demo_files.get("input.jpg")):
-        st.error("En az bir görsel girişi yapın (dosya yükle veya URL).")
+        st.error("Provide at least one image (upload or URL).")
     else:
         try:
-            # Build edit prompt from configurator
-            edit_prompt = build_car_prompt(
-                model_name=model_name,
-                body_color=body_color,
-                finish=finish,
-                wheel_style=wheel_style,
-                caliper_color=caliper_color,
-                extra=extra_prompt
-            )
-
+            # Build prompts
+            edit_prompt = build_edit_prompt(model_sel, body_color, finish, wheel, caliper, extra_prompt)
+            scene_text = SCENE_PRESETS.get(scene_name, "premium studio scene")
             img_urls = image_url or ""
+
             files_payload = []
             if file_list:
                 for f in file_list:
                     files_payload.append(("files", (f.name, f.getvalue(), f.type or "image/jpeg")))
 
             data = {
-                "category": category,
-                "edit_prompt": edit_prompt,               # backend doluysa bunu kullanır
+                "category": "auto",
+                "edit_prompt": edit_prompt,
                 "num_images": "1",
                 "image_urls": img_urls,
-                "mannequin_image_url": "",                # otomotivde kullanılmıyor
+                # scene pass
+                "do_scene_pass": "true" if do_scene_pass else "false",
+                "scene_prompt_text": scene_text,
+                # identity lock (backendside rules)
                 "identity_lock": "true" if identity_lock else "false",
-                # Preview controls
+                # canvas/preview
                 "preview_aspect": preview_aspect,
                 "preview_long_edge": str(int(preview_long_edge)),
                 "preview_ratio": str(float(preview_ratio)),
-                "padding_ratio": str(float(preview_ratio)),
                 # SR
                 "upscale": "true" if upscale else "false",
-                "upscale_factor": st.session_state.get("upscale_factor","2"),
+                "upscale_factor": "2",
                 "upscale_stage": st.session_state.get("upscale_stage","both"),
-                # Video chain (optional)
+                # video
                 "to_video": "true" if to_video else "false",
-                "video_prompt": build_video_prompt(scene_name, scene_extra) if to_video else "",
+                "video_prompt": scene_text,  # same vibe for camera move
                 "duration": st.session_state.get("duration_sel", VIDEO_DUR_OPTIONS[0]),
                 "resolution": st.session_state.get("resolution_sel", VIDEO_RES_OPTIONS[1]),
                 "prompt_optimizer": "false",
             }
 
-            with st.spinner("AI Chain Running…"):
+            with st.spinner("LamboVision pipeline running…"):
                 out = post_chain(data, files_payload if files_payload else None)
 
             st.session_state["job_counter"] += 1
 
-            # ---- Outputs ----
+            # Parse outputs
             pack_native_url = None; pack_display_jpeg = None
             try:
                 pack_native_url = (out["packshot_step"]["result"]["images_native"] or [{}])[0].get("url")
@@ -495,12 +501,13 @@ if run:
                     if nb: padded_display_jpeg = make_small_jpeg_from_native(nb, 1280, bg_rgb=(255,255,255))
             except Exception: pass
 
-            placed_native_url = None; placed_display_jpeg = None
+            scene_native_url = None; scene_display_jpeg = None
             try:
-                placed_native_url = (out.get("image_step") or {}).get("result", {}).get("images_native", [{}])[0].get("url")
-                if placed_native_url:
-                    mn = fetch_bytes(placed_native_url)
-                    if mn: placed_display_jpeg = make_small_jpeg_from_native(mn, 1280, bg_rgb=(255,255,255))
+                if out.get("scene_step"):
+                    scene_native_url = (out["scene_step"]["result"]["images_native"] or [{}])[0].get("url")
+                    if scene_native_url:
+                        sb = fetch_bytes(scene_native_url)
+                        if sb: scene_display_jpeg = make_small_jpeg_from_native(sb, 1280, bg_rgb=(255,255,255))
             except Exception: pass
 
             vurl = None
@@ -520,28 +527,31 @@ if run:
                 "packshot_display_jpeg": pack_display_jpeg,
                 "padded_native_url": padded_native_url,
                 "padded_display_jpeg": padded_display_jpeg,
-                "placed_native_url": placed_native_url,
-                "placed_display_jpeg": placed_display_jpeg,
+                "scene_native_url": scene_native_url,
+                "scene_display_jpeg": scene_display_jpeg,
                 "video_url": vurl,
                 "api_base": API_BASE,
                 "has_auth_header": bool(HEADERS),
                 "preview_aspect": preview_aspect,
+                "scene_vendor_url": out.get("scene_vendor_url"),
+                "scene_prompt_text": scene_text,
+                "edit_prompt": edit_prompt,
             }
 
         except requests.HTTPError as e:
             st.error(f"HTTP {e.response.status_code}")
         except Exception as e:
-            st.error(f"Hata: {e}")
+            st.error(f"Error: {e}")
 
-# ================= RESULTS =================
+# ==== Results ====
 res = st.session_state.get("results")
 vbytes = None
 if res:
     st.subheader("Results")
-    c_pack, c_pad, c_model, c_vid = st.columns(4)
+    c_pack2, c_pad2, c_scene2, c_video2 = st.columns(4)
 
     show_tile_card_display_download(
-        c_pack, "Packshot (Studio)",
+        c_pack2, "Configured Packshot",
         display_bytes=res.get("packshot_display_jpeg"),
         download_url=res.get("packshot_native_url"),
         filename_stub="packshot_native",
@@ -549,7 +559,7 @@ if res:
     )
 
     show_tile_card_display_download(
-        c_pad, "Padded",
+        c_pad2, "Padded (9:16 Canvas)",
         display_bytes=res.get("padded_display_jpeg"),
         download_url=res.get("padded_native_url"),
         filename_stub="padded_backend",
@@ -557,20 +567,21 @@ if res:
     )
 
     show_tile_card_display_download(
-        c_model, "Composite",
-        display_bytes=res.get("placed_display_jpeg"),
-        download_url=res.get("placed_native_url"),
-        filename_stub="composite_native",
+        c_scene2, "Scene Composite",
+        display_bytes=res.get("scene_display_jpeg"),
+        download_url=res.get("scene_native_url"),
+        filename_stub="scene_native",
         key_prefix=f"job{st.session_state['job_counter']}"
     )
 
-    c_vid.markdown('<div class="lb-card-title">AI Generated Video</div>', unsafe_allow_html=True)
+    # Video
     vurl = res.get("video_url")
+    c_video2.markdown('<div class="lv-card-title">AI Cinematic</div>', unsafe_allow_html=True)
     if vurl:
         abs_v = _abs_backend_url(vurl)
-        c_vid.markdown(
+        c_video2.markdown(
             f"""
-            <div class="lb-frame" style="display:flex;align-items:center;justify-content:center;">
+            <div class="lv-frame" style="display:flex;align-items:center;justify-content:center;">
               <video autoplay loop muted controls playsinline style="width:100%;height:100%;object-fit:cover;">
                 <source src="{abs_v}" type="video/mp4">
               </video>
@@ -580,26 +591,25 @@ if res:
         vb = fetch_bytes(abs_v)
         if vb:
             vbytes = vb
-            c_vid.download_button("Download Video (MP4)", data=vb, file_name="lambovision_video.mp4",
-                                  mime="video/mp4", key=f"job{st.session_state['job_counter']}_video_dl")
+            c_video2.download_button("Download Video (MP4)", data=vb, file_name="lambo_vision_video.mp4",
+                                     mime="video/mp4", key=f"job{st.session_state['job_counter']}_video_dl")
     else:
-        c_vid.markdown('<div class="lb-frame"></div>', unsafe_allow_html=True)
+        c_video2.markdown('<div class="lv-frame"></div>', unsafe_allow_html=True)
+        # On-demand video from scene or packshot
         vid_checkbox_key = f"video_toggle_job{st.session_state['job_counter']}"
-        if st.checkbox("Generate Video From This Result", value=False, key=vid_checkbox_key):
-            src_for_video = res.get("packshot_native_url") or res.get("placed_native_url")
+        if st.checkbox("Generate Video From Scene", value=False, key=vid_checkbox_key):
+            src_for_video = res.get("scene_native_url") or res.get("packshot_native_url")
             if not src_for_video:
-                st.warning("Video için kullanılacak native görsel bulunamadı.")
+                st.warning("No image found for video.")
             else:
-                with st.spinner("Generating Video …"):
+                with st.spinner("Generating video …"):
                     try:
                         v = post_video(
                             src_for_video,
                             duration=st.session_state.get("duration_sel", VIDEO_DUR_OPTIONS[0]),
                             resolution=st.session_state.get("resolution_sel", VIDEO_RES_OPTIONS[1]),
-                            preview_aspect=st.session_state.get("preview_aspect","16:9"),
-                            prompt_text=build_video_prompt(st.session_state.get("scene_name","Studio Cinematic"),
-                                                          st.session_state.get("scene_extra","")),
-                            prompt_optimizer=False,
+                            preview_aspect=st.session_state.get("preview_aspect","9:16"),
+                            prompt=res.get("scene_prompt_text")
                         )
                     except requests.HTTPError as e:
                         st.error(f"HTTP {e.response.status_code}")
@@ -612,29 +622,29 @@ if res:
                         if isinstance(ui_hints, dict):
                             st.session_state["video_ui_max_px"] = int(ui_hints.get("suggested_video_max_px", VIDEO_MAX_PX_DEFAULT))
                         st.session_state.pop(vid_checkbox_key, None)
-                        st.success("Video is Ready! Showing preview…")
+                        st.success("Video is ready.")
                         st.rerun()
                     else:
-                        st.info("Video URL gelmedi.")
+                        st.info("No video URL returned.")
 
-    # ZIP
+    # ZIP bundle
     named = []
     pn = fetch_bytes(res.get("packshot_native_url")) if res.get("packshot_native_url") else None
-    mn = fetch_bytes(res.get("placed_native_url")) if res.get("placed_native_url") else None
+    sn = fetch_bytes(res.get("scene_native_url")) if res.get("scene_native_url") else None
     if pn: named.append((f"packshot_native{infer_ext(pn)}", pn))
-    if mn: named.append((f"composite_native{infer_ext(mn)}", mn))
+    if sn: named.append((f"scene_native{infer_ext(sn)}", sn))
     if vbytes: named.append(("video.mp4", vbytes))
     if named:
         zip_bytes = make_zip(named)
         st.download_button("Download All (ZIP)", data=zip_bytes,
-                           file_name="lambovision_outputs.zip", mime="application/zip",
+                           file_name="lambo_vision_outputs.zip", mime="application/zip",
                            key=f"job{st.session_state['job_counter']}_zip_dl")
 
-# ================= Sidebar =================
+# ==== Sidebar ====
 with st.sidebar:
     st.caption(f"API_BASE: {API_BASE}")
-    if HF_TOKEN: st.caption("Auth: Bearer (aktif)")
+    if HF_TOKEN: st.caption("Auth: Bearer ✓")
     st.slider("Video preview width (px)", 360, 1080, st.session_state["video_ui_max_px"],
               step=10, key="video_ui_max_px")
     if st.button("Clear cache"): st.cache_data.clear(); st.success("Cache cleared.")
-    if st.button("Clear results"): st.session_state["results"] = None; st.success("Cleared.")
+    if st.button("Clear last results"): st.session_state["results"] = None; st.success("Results cleared.")