Update app.py

app.py

@@ -1,208 +1,659 @@
-import gradio as gr
-import requests
-import os
-import base64
-from io import BytesIO
-from PIL import Image
+import cv2
+import numpy as np
 import json
+import math
+import random
+from scipy.spatial.distance import cdist
+import gradio as gr # Import gradio
 
-def generate_image(prompt, cfg_scale, width, height, seed, steps, input_image=None):
+# Set random seed for reproducibility (remove if you want different results each time)
+random.seed(42)
+np.random.seed(42)
+
+# --- Image Processing and Contour Extraction ---
+
+def extract_curves_from_image_np(img_bgr_np):
+    """
+    Extract blue curves from a BGR numpy image array.
+    This is the core image processing function for contour extraction.
+    """
+    if img_bgr_np is None:
+        print("Input image numpy array is None.")
+        return []
+
+    # Convert BGR to HSV for better color segmentation
+    hsv = cv2.cvtColor(img_bgr_np, cv2.COLOR_BGR2HSV)
+
+    # Define range for blue color in HSV
+    lower_blue = np.array([90, 50, 50])
+    upper_blue = np.array([130, 255, 255])
+    mask = cv2.inRange(hsv, lower_blue, upper_blue)
+    
+    # Find contours from the mask
+    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    
+    # Sort contours by their x-coordinate to maintain a consistent order
+    contours = sorted(contours, key=lambda c: cv2.boundingRect(c)[0])
+    
+    # Filter out small contours that might be noise
+    return [c for c in contours if cv2.contourArea(c) > 20]
+
+def simplify_contour_high_fidelity(contour):
+    """
+    Simplify contour using Ramer-Douglas-Peucker algorithm while keeping high fidelity.
+    This reduces the number of points in the contour without losing significant shape details.
+    """
+    epsilon = 0.001 * cv2.arcLength(contour, True) # Smaller epsilon for higher fidelity
+    approx = cv2.approxPolyDP(contour, epsilon, False)
+    return [[int(p[0][0]), int(p[0][1])] for p in approx]
+
+def calculate_path_normals(curve_points):
     """
-    Generate image using NVIDIA's Flux.1-dev API
+    Calculate normal vectors for each point on the path.
+    These normals are initially perpendicular to the tangent at each point.
     """
-    try:
-        # Get API key from environment
-        api_key = os.getenv("NVIDIA_API_KEY")
-        if not api_key:
-            return None, "Error: NVIDIA_API_KEY environment variable not set"
+    normals = []
+    
+    for i in range(len(curve_points)):
+        # Get previous and next points to calculate the tangent vector
+        # Handle wrap-around for closed curves
+        if i == 0:
+            prev_point = curve_points[-1] if len(curve_points) > 2 else curve_points[i]
+            next_point = curve_points[i + 1]
+        elif i == len(curve_points) - 1:
+            prev_point = curve_points[i - 1]
+            next_point = curve_points[0] if len(curve_points) > 2 else curve_points[i]
+        else:
+            prev_point = curve_points[i - 1]
+            next_point = curve_points[i + 1]
         
-        # API endpoint
-        invoke_url = "https://ai.api.nvidia.com/v1/genai/black-forest-labs/flux.1-dev"
+        # Calculate tangent vector (vector from previous to next point)
+        tx = next_point[0] - prev_point[0]
+        ty = next_point[1] - prev_point[1]
         
-        # Headers
-        headers = {
-            "Authorization": f"Bearer {api_key}",
-            "Accept": "application/json",
-        }
+        # Normalize tangent vector
+        length = math.sqrt(tx*tx + ty*ty)
+        if length > 0:
+            tx /= length
+            ty /= length
         
-        # Prepare payload
-        payload = {
-            "prompt": prompt,
-            "cfg_scale": cfg_scale,
-            "width": int(width),
-            "height": int(height),
-            "seed": int(seed) if seed != -1 else 0,
-            "steps": int(steps)
-        }
+        # Calculate normal vector (perpendicular to tangent)
+        # (nx, ny) is (-ty, tx) or (ty, -tx)
+        nx = -ty
+        ny = tx
         
-        # Handle input image for img2img or control modes
-        if input_image is not None:
-            # Convert PIL image to base64
-            buffered = BytesIO()
-            input_image.save(buffered, format="PNG")
-            img_str = base64.b64encode(buffered.getvalue()).decode()
-            payload["image"] = f"data:image/png;base64,{img_str}"
-            payload["mode"] = "canny"  # You can make this configurable
-        
-        # Make API request
-        response = requests.post(invoke_url, headers=headers, json=payload, timeout=120)
-        response.raise_for_status()
-        
-        response_body = response.json()
-        
-        # Check if response contains image data
-        if "image" in response_body:
-            # Decode base64 image
-            image_data = response_body["image"]
-            if image_data.startswith("data:image"):
-                # Remove data URL prefix
-                image_data = image_data.split(",")[1]
-            
-            # Decode and create PIL Image
-            image_bytes = base64.b64decode(image_data)
-            image = Image.open(BytesIO(image_bytes))
-            
-            return image, f"✅ Image generated successfully!\nSeed used: {response_body.get('seed', 'unknown')}"
-        else:
-            return None, f"❌ Error: No image in response\n{json.dumps(response_body, indent=2)}"
-            
-    except requests.exceptions.RequestException as e:
-        return None, f"❌ API Request Error: {str(e)}"
-    except Exception as e:
-        return None, f"❌ Error: {str(e)}"
+        normals.append((nx, ny))
+    
+    return normals
+
+def determine_shape_center(curve_points):
+    """
+    Calculate the approximate center of the shape using the centroid of its points.
+    This is used to determine the "inward" direction for normals.
+    """
+    if not curve_points:
+        return (0, 0)
+    
+    # Calculate centroid
+    cx = sum(p[0] for p in curve_points) / len(curve_points)
+    cy = sum(p[1] for p in curve_points) / len(curve_points)
+    return (cx, cy)
 
-def create_gradio_interface():
+def adjust_normals_for_inward_direction(curve_points, normals):
     """
-    Create and configure the Gradio interface
+    Adjust normal vectors to point inward toward the shape center.
+    This is crucial for positioning elements inside the curve.
     """
+    center = determine_shape_center(curve_points)
+    adjusted_normals = []
     
-    with gr.Blocks(title="NVIDIA Flux.1-dev Image Generator", theme=gr.themes.Soft()) as demo:
-        gr.Markdown(
-            """
-            # 🎨 NVIDIA Flux.1-dev Image Generator
-            Generate high-quality images using NVIDIA's Flux.1-dev model via their API.
+    for i, (nx, ny) in enumerate(normals):
+        px, py = curve_points[i]
+        
+        # Vector from the current point on the curve to the shape's center
+        to_center_x = center[0] - px
+        to_center_y = center[1] - py
+        
+        # Check if the normal points towards the center using the dot product
+        # If dot product is negative, the normal points away from the center, so flip it
+        dot_product = nx * to_center_x + ny * to_center_y
+        
+        if dot_product < 0:
+            nx = -nx
+            ny = -ny
+        
+        adjusted_normals.append((nx, ny))
+    
+    return adjusted_normals
+
+# --- Ultra-Dense Point Generation ---
+
+def ultra_dense_poisson_sampling(width, height, radius, mask=None, max_attempts=100):
+    """
+    Ultra-dense Poisson disk sampling for distributing points evenly with a minimum distance.
+    This version is modified to generate fewer, more spread-out points by increasing the radius.
+    """
+    
+    cell_size = radius / math.sqrt(2) # Size of grid cells for efficient neighbor lookup
+    grid = {} # Stores points by their grid cell
+    points = [] # List of accepted points
+    active_list = [] # Points from which new candidates are generated
+    
+    if mask is not None:
+        valid_coords = np.where(mask > 0) # Get all coordinates where the mask is non-zero
+        if len(valid_coords[0]) == 0:
+            return points
+        
+        # Strategy: Place a few initial seed points strategically within the mask
+        num_seeds = min(20, len(valid_coords[0]) // 50 + 1) 
+        
+        # Randomly select indices for potential seed points
+        indices = np.random.choice(len(valid_coords[0]), min(num_seeds * 5, len(valid_coords[0])), replace=False)
+        
+        for idx in indices:
+            if len(points) >= num_seeds:
+                break
+                
+            start_point = (float(valid_coords[1][idx]), float(valid_coords[0][idx]))
+            
+            # Ensure seed points are not too close to each other
+            too_close = False
+            for existing_point in points:
+                dist = math.sqrt((start_point[0] - existing_point[0])**2 + (start_point[1] - existing_point[1])**2)
+                if dist < radius * 0.8: # Slightly closer for seeds to ensure initial spread
+                    too_close = True
+                    break
             
-            **Requirements:** Set your `NVIDIA_API_KEY` environment variable before running.
-            """
-        )
+            if not too_close:
+                points.append(start_point)
+                active_list.append(start_point)
+                
+                grid_x = int(start_point[0] // cell_size)
+                grid_y = int(start_point[1] // cell_size)
+                grid[(grid_y, grid_x)] = start_point
+    
+    # Aggressive expansion: try to find new points from active points
+    attempts = 0
+    max_total_attempts = 200000 # Increased limit for thoroughness
+    successful_placements = 0
+    
+    while active_list and attempts < max_total_attempts:
+        attempts += 1
+        
+        # Prefer newer points (at the end of the list) as they are more likely to have space around them
+        random_index = random.randint(0, len(active_list) - 1)
+        current_point = active_list[random_index]
+        found_valid = False
         
-        with gr.Row():
-            with gr.Column(scale=1):
-                # Input controls
-                prompt = gr.Textbox(
-                    label="Prompt",
-                    placeholder="Describe the image you want to generate...",
-                    lines=3,
-                    value="a simple coffee shop interior"
-                )
+        for attempt in range(max_attempts):
+            # Generate a candidate point in an annulus around the current point
+            angle = random.uniform(0, 2 * math.pi)
+            distance = random.uniform(radius, 2 * radius) # Annulus between r and 2r
+            
+            new_x = current_point[0] + distance * math.cos(angle)
+            new_y = current_point[1] + distance * math.sin(angle)
+            
+            # Check if the new point is within image bounds
+            if new_x < 0 or new_x >= width or new_y < 0 or new_y >= height:
+                continue
+            
+            # Check if the new point is within the mask
+            if mask is not None:
+                mask_x = int(round(new_x))
+                mask_y = int(round(new_y))
+                if (mask_y >= mask.shape[0] or mask_x >= mask.shape[1] or 
+                    mask[mask_y, mask_x] == 0): # Check if pixel is part of the masked area
+                    continue
+            
+            # Check minimum distance to existing points using the grid
+            grid_x = int(new_x // cell_size)
+            grid_y = int(new_y // cell_size)
+            
+            too_close = False
+            # Check neighboring cells (2 cells in each direction)
+            for dy in range(-2, 3):
+                for dx in range(-2, 3):
+                    check_key = (grid_y + dy, grid_x + dx)
+                    if check_key in grid:
+                        existing_point = grid[check_key]
+                        dist = math.sqrt((new_x - existing_point[0])**2 + (new_y - existing_point[1])**2)
+                        if dist < radius: # If any existing point is within 'radius' distance, it's too close
+                            too_close = True
+                            break
+                if too_close:
+                    break
+            
+            if not too_close:
+                new_point = (new_x, new_y)
+                points.append(new_point)
+                active_list.append(new_point)
+                grid[(grid_y, grid_x)] = new_point
+                found_valid = True
+                successful_placements += 1
+                break # Found a valid point, move to the next active point
+        
+        if not found_valid:
+            # If no valid point was found after max_attempts, remove current_point from active_list
+            active_list.pop(random_index)
+    
+    return points
+
+def multi_scale_grid_sampling(width, height, mask=None):
+    """
+    Multi-scale grid sampling for maximum coverage, used as a fallback.
+    This version uses larger grid spacings to generate fewer, more spread-out points.
+    """
+    
+    all_points = []
+    
+    # Multiple grid scales with larger spacings
+    spacings = [25, 35, 45] # Different, larger grid spacings
+    
+    for spacing in spacings:
+        points_this_scale = []
+        jitter = spacing * 0.3 # Less jitter for more structured placement
+        
+        y = spacing // 2
+        while y < height - spacing // 2:
+            x = spacing // 2
+            while x < width - spacing // 2:
+                # Add random jitter to the grid point for a more organic look
+                jx = x + random.uniform(-jitter, jitter)
+                jy = y + random.uniform(-jitter, jitter)
                 
-                input_image = gr.Image(
-                    label="Input Image (optional - for img2img/control)",
-                    type="pil",
-                    height=300
-                )
+                # Bounds check
+                if jx < 0 or jx >= width or jy < 0 or jy >= height:
+                    x += spacing
+                    continue
                 
-                with gr.Row():
-                    cfg_scale = gr.Slider(
-                        minimum=1.0,
-                        maximum=20.0,
-                        value=3.5,
-                        step=0.5,
-                        label="CFG Scale",
-                        info="Higher values follow prompt more closely"
-                    )
-                    
-                    steps = gr.Slider(
-                        minimum=10,
-                        maximum=100,
-                        value=50,
-                        step=5,
-                        label="Steps",
-                        info="More steps = higher quality but slower"
-                    )
+                # Mask check: ensure point is within the masked area
+                if mask is not None:
+                    mask_x = int(round(jx))
+                    mask_y = int(round(jy))
+                    if (mask_y >= mask.shape[0] or mask_x >= mask.shape[1] or 
+                        mask[mask_y, mask_x] == 0):
+                        x += spacing
+                        continue
                 
-                with gr.Row():
-                    width = gr.Dropdown(
-                        choices=[512, 768, 1024, 1280],
-                        value=1024,
-                        label="Width"
-                    )
-                    
-                    height = gr.Dropdown(
-                        choices=[512, 768, 1024, 1280],
-                        value=1024,
-                        label="Height"
-                    )
+                # Check distance to existing points from all scales to avoid overlaps
+                too_close = False
+                min_dist_for_this_scale = spacing * 0.8 # Minimum distance for this scale
+                
+                for existing_point in all_points:
+                    dist = math.sqrt((jx - existing_point[0])**2 + (jy - existing_point[1])**2)
+                    if dist < min_dist_for_this_scale:
+                        too_close = True
+                        break
                 
-                seed = gr.Number(
-                    label="Seed",
-                    value=-1,
-                    info="Use -1 for random seed"
-                )
+                if not too_close:
+                    points_this_scale.append((jx, jy))
+                    all_points.append((jx, jy)) # Add to the global list of points
                 
-                generate_btn = gr.Button(
-                    "🎨 Generate Image",
-                    variant="primary",
-                    size="lg"
-                )
-            
-            with gr.Column(scale=1):
-                # Output
-                output_image = gr.Image(
-                    label="Generated Image",
-                    type="pil",
-                    height=500
-                )
+                x += spacing
+            y += spacing
+    
+    return all_points
+
+def create_varied_rectangles(points, mask, curve_points, base_size=15, offset_distance=15):
+    """
+    Create highly varied organic rectangles positioned on the inner side of the path.
+    Rectangles are larger and fewer, aiming for coverage with fewer elements.
+    """
+    rectangles = []
+    
+    if len(points) < 1:
+        return rectangles
+    
+    # Calculate path normals for inward positioning if curve points are available
+    if curve_points:
+        normals = calculate_path_normals(curve_points)
+        adjusted_normals = adjust_normals_for_inward_direction(curve_points, normals)
+    else:
+        normals = []
+        adjusted_normals = []
+    
+    # Calculate local density (optional, for more nuanced sizing)
+    if len(points) > 10:
+        point_array = np.array(points)
+        distances = cdist(point_array, point_array)
+    else:
+        distances = None
+    
+    for i, (px, py) in enumerate(points):
+        # Size variation based on local density or random factor
+        if distances is not None and i < len(distances):
+            distances_to_point = distances[i]
+            # Find average distance to a few nearest neighbors
+            nearest_distances = sorted(distances_to_point[distances_to_point > 0])[:5]
+            
+            if nearest_distances:
+                avg_neighbor_dist = sum(nearest_distances) / len(nearest_distances)
+                # Adjust size factor based on neighbor distance relative to a reference (e.g., 20)
+                size_factor = max(0.5, min(1.5, avg_neighbor_dist / 20)) 
+            else:
+                size_factor = random.uniform(0.8, 1.2) # Default random factor
+        else:
+            size_factor = random.uniform(0.8, 1.2) # Default random factor
+        
+        # More varied rectangle dimensions based on base_size and size_factor
+        # Adjusted ranges to make rectangles taller and narrower
+        rect_width = base_size * size_factor * random.uniform(0.3, 0.6) # Slightly wider min width
+        rect_height = base_size * size_factor * random.uniform(1.5, 3.0) # Slightly shorter max height
+        
+        # Find closest path point for normal direction to position the rectangle
+        current_offset_x, current_offset_y = 0, 0
+        if curve_points and adjusted_normals:
+            min_dist_to_curve = float('inf')
+            closest_normal = (0, 0) # Default if no close point found
+            
+            for j, (cpx, cpy) in enumerate(curve_points):
+                dist = math.sqrt((px - cpx)**2 + (py - cpy)**2)
+                if dist < min_dist_to_curve:
+                    min_dist_to_curve = dist
+                    closest_normal = adjusted_normals[j]
+            
+            # Position rectangle on the inner side using the normal vector and offset distance
+            current_offset_x = closest_normal[0] * offset_distance
+            current_offset_y = closest_normal[1] * offset_distance
+        
+        # Calculate rectangle angle based on path tangent or local flow
+        angle = 0
+        if curve_points:
+            # Find closest path segment for tangent calculation
+            min_dist_for_angle = float('inf')
+            
+            for j in range(len(curve_points)):
+                cpx, cpy = curve_points[j]
+                dist = math.sqrt((px - cpx)**2 + (py - cpy)**2)
                 
-                status_text = gr.Textbox(
-                    label="Status",
-                    lines=3,
-                    interactive=False
-                )
-        
-        # Example prompts
-        gr.Markdown("### 💡 Example Prompts")
-        examples = gr.Examples(
-            examples=[
-                ["a cozy coffee shop with warm lighting and vintage furniture"],
-                ["a futuristic cityscape at sunset with flying cars"],
-                ["a magical forest with glowing mushrooms and fairy lights"],
-                ["a minimalist modern kitchen with marble countertops"],
-                ["a steampunk laboratory with brass machinery and glowing tubes"],
-                ["a serene mountain lake reflecting snow-capped peaks"],
-            ],
-            inputs=[prompt]
-        )
-        
-        # Event handlers
-        generate_btn.click(
-            fn=generate_image,
-            inputs=[prompt, cfg_scale, width, height, seed, steps, input_image],
-            outputs=[output_image, status_text]
-        )
-        
-        # Keyboard shortcut
-        prompt.submit(
-            fn=generate_image,
-            inputs=[prompt, cfg_scale, width, height, seed, steps, input_image],
-            outputs=[output_image, status_text]
-        )
-    
-    return demo
+                if dist < min_dist_for_angle:
+                    min_dist_for_angle = dist
+                    
+                    # Calculate tangent angle at this point
+                    if j < len(curve_points) - 1:
+                        next_point = curve_points[j + 1]
+                        dx = next_point[0] - cpx
+                        dy = next_point[1] - cpy
+                    elif j > 0:
+                        prev_point = curve_points[j - 1]
+                        dx = cpx - prev_point[0]
+                        dy = cpy - prev_point[1]
+                    else:
+                        dx, dy = 1, 0 # Default for single point or edge case
+                    
+                    # Angle aligned with path tangent (height of rectangle along tangent)
+                    # Add some random jitter to the angle for more organic feel
+                    angle = math.atan2(dy, dx) + random.uniform(-0.1, 0.1) 
+        else:
+            # Fallback: complex orientation patterns if no curve points
+            angle = (math.sin(px * 0.01) * 0.5 + 
+                    math.cos(py * 0.012) * 0.4 + 
+                    math.sin((px + py) * 0.008) * 0.3 +
+                    random.uniform(-0.5, 0.5))
+        
+        rectangles.append({
+            'x': px + current_offset_x,
+            'y': py + current_offset_y,
+            'width': rect_width,
+            'height': rect_height,
+            'angle': angle,
+            'size_factor': size_factor
+        })
+    
+    return rectangles
+
+def generate_id(prefix="el"):
+    """Generate a random ID for Excalidraw elements."""
+    return f"{prefix}_{''.join(random.choices('abcdefghijklmnopqrstuvwxyz013456789', k=9))}"
+
+# --- Gradio UI Function ---
+
+def generate_excalidraw_json_from_image(image_np):
+    """
+    Main function to generate Excalidraw JSON from an uploaded image.
+    This function is called by the Gradio interface.
+    """
+    if image_np is None:
+        return "Please upload an image to generate Excalidraw elements."
+
+    # Gradio's image input is typically RGB, OpenCV expects BGR
+    img_bgr = cv2.cvtColor(image_np, cv2.COLOR_RGB2BGR)
+
+    # Extract contours from the image
+    contours = extract_curves_from_image_np(img_bgr)
+    all_curves_points = [simplify_contour_high_fidelity(c) for c in contours]
+
+    final_elements = []
+    BASE_X, BASE_Y = 100, 100 # Base offset for all elements in Excalidraw
+
+    # Generate outline elements
+    for i, curve_points in enumerate(all_curves_points):
+        if not curve_points: # Skip empty curves
+            continue
+        start_x, start_y = curve_points[0][0], curve_points[0][1]
+        relative_points = [[p[0] - start_x, p[1] - start_y] for p in curve_points]
+        
+        outline_element = {
+            "id": generate_id("outline"), "type": "line",
+            "x": float(BASE_X + start_x), "y": float(BASE_Y + start_y), "angle": 0,
+            "strokeColor": "#00aaff", "backgroundColor": "transparent", "fillStyle": "solid",
+            "strokeWidth": 4, "strokeStyle": "solid", "roughness": 1, "opacity": 100,
+            "roundness": {"type": 2}, "points": relative_points,
+            "seed": random.randint(1000, 1000000), "version": 1, "versionNonce": random.randint(1000, 1000000)
+        }
+        final_elements.append(outline_element)
+
+    # Generate ultra-dense interior fill with rectangles if contours exist
+    if contours:
+        
+        # Create a bounding box that encompasses all contours
+        x_min = min([cv2.boundingRect(c)[0] for c in contours])
+        y_min = min([cv2.boundingRect(c)[1] for c in contours])
+        x_max = max([cv2.boundingRect(c)[0] + cv2.boundingRect(c)[2] for c in contours])
+        y_max = max([cv2.boundingRect(c)[1] + cv2.boundingRect(c)[3] for c in contours])
+        
+        # Create a mask image to define the valid area for point sampling
+        mask_width = x_max + 40
+        mask_height = y_max + 40
+        mask = np.zeros((mask_height, mask_width), dtype=np.uint8)
+        
+        cv2.drawContours(mask, contours, -1, 255, thickness=cv2.FILLED)
+        
+        kernel = np.ones((3,3), np.uint8)
+        mask = cv2.erode(mask, kernel, iterations=1)
+        
+        min_distance_between_points = 25 
+        sample_points = ultra_dense_poisson_sampling(mask.shape[1], mask.shape[0], min_distance_between_points, mask)
+        
+        if len(sample_points) < 70: 
+            grid_points = multi_scale_grid_sampling(mask.shape[1], mask.shape[0], mask)
+            
+            for gp in grid_points:
+                too_close = False
+                for sp in sample_points:
+                    if math.sqrt((gp[0] - sp[0])**2 + (gp[1] - sp[0])**2) < min_distance_between_points * 0.8:
+                        too_close = True
+                        break
+                if not too_close:
+                    sample_points.append(gp)
+        
+        all_path_points = []
+        for curve in all_curves_points:
+            all_path_points.extend(curve)
+        
+        rectangles = create_varied_rectangles(sample_points, mask, all_path_points, 
+                                              base_size=15, offset_distance=15)
+        
+        # Expanded color schemes for more variety
+        color_schemes = [
+            # Warm tones
+            ('#ff6b6b', '#feca57', '#ff9ff3', '#ffbe76', '#f0932b'), 
+            # Cool tones
+            ('#74b9ff', '#00cec9', '#6c5ce7', '#a29bfe', '#81ecec'),  
+            # Sunset/Earthy tones
+            ('#fd79a8', '#fdcb6e', '#e17055', '#d63031', '#ffeaa7'),  
+            # Green/Nature tones
+            ('#55efc4', '#00b894', '#00d2d3', '#00b894', '#006266'),
+            # Muted/Pastel tones
+            ('#a4b0be', '#dfe6e9', '#b2bec3', '#636e72', '#2d3436'),
+            # Vibrant tones
+            ('#ff7675', '#fdcb6e', '#a29bfe', '#ffeaa7', '#55efc4'),
+            # Darker, richer tones
+            ('#2c3e50', '#34495e', '#7f8c8d', '#95a5a6', '#bdc3c7')
+        ]
+        
+        scheme = random.choice(color_schemes) 
+        
+        for i, rect in enumerate(rectangles):
+            base_color_hex = random.choice(scheme)
+            r = int(base_color_hex[1:3], 16)
+            g = int(base_color_hex[3:5], 16) 
+            b = int(base_color_hex[5:7], 16)
+            
+            r = max(0, min(255, r + random.randint(-30, 30))) 
+            g = max(0, min(255, g + random.randint(-30, 30)))
+            b = max(0, min(255, b + random.randint(-30, 30)))
+            
+            bg_color = f"#{r:02x}{g:02x}{b:02x}"
+            
+            base_opacity = 60 + (rect['size_factor'] - 0.8) * 20 
+            opacity = max(40, min(90, base_opacity + random.randint(-15, 15))) 
+            
+            fill_styles = ['solid', 'cross-hatch', 'dots', 'hachure'] 
+            weights = [0.6, 0.2, 0.1, 0.1] 
+            fill_style = random.choices(fill_styles, weights=weights)[0]
+            
+            # Adjusted stroke weights: more likely to have a stroke, with varied thickness
+            stroke_width = random.uniform(0.5, 2.0) if random.random() < 0.95 else 0 
+            
+            rect_x = BASE_X + rect['x'] - rect['width'] / 2
+            rect_y = BASE_Y + rect['y'] - rect['height'] / 2
+            
+            rect_element = {
+                "id": generate_id("rect_dense"), 
+                "type": "rectangle",
+                "x": float(rect_x),
+                "y": float(rect_y),
+                "width": rect['width'], 
+                "height": rect['height'],
+                "angle": rect['angle'], 
+                "strokeColor": "#8e9094", 
+                "backgroundColor": bg_color,
+                "fillStyle": fill_style, 
+                "strokeWidth": stroke_width, 
+                "strokeStyle": "solid",
+                "roughness": random.uniform(0.7, 1.5), 
+                "opacity": opacity,
+                "roundness": {"type": 3}, 
+                "seed": random.randint(1000, 1000000), 
+                "version": 1,
+                "versionNonce": random.randint(1000, 1000000)
+            }
+            final_elements.append(rect_element)
+    else:
+        # If no contours found from image, use fallback data for rectangles too
+        # This part ensures that even if the image processing fails, something is generated.
+        print("⚠️  No contours found from uploaded image for rectangle generation. Using fallback data.")
+        fallback_all_curves_points = [
+            [[194, 53],[192, 81],[191, 108],[191, 137],[192, 166],[192, 195],[194, 224],[197, 252],[200, 281],[205, 309],[210, 336],[214, 362],[219, 390],[225, 423]],
+            [[230, 429],[239, 452],[249, 475],[258, 497],[271, 519],[287, 539],[304, 553],[320, 560],[341, 569],[365, 576],[394, 580],[425, 580],[455, 574],[484, 564],[513, 552],[538, 546],[565, 523],[590, 499],[620, 465],[639, 432],[656, 396],[656, 363],[657, 329],[657, 294],[657, 260],[649, 222],[637, 185],[623, 147],[603, 110],[578, 83],[558, 71],[540, 68],[517, 59],[492, 51],[461, 46],[443, 45],[426, 46]],
+            [[426, 44], [430, 20], [434, 0]]
+        ]
+        fallback_contours = [np.array(c).reshape((-1, 1, 2)).astype(np.int32) for c in fallback_all_curves_points]
+
+        # Create mask for fallback data
+        x_min_f = min([cv2.boundingRect(c)[0] for c in fallback_contours])
+        y_min_f = min([cv2.boundingRect(c)[1] for c in fallback_contours])
+        x_max_f = max([cv2.boundingRect(c)[0] + cv2.boundingRect(c)[2] for c in fallback_contours])
+        y_max_f = max([cv2.boundingRect(c)[1] + cv2.boundingRect(c)[3] for c in fallback_contours])
+        mask_width_f = x_max_f + 40
+        mask_height_f = y_max_f + 40
+        mask_f = np.zeros((mask_height_f, mask_width_f), dtype=np.uint8)
+        cv2.drawContours(mask_f, fallback_contours, -1, 255, thickness=cv2.FILLED)
+        kernel_f = np.ones((3,3), np.uint8)
+        mask_f = cv2.erode(mask_f, kernel_f, iterations=1)
+
+        min_distance_between_points = 25
+        sample_points_f = ultra_dense_poisson_sampling(mask_f.shape[1], mask_f.shape[0], min_distance_between_points, mask_f)
+        if len(sample_points_f) < 70:
+            grid_points_f = multi_scale_grid_sampling(mask_f.shape[1], mask_f.shape[0], mask_f)
+            for gp_f in grid_points_f:
+                too_close = False
+                for sp_f in sample_points_f:
+                    if math.sqrt((gp_f[0] - sp_f[0])**2 + (gp_f[1] - sp_f[1])**2) < min_distance_between_points * 0.8:
+                        too_close = True
+                        break
+                if not too_close:
+                    sample_points_f.append(gp_f)
+
+        rectangles_f = create_varied_rectangles(sample_points_f, mask_f, fallback_all_curves_points, 
+                                              base_size=15, offset_distance=15)
+        
+        # Generate elements for fallback rectangles
+        # Use a random color scheme for fallback as well
+        fallback_scheme = random.choice(color_schemes) 
+        for i, rect in enumerate(rectangles_f):
+            base_color_hex = random.choice(fallback_scheme) 
+            r = int(base_color_hex[1:3], 16)
+            g = int(base_color_hex[3:5], 16) 
+            b = int(base_color_hex[5:7], 16)
+            r = max(0, min(255, r + random.randint(-30, 30))) 
+            g = max(0, min(255, g + random.randint(-30, 30)))
+            b = max(0, min(255, b + random.randint(-30, 30)))
+            bg_color = f"#{r:02x}{g:02x}{b:02x}"
+            
+            base_opacity = 60 + (rect['size_factor'] - 0.8) * 20 
+            opacity = max(40, min(90, base_opacity + random.randint(-15, 15))) 
+            
+            fill_styles = ['solid', 'cross-hatch', 'dots', 'hachure'] 
+            weights = [0.6, 0.2, 0.1, 0.1] 
+            fill_style = random.choices(fill_styles, weights=weights)[0]
+            
+            stroke_width = random.uniform(0.5, 2.0) if random.random() < 0.95 else 0 
+            
+            rect_x = BASE_X + rect['x'] - rect['width'] / 2
+            rect_y = BASE_Y + rect['y'] - rect['height'] / 2
+            
+            rect_element = {
+                "id": generate_id("rect_dense_fallback"), # Different ID prefix for fallback
+                "type": "rectangle",
+                "x": float(rect_x),
+                "y": float(rect_y),
+                "width": rect['width'], 
+                "height": rect['height'],
+                "angle": rect['angle'], 
+                "strokeColor": "#8e9094", 
+                "backgroundColor": bg_color,
+                "fillStyle": fill_style, 
+                "strokeWidth": stroke_width, 
+                "strokeStyle": "solid",
+                "roughness": random.uniform(0.7, 1.5), 
+                "opacity": opacity,
+                "roundness": {"type": 3}, 
+                "seed": random.randint(1000, 1000000), 
+                "version": 1,
+                "versionNonce": random.randint(1000, 1000000)
+            }
+            final_elements.append(rect_element)
+
+
+    final_excalidraw_structure = {
+        "type": "excalidraw/clipboard",
+        "elements": final_elements,
+        "files": {}
+    }
+    return json.dumps(final_excalidraw_structure, indent=2)
+
+# Gradio interface definition
+iface = gr.Interface(
+    fn=generate_excalidraw_json_from_image,
+    inputs=gr.Image(type="numpy", label="Upload Image (Blue Curves)"),
+    outputs=gr.Textbox(label="Excalidraw JSON Output (Copy & Paste into Excalidraw)"),
+    title="Excalidraw Organic Rectangle Generator",
+    description="Upload an image containing blue curves. The tool will generate Excalidraw JSON data "
+                "with organic, aligned rectangles filling the interior of the curves. "
+                "The rectangles are designed to trace the path and avoid significant overlap."
+)
 
 if __name__ == "__main__":
-    # Check if API key is set
-    if not os.getenv("NVIDIA_API_KEY"):
-        print("⚠️  Warning: NVIDIA_API_KEY environment variable not set!")
-        print("Please set it before running the app:")
-        print("export NVIDIA_API_KEY=your_api_key_here")
-        print()
-    
-    # Create and launch the app
-    demo = create_gradio_interface()
-    demo.launch(
-        share=False,  # Set to True if you want a public link
-        server_name="0.0.0.0",  # Allow external connections
-        server_port=7860,
-        show_error=True
-    )
+    iface.launch()