Update app.py

app.py

@@ -1,16 +1,684 @@
 import os
-from gradio_client import Client, handle_file
+import shutil
+import sys
+import warnings
+import random
+import time
+import logging
+import fal_client
+import base64
+import numpy as np
+import math
+import scipy
+import requests
+import torch
+import torchvision
+import gradio as gr
+import argparse
+import spaces
+from PIL import Image, ImageFilter, ImageOps, ImageDraw, ImageFont
+from io import BytesIO
+from typing import Dict, List, Tuple, Union, Optional
 
-HF_TOKEN = os.environ.get("HF_TOKEN")
-# Create a client with authentication
-client = Client(
-    "rootglitch/CarVizGradioDemo01", 
-    hf_token=HF_TOKEN  
-)
+os.system("python -m pip install -e sam-hq")
+os.system("python -m pip install -e GroundingDINO")
+os.system("pip install opencv-python pycocotools matplotlib onnxruntime onnx ipykernel")
+os.system("wget https://huggingface.co/ShilongLiu/GroundingDINO/resolve/main/groundingdino_swint_ogc.pth")
+os.system("wget https://huggingface.co/lkeab/hq-sam/resolve/main/sam_hq_vit_l.pth")
+sys.path.append(os.path.join(os.getcwd(), "GroundingDINO"))
+sys.path.append(os.path.join(os.getcwd(), "sam-hq"))
 
-result = client.predict(
-    input_image_path=handle_file('https://raw.githubusercontent.com/gradio-app/gradio/main/test/test_files/bus.png'),
-    prompt="Hello!!",
-    api_name="/generate_image"
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[logging.StreamHandler()]
 )
-print(result)
+logger = logging.getLogger(__name__)
+
+# Grounding DINO
+import GroundingDINO.groundingdino.datasets.transforms as T
+from GroundingDINO.groundingdino.models import build_model
+from GroundingDINO.groundingdino.util.slconfig import SLConfig
+from GroundingDINO.groundingdino.util.utils import clean_state_dict, get_phrases_from_posmap
+
+# segment anything
+from segment_anything import build_sam_vit_l, SamPredictor 
+
+# Constants
+CONFIG_FILE = 'GroundingDINO/groundingdino/config/GroundingDINO_SwinT_OGC.py'
+GROUNDINGDINO_CHECKPOINT = "groundingdino_swint_ogc.pth"
+SAM_CHECKPOINT = 'sam_hq_vit_l.pth'
+OUTPUT_DIR = "outputs"
+
+# Global variables for model caching
+_models = {
+    'groundingdino': None,
+    'sam_predictor': None
+}
+
+# Enable GPU if available with proper error handling
+try:
+    device = 'cuda' if torch.cuda.is_available() else 'cpu'
+    logger.info(f"Using device: {device}")
+except Exception as e:
+    logger.warning(f"Error detecting GPU, falling back to CPU: {e}")
+    device = 'cpu'
+
+
+class ModelManager:
+    """Manages model loading, unloading, and provides error handling"""
+    
+    @staticmethod
+    def load_model(model_name: str) -> None:
+        """Load a model if not already loaded"""
+        try:
+            if model_name == 'groundingdino' and _models['groundingdino'] is None:
+                logger.info("Loading GroundingDINO model...")
+                start_time = time.time()
+                
+                if not os.path.exists(GROUNDINGDINO_CHECKPOINT):
+                    raise FileNotFoundError(f"GroundingDINO checkpoint not found at {GROUNDINGDINO_CHECKPOINT}")
+                
+                args = SLConfig.fromfile(CONFIG_FILE)
+                args.device = device
+                model = build_model(args)
+                checkpoint = torch.load(GROUNDINGDINO_CHECKPOINT, map_location="cpu")
+                load_res = model.load_state_dict(clean_state_dict(checkpoint["model"]), strict=False)
+                logger.info(f"GroundingDINO load result: {load_res}")
+                _ = model.eval()
+                _models['groundingdino'] = model
+                
+                logger.info(f"GroundingDINO model loaded in {time.time() - start_time:.2f} seconds")
+                
+            elif model_name == 'sam' and _models['sam_predictor'] is None:
+                logger.info("Loading SAM-HQ model...")
+                start_time = time.time()
+                
+                if not os.path.exists(SAM_CHECKPOINT):
+                    raise FileNotFoundError(f"SAM checkpoint not found at {SAM_CHECKPOINT}")
+                
+                sam = build_sam_vit_l(checkpoint=SAM_CHECKPOINT)
+                sam.to(device=device)
+                _models['sam_predictor'] = SamPredictor(sam)
+                
+                logger.info(f"SAM-HQ model loaded in {time.time() - start_time:.2f} seconds")
+
+                
+        except Exception as e:
+            logger.error(f"Error loading {model_name} model: {e}")
+            raise RuntimeError(f"Failed to load {model_name} model: {e}")
+    
+    @staticmethod
+    def get_model(model_name: str):
+        """Get a model, loading it if necessary"""
+        if model_name not in _models or _models[model_name] is None:
+            ModelManager.load_model(model_name)
+        return _models[model_name]
+    
+    @staticmethod
+    def unload_model(model_name: str) -> None:
+        """Unload a model to free memory"""
+        if model_name in _models and _models[model_name] is not None:
+            logger.info(f"Unloading {model_name} model")
+            _models[model_name] = None
+            if device == 'cuda':
+                torch.cuda.empty_cache()
+
+
+def transform_image(image_pil: Image.Image) -> torch.Tensor:
+    """Transform PIL image for GroundingDINO"""
+    transform = T.Compose([
+        T.RandomResize([800], max_size=1333),
+        T.ToTensor(),
+        T.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
+    ])
+    image, _ = transform(image_pil, None)  # 3, h, w
+    return image
+
+
+def get_grounding_output(
+    image: torch.Tensor, 
+    caption: str, 
+    box_threshold: float, 
+    text_threshold: float, 
+    with_logits: bool = True
+) -> Tuple[torch.Tensor, torch.Tensor, List[str]]:
+    """Run GroundingDINO to get bounding boxes from text prompt"""
+    try:
+        model = ModelManager.get_model('groundingdino')
+        
+        # Format caption
+        caption = caption.lower().strip()
+        if not caption.endswith("."):
+            caption = caption + "."
+
+        with torch.no_grad():
+            outputs = model(image[None], captions=[caption])
+            
+        logits = outputs["pred_logits"].cpu().sigmoid()[0]  # (nq, 256)
+        boxes = outputs["pred_boxes"].cpu()[0]  # (nq, 4)
+
+        # Filter output
+        logits_filt = logits.clone()
+        boxes_filt = boxes.clone()
+        filt_mask = logits_filt.max(dim=1)[0] > box_threshold
+        logits_filt = logits_filt[filt_mask]  # num_filt, 256
+        boxes_filt = boxes_filt[filt_mask]  # num_filt, 4
+
+        # Get phrases
+        tokenizer = model.tokenizer
+        tokenized = tokenizer(caption)
+        pred_phrases = []
+        scores = []
+        
+        for logit, box in zip(logits_filt, boxes_filt):
+            pred_phrase = get_phrases_from_posmap(
+                logit > text_threshold, tokenized, tokenizer)
+            if with_logits:
+                pred_phrases.append(pred_phrase + f"({str(logit.max().item())[:4]})")
+            else:
+                pred_phrases.append(pred_phrase)
+            scores.append(logit.max().item())
+
+        return boxes_filt, torch.Tensor(scores), pred_phrases
+    
+    except Exception as e:
+        logger.error(f"Error in grounding output: {e}")
+        # Return empty results instead of crashing
+        return torch.Tensor([]), torch.Tensor([]), []
+
+
+def draw_mask(mask: np.ndarray, draw: ImageDraw.Draw) -> None:
+    """Draw mask on image"""
+
+    color = (255, 255, 255, 255)
+
+    nonzero_coords = np.transpose(np.nonzero(mask))
+    for coord in nonzero_coords:
+        draw.point(coord[::-1], fill=color)
+
+
+def draw_box(box: torch.Tensor, draw: ImageDraw.Draw, label: Optional[str]) -> None:
+    """Draw bounding box on image"""
+    color = tuple(np.random.randint(0, 255, size=3).tolist())
+    draw.rectangle(((box[0], box[1]), (box[2], box[3])), outline=color, width=2)
+
+    if label:
+        font = ImageFont.load_default()
+        if hasattr(font, "getbbox"):
+            bbox = draw.textbbox((box[0], box[1]), str(label), font)
+        else:
+            w, h = draw.textsize(str(label), font)
+            bbox = (box[0], box[1], w + box[0], box[1] + h)
+        draw.rectangle(bbox, fill=color)
+        draw.text((box[0], box[1]), str(label), fill="white")
+
+
+def run_grounded_sam(input_image):
+    """Main function to run GroundingDINO and SAM-HQ"""
+    # Create output directory
+    os.makedirs(OUTPUT_DIR, exist_ok=True)
+    text_prompt = 'car'
+    task_type = 'text'
+    box_threshold = 0.3
+    text_threshold = 0.25
+    iou_threshold = 0.8
+    hq_token_only = True
+    
+    # Process input image
+    if isinstance(input_image, dict):
+        # Input from gradio sketch component
+        scribble = np.array(input_image["mask"])
+        image_pil = input_image["image"].convert("RGB")
+    else:
+        # Direct image input
+        image_pil = input_image.convert("RGB") if input_image else None
+        scribble = None
+        
+    if image_pil is None:
+        logger.error("No input image provided")
+        return [Image.new('RGB', (400, 300), color='gray')]
+
+    # Transform image for GroundingDINO
+    transformed_image = transform_image(image_pil)
+    
+    # Load models as needed
+    ModelManager.load_model('groundingdino')
+    size = image_pil.size
+    H, W = size[1], size[0]
+
+    # Run GroundingDINO with provided text
+    boxes_filt, scores, pred_phrases = get_grounding_output(
+        transformed_image, text_prompt, box_threshold, text_threshold
+    )
+
+    if boxes_filt is not None:
+        # Scale boxes to image dimensions
+        for i in range(boxes_filt.size(0)):
+            boxes_filt[i] = boxes_filt[i] * torch.Tensor([W, H, W, H])
+            boxes_filt[i][:2] -= boxes_filt[i][2:] / 2
+            boxes_filt[i][2:] += boxes_filt[i][:2]
+        
+        # Apply non-maximum suppression if we have multiple boxes
+        if boxes_filt.size(0) > 1:
+            logger.info(f"Before NMS: {boxes_filt.shape[0]} boxes")
+            nms_idx = torchvision.ops.nms(boxes_filt, scores, iou_threshold).numpy().tolist()
+            boxes_filt = boxes_filt[nms_idx]
+            pred_phrases = [pred_phrases[idx] for idx in nms_idx]
+            logger.info(f"After NMS: {boxes_filt.shape[0]} boxes")
+    
+    # Load SAM model
+    ModelManager.load_model('sam')
+    sam_predictor = ModelManager.get_model('sam_predictor')
+    
+    # Set image for SAM
+    image = np.array(image_pil)
+    sam_predictor.set_image(image)
+    
+    # Run SAM 
+    # Use boxes for these task types
+    if boxes_filt.size(0) == 0:
+        logger.warning("No boxes detected")
+        return [image_pil, Image.new('RGBA', size, color=(0, 0, 0, 0))]
+    
+    transformed_boxes = sam_predictor.transform.apply_boxes_torch(boxes_filt, image.shape[:2]).to(device)
+    
+    masks, _, _ = sam_predictor.predict_torch(
+        point_coords=None,
+        point_labels=None,
+        boxes=transformed_boxes,
+        multimask_output=False,
+        hq_token_only=hq_token_only,
+    )
+    
+    # Create mask image
+    mask_image = Image.new('RGBA', size, color=(0, 0, 0, 0))
+    mask_draw = ImageDraw.Draw(mask_image)
+    
+    # Draw masks
+    for mask in masks:
+        draw_mask(mask[0].cpu().numpy(), mask_draw)
+    
+    # Draw boxes and points on original image
+    image_draw = ImageDraw.Draw(image_pil)
+
+    for box, label in zip(boxes_filt, pred_phrases):
+        draw_box(box, image_draw, label)
+
+    return mask_image
+    
+    # except Exception as e:
+    #     logger.error(f"Error in run_grounded_sam: {e}")
+        # # Return original image on error
+        # if isinstance(input_image, dict) and "image" in input_image:
+        #     return [input_image["image"], Image.new('RGBA', input_image["image"].size, color=(0, 0, 0, 0))]
+        # elif isinstance(input_image, Image.Image):
+        #     return [input_image, Image.new('RGBA', input_image.size, color=(0, 0, 0, 0))]
+        # else:
+        #     return [Image.new('RGB', (400, 300), color='gray'), Image.new('RGBA', (400, 300), color=(0, 0, 0, 0))]
+
+def split_image_with_alpha(image):
+    image = image.convert("RGB")
+    return image
+
+def gaussian_blur(image, radius=10):
+    """Apply Gaussian blur to image."""
+    blurred = image.filter(ImageFilter.GaussianBlur(radius=10))
+    return blurred
+
+def invert_image(image):
+    img_inverted = ImageOps.invert(image)
+    return img_inverted
+
+def expand_mask(mask, expand, tapered_corners):
+    # Ensure mask is in grayscale (mode 'L')
+    mask = mask.convert("L")
+    
+    # Convert to NumPy array
+    mask_np = np.array(mask)
+
+    # Define kernel
+    c = 0 if tapered_corners else 1
+    kernel = np.array([[c, 1, c],
+                       [1, 1, 1],
+                       [c, 1, c]], dtype=np.uint8)
+
+    # Perform dilation or erosion based on expand value
+    if expand > 0:
+        for _ in range(expand):
+            mask_np = scipy.ndimage.grey_dilation(mask_np, footprint=kernel)
+    elif expand < 0:
+        for _ in range(abs(expand)):
+            mask_np = scipy.ndimage.grey_erosion(mask_np, footprint=kernel)
+
+    # Convert back to PIL image
+    return Image.fromarray(mask_np, mode="L")
+
+def image_blend_by_mask(image_a, image_b, mask, blend_percentage):
+    # Ensure images have the same size and mode
+    image_a = image_a.convert('RGB')
+    image_b = image_b.convert('RGB')
+    mask = mask.convert('L')
+    
+    # Resize images if they don't match
+    if image_a.size != image_b.size:
+        image_b = image_b.resize(image_a.size, Image.LANCZOS)
+    
+    # Ensure mask has the same size
+    if mask.size != image_a.size:
+        mask = mask.resize(image_a.size, Image.LANCZOS)
+    
+    # Invert mask
+    mask = ImageOps.invert(mask)
+
+    # Mask image
+    masked_img = Image.composite(image_a, image_b, mask)
+
+    # Blend image
+    blend_mask = Image.new(mode="L", size=image_a.size,
+                           color=(round(blend_percentage * 255)))
+    blend_mask = ImageOps.invert(blend_mask)
+    img_result = Image.composite(image_a, masked_img, blend_mask)
+
+    del image_a, image_b, blend_mask, mask
+
+    return img_result
+
+def blend_images(image_a, image_b, blend_percentage):
+    """Blend img_b over image_a using the normal mode with a blend percentage."""
+    img_a = image_a.convert("RGBA")
+    img_b = image_b.convert("RGBA")
+
+    # Blend img_b over img_a using alpha_composite (normal blend mode)
+    out_image = Image.alpha_composite(img_a, img_b)
+
+    out_image = out_image.convert("RGB")
+
+    # Create blend mask
+    blend_mask = Image.new("L", image_a.size, round(blend_percentage * 255))
+    blend_mask = ImageOps.invert(blend_mask)  # Invert the mask
+
+    # Apply composite blend
+    result = Image.composite(image_a, out_image, blend_mask)
+    return result
+
+def apply_image_levels(image, black_level, mid_level, white_level):
+    levels = AdjustLevels(black_level, mid_level, white_level)
+    adjusted_image = levels.adjust(image)
+    return adjusted_image
+
+class AdjustLevels:
+    def __init__(self, min_level, mid_level, max_level):
+        self.min_level = min_level
+        self.mid_level = mid_level
+        self.max_level = max_level
+
+    def adjust(self, im):
+
+        im_arr = np.array(im).astype(np.float32)
+        im_arr[im_arr < self.min_level] = self.min_level
+        im_arr = (im_arr - self.min_level) * \
+            (255 / (self.max_level - self.min_level))
+        im_arr = np.clip(im_arr, 0, 255)
+
+        # mid-level adjustment
+        gamma = math.log(0.5) / math.log((self.mid_level - self.min_level) / (self.max_level - self.min_level))
+        im_arr = np.power(im_arr / 255, gamma) * 255
+
+        im_arr = im_arr.astype(np.uint8)
+
+        im = Image.fromarray(im_arr)
+
+        return im
+
+def resize_image(image, scaling_factor=1):
+    image = image.resize((int(image.width * scaling_factor), 
+        int(image.height * scaling_factor)))
+    return image
+
+def upscale_image(image, size):
+    new_image = image.resize((size, size), Image.LANCZOS)
+    return new_image
+
+def resize_to_square(image, size=1024):
+
+    # Load image if a file path is provided
+    if isinstance(image, str):
+        img = Image.open(image).convert("RGBA")
+    else:
+        img = image.convert("RGBA")  # If already an Image object
+
+    # Resize while maintaining aspect ratio
+    img.thumbnail((size, size), Image.LANCZOS)
+
+    # Create a transparent square canvas
+    square_img = Image.new("RGBA", (size, size), (0, 0, 0, 0))
+
+    # Calculate the position to paste the resized image (centered)
+    x_offset = (size - img.width) // 2
+    y_offset = (size - img.height) // 2
+
+    # Extract the alpha channel as a mask
+    mask = img.split()[3] if img.mode == "RGBA" else None
+
+    # Paste the resized image onto the square canvas with the correct transparency mask
+    square_img.paste(img, (x_offset, y_offset), mask)
+
+    return square_img
+
+
+def encode_image(image):
+    buffer = BytesIO()
+    image.save(buffer, format="PNG")
+    encoded_image = base64.b64encode(buffer.getvalue()).decode("utf-8")
+    return f"data:image/png;base64,{encoded_image}"
+
+def generate_ai_bg(input_img, prompt):
+    # input_img = resize_image(input_img, 0.01)
+    hf_input_img = encode_image(input_img)
+
+    handler = fal_client.submit(
+        "fal-ai/iclight-v2",
+        arguments={
+            "prompt": prompt,
+            "image_url": hf_input_img
+        },
+        webhook_url="https://optional.webhook.url/for/results",
+    )
+
+    request_id = handler.request_id
+
+    status = fal_client.status("fal-ai/iclight-v2", request_id, with_logs=True)
+
+    result = fal_client.result("fal-ai/iclight-v2", request_id)
+
+    relight_img_path = result['images'][0]['url']
+
+    response = requests.get(relight_img_path, stream=True)
+
+    relight_img = Image.open(BytesIO(response.content)).convert("RGBA")
+
+    # from gradio_client import Client, handle_file
+
+    # client = Client("lllyasviel/iclight-v2-vary")
+
+    # result = client.predict(
+    #         input_fg=handle_file(input_img),
+    #         bg_source="None",
+    #         prompt=prompt,
+    #         image_width=256,
+    #         image_height=256,
+    #         num_samples=1,
+    #         seed=12345,
+    #         steps=25,
+    #         n_prompt="lowres, bad anatomy, bad hands, cropped, worst quality",
+    #         cfg=2,
+    #         gs=5,
+    #         enable_hr_fix=True,
+    #         hr_downscale=0.5,
+    #         lowres_denoise=0.8,
+    #         highres_denoise=0.99,
+    #         api_name="/process"
+    # )
+    # print(result)
+
+    # relight_img_path = result[0][0]['image']
+
+    # relight_img = Image.open(relight_img_path).convert("RGBA")
+
+    return relight_img
+
+def blend_details(input_image, relit_image, masked_image, scaling_factor=1):
+
+    # input_image = resize_image(input_image)
+
+    # relit_image = resize_image(relit_image)
+
+    # masked_image = resize_image(masked_image)
+
+    masked_image_rgb = split_image_with_alpha(masked_image)
+    masked_image_blurred = gaussian_blur(masked_image_rgb, radius=10)
+    grow_mask = expand_mask(masked_image_blurred, -15, True)
+
+    # grow_mask.save("output/grow_mask.png")
+
+    # Split images and get RGB channels
+    input_image_rgb = split_image_with_alpha(input_image)
+    input_blurred = gaussian_blur(input_image_rgb, radius=10)
+    input_inverted = invert_image(input_image_rgb)
+
+    # input_blurred.save("output/input_blurred.png")
+    # input_inverted.save("output/input_inverted.png")
+        
+    # Add blurred and inverted images
+    input_blend_1 = blend_images(input_inverted, input_blurred, blend_percentage=0.5)
+    input_blend_1_inverted = invert_image(input_blend_1)
+    input_blend_2 = blend_images(input_blurred, input_blend_1_inverted, blend_percentage=1.0)
+
+    # input_blend_2.save("output/input_blend_2.png")
+
+    # Process relit image
+    relit_image_rgb = split_image_with_alpha(relit_image)
+    relit_blurred = gaussian_blur(relit_image_rgb, radius=10)
+    relit_inverted = invert_image(relit_image_rgb)
+
+    # relit_blurred.save("output/relit_blurred.png")
+    # relit_inverted.save("output/relit_inverted.png")
+    
+    # Add blurred and inverted relit images
+    relit_blend_1 = blend_images(relit_inverted, relit_blurred, blend_percentage=0.5)
+    relit_blend_1_inverted = invert_image(relit_blend_1)
+    relit_blend_2 = blend_images(relit_blurred, relit_blend_1_inverted, blend_percentage=1.0)
+
+    # relit_blend_2.save("output/relit_blend_2.png")
+
+    high_freq_comp = image_blend_by_mask(relit_blend_2, input_blend_2, grow_mask, blend_percentage=1.0)
+
+    # high_freq_comp.save("output/high_freq_comp.png")
+
+    comped_image = blend_images(relit_blurred, high_freq_comp, blend_percentage=0.65)
+
+    # comped_image.save("output/comped_image.png")
+
+    final_image = apply_image_levels(comped_image, black_level=83, mid_level=128, white_level=172)
+
+    # final_image.save("output/final_image.png")
+
+    return final_image
+
+@spaces.GPU
+def generate_image(input_image_path, prompt):
+
+    # resized_input_img = resize_to_square(input_image_path, 256)
+
+    # resized_input_img_path = '/tmp/gradio/resized_input_img.png'
+
+    # resized_input_img.convert("RGBA").save(resized_input_img_path, "PNG")
+
+    # ai_gen_image = generate_ai_bg(resized_input_img, prompt)
+
+    # upscaled_ai_image = upscale_image(ai_gen_image, 8192)
+
+    # upscaled_input_image = upscale_image(resized_input_img, 8192)
+
+    # mask_input_image = run_grounded_sam(upscaled_input_image)
+
+    # final_image = blend_details(upscaled_input_image, upscaled_ai_image, mask_input_image)
+
+    # FAL
+
+    resized_input_img = resize_to_square(input_image_path, 1024)
+
+    ai_gen_image = generate_ai_bg(resized_input_img, prompt)
+
+    mask_input_image = run_grounded_sam(resized_input_img)
+
+    final_image = blend_details(resized_input_img, ai_gen_image, mask_input_image)
+
+    return final_image
+
+def create_ui():
+    """Create Gradio UI for CarViz demo"""
+    with gr.Blocks(title="CarViz Demo") as block:
+        gr.Markdown("""
+        # CarViz
+        """)
+
+        with gr.Row():
+            with gr.Column():
+                input_image_path = gr.Image(type="filepath", label="image")
+                # ai_image = gr.Image(type="pil", label="image")
+                prompt = gr.Textbox(label="Prompt", placeholder="Enter your prompt here...")
+                run_button = gr.Button(value='Run')
+
+            with gr.Column():
+                output_image = gr.Image(label="Generated Image")
+        
+        # Run button
+        run_button.click(
+            fn=generate_image, 
+            inputs=[
+                input_image_path,
+                # ai_image,
+                prompt
+            ], 
+            outputs=[output_image]
+        )     
+ 
+    return block
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser("Carviz demo", add_help=True)
+    parser.add_argument("--debug", action="store_true", help="using debug mode")
+    parser.add_argument("--share", action="store_true", help="share the app")
+    parser.add_argument('--no-gradio-queue', action="store_true", help="disable gradio queue")
+    parser.add_argument('--port', type=int, default=7860, help="port to run the app")
+    parser.add_argument('--host', type=str, default="0.0.0.0", help="host to run the app")
+    args = parser.parse_args()
+
+    logger.info(f"Starting CarViz demo with args: {args}")
+    
+    # Check for model files
+    if not os.path.exists(GROUNDINGDINO_CHECKPOINT):
+        logger.warning(f"GroundingDINO checkpoint not found at {GROUNDINGDINO_CHECKPOINT}")
+    if not os.path.exists(SAM_CHECKPOINT):
+        logger.warning(f"SAM-HQ checkpoint not found at {SAM_CHECKPOINT}")
+    
+    # Create app
+    block = create_ui()
+    if not args.no_gradio_queue:
+        block = block.queue()
+    
+    # Launch app
+    try:
+        block.launch(
+            debug=args.debug, 
+            share=args.share, 
+            show_error=True,
+            server_name=args.host,
+            server_port=args.port
+        )
+    except Exception as e:
+        logger.error(f"Error launching app: {e}")