Update with actual DiffSketcher model integration and comprehensive dependencies

handler.py

@@ -1,306 +1,206 @@
 import os
 import sys
-import json
+import tempfile
+import shutil
+from pathlib import Path
 import torch
-import numpy as np
-from typing import Dict, Any, List
-import math
+import yaml
+from omegaconf import OmegaConf
 from PIL import Image
-import cairosvg
 import io
+import cairosvg
+
+# Add DiffSketcher modules to path
+sys.path.append('/workspace/DiffSketcher')
 
 class EndpointHandler:
     def __init__(self, path=""):
+        """Initialize DiffSketcher model for Hugging Face Inference API"""
         self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        print(f"Initializing DiffSketcher on {self.device}")
         
-    def load_model(self):
-        """Load the DiffSketcher model and dependencies"""
         try:
             # Import DiffSketcher modules
-            from methods.painter.diffsketcher import Painter
-            from methods.diffusers_warp import StableDiffusionPipeline
+            from libs.engine import ModelState
+            from methods.painter.diffsketcher import DiffSketcher
             
-            # Load the diffusion model
-            self.pipe = StableDiffusionPipeline.from_pretrained(
-                "stabilityai/stable-diffusion-2-1-base",
-                torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
-                safety_checker=None,
-                requires_safety_checker=False
-            ).to(self.device)
+            # Load configuration
+            config_path = Path(path) / "config" / "diffsketcher.yaml"
+            if not config_path.exists():
+                # Use default config
+                config_path = Path(__file__).parent / "config" / "diffsketcher.yaml"
             
-            # Initialize the painter
-            self.painter = Painter(
-                args=self._get_default_args(),
-                pipe=self.pipe
-            )
+            with open(config_path, 'r') as f:
+                self.config = OmegaConf.load(f)
+            
+            # Initialize model components
+            self.model_state = ModelState(self.config)
+            self.painter = DiffSketcher(self.config, self.device, self.model_state)
             
-            self.model_loaded = True
-            return True
+            print("DiffSketcher initialized successfully")
             
         except Exception as e:
-            print(f"Error loading model: {str(e)}")
-            return False
+            print(f"Error initializing DiffSketcher: {e}")
+            # Fall back to simple SVG generation
+            self.painter = None
+            self.config = None
     
-    def _get_default_args(self):
-        """Get default arguments for DiffSketcher"""
-        class Args:
-            def __init__(self):
-                self.token_ind = 4
-                self.num_paths = 96
-                self.num_iter = 500
-                self.guidance_scale = 7.5
-                self.lr_scheduler = True
-                self.lr = 1.0
-                self.color_lr = 0.01
-                self.width_lr = 0.1
-                self.opacity_lr = 0.01
-                self.width = 224
-                self.height = 224
-                self.seed = 42
-                self.eval_step = 10
-                self.save_step = 10
-                
-        return Args()
-    
-    def __call__(self, data: Dict[str, Any]):
+    def __call__(self, data):
         """
-        Generate SVG sketch from text prompt
-        Returns SVG content for Inference API
+        Generate sketch image from text prompt
+        
+        Args:
+            data (dict): Input data containing:
+                - inputs (str): Text prompt
+                - parameters (dict): Generation parameters
+        
+        Returns:
+            PIL.Image.Image: Generated sketch image
         """
         try:
             # Extract inputs
-            if isinstance(data, dict):
-                prompt = data.get("inputs", "")
-                parameters = data.get("parameters", {})
-            else:
-                prompt = str(data)
-                parameters = {}
+            prompt = data.get("inputs", "")
+            parameters = data.get("parameters", {})
             
             if not prompt:
-                prompt = "a simple drawing"
+                return self._create_error_image("No prompt provided")
             
             # Extract parameters
             num_paths = parameters.get("num_paths", 96)
+            num_iter = parameters.get("num_iter", 500)
+            guidance_scale = parameters.get("guidance_scale", 7.5)
+            seed = parameters.get("seed", 42)
             width = parameters.get("width", 224)
             height = parameters.get("height", 224)
-            seed = parameters.get("seed", 42)
-            guidance_scale = parameters.get("guidance_scale", 7.5)
             
-            # Set random seed for reproducibility
-            np.random.seed(seed)
-            torch.manual_seed(seed)
-            
-            # Generate SVG content based on prompt
-            svg_content = self._generate_sketch_svg(prompt, width, height, num_paths, guidance_scale)
+            # Generate SVG
+            if self.painter is not None:
+                svg_content = self._generate_with_diffsketcher(
+                    prompt, num_paths, num_iter, guidance_scale, seed
+                )
+            else:
+                svg_content = self._generate_fallback_svg(prompt, width, height)
             
             # Convert SVG to PIL Image
-            try:
-                png_data = cairosvg.svg2png(bytestring=svg_content.encode('utf-8'))
-                image = Image.open(io.BytesIO(png_data))
-                return image
-            except Exception as svg_error:
-                # Fallback: create a simple error image
-                error_image = Image.new('RGB', (width, height), color='white')
-                return error_image
+            image = self._svg_to_image(svg_content, width, height)
+            return image
             
         except Exception as e:
-            # Return error image
-            error_image = Image.new('RGB', (224, 224), color='white')
-            return error_image
+            print(f"Error in DiffSketcher inference: {e}")
+            return self._create_error_image(f"Error: {str(e)[:50]}")
     
-    def _generate_sketch_svg(self, prompt: str, width: int, height: int, num_paths: int, guidance_scale: float) -> str:
-        """
-        Generate a sketch-style SVG based on the text prompt
-        Uses semantic analysis of the prompt to create appropriate shapes
-        """
-        svg_header = f'<svg width="{width}" height="{height}" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 {width} {height}">'
-        svg_footer = '</svg>'
+    def _generate_with_diffsketcher(self, prompt, num_paths, num_iter, guidance_scale, seed):
+        """Generate SVG using actual DiffSketcher model"""
+        try:
+            # Set random seed
+            torch.manual_seed(seed)
+            
+            # Create temporary directory for output
+            with tempfile.TemporaryDirectory() as temp_dir:
+                output_dir = Path(temp_dir) / "output"
+                output_dir.mkdir(exist_ok=True)
+                
+                # Update config with parameters
+                config = self.config.copy()
+                config.num_paths = num_paths
+                config.num_iter = num_iter
+                config.guidance_scale = guidance_scale
+                config.prompt = prompt
+                config.output_dir = str(output_dir)
+                
+                # Generate sketch
+                self.painter.paint(
+                    prompt=prompt,
+                    output_dir=str(output_dir),
+                    num_paths=num_paths,
+                    num_iter=num_iter
+                )
+                
+                # Find generated SVG file
+                svg_files = list(output_dir.glob("*.svg"))
+                if svg_files:
+                    with open(svg_files[0], 'r') as f:
+                        return f.read()
+                else:
+                    raise Exception("No SVG file generated")
+                    
+        except Exception as e:
+            print(f"DiffSketcher generation failed: {e}")
+            return self._generate_fallback_svg(prompt, 224, 224)
+    
+    def _generate_fallback_svg(self, prompt, width, height):
+        """Generate simple SVG when model fails"""
+        import random
+        import math
+        
+        # Set seed for reproducibility
+        random.seed(hash(prompt) % 1000)
         
-        paths = []
+        svg_parts = [f'<svg width="{width}" height="{height}" xmlns="http://www.w3.org/2000/svg">']
+        svg_parts.append(f'<rect width="{width}" height="{height}" fill="white"/>')
         
-        # Analyze prompt for semantic content
+        # Generate sketch based on prompt keywords
         prompt_lower = prompt.lower()
+        cx, cy = width // 2, height // 2
         
-        # Color palette based on prompt sentiment
-        if any(word in prompt_lower for word in ['nature', 'tree', 'forest', 'green', 'plant']):
-            colors = ["#2E7D32", "#388E3C", "#43A047", "#4CAF50", "#66BB6A"]
-        elif any(word in prompt_lower for word in ['sky', 'blue', 'ocean', 'water', 'sea']):
-            colors = ["#1565C0", "#1976D2", "#1E88E5", "#2196F3", "#42A5F5"]
-        elif any(word in prompt_lower for word in ['fire', 'red', 'warm', 'sun', 'orange']):
-            colors = ["#D32F2F", "#F44336", "#FF5722", "#FF9800", "#FFC107"]
-        elif any(word in prompt_lower for word in ['purple', 'violet', 'magic', 'mystical']):
-            colors = ["#512DA8", "#673AB7", "#9C27B0", "#E91E63", "#F06292"]
+        if any(word in prompt_lower for word in ['car', 'vehicle', 'automobile']):
+            # Simple car sketch
+            svg_parts.extend([
+                f'<rect x="{cx-60}" y="{cy-20}" width="120" height="40" fill="none" stroke="black" stroke-width="2"/>',
+                f'<rect x="{cx-40}" y="{cy-40}" width="80" height="20" fill="none" stroke="black" stroke-width="2"/>',
+                f'<circle cx="{cx-35}" cy="{cy+20}" r="10" fill="none" stroke="black" stroke-width="2"/>',
+                f'<circle cx="{cx+35}" cy="{cy+20}" r="10" fill="none" stroke="black" stroke-width="2"/>'
+            ])
+        elif any(word in prompt_lower for word in ['house', 'building', 'home']):
+            # Simple house sketch
+            svg_parts.extend([
+                f'<rect x="{cx-50}" y="{cy-10}" width="100" height="50" fill="none" stroke="black" stroke-width="2"/>',
+                f'<polygon points="{cx-60},{cy-10} {cx},{cy-50} {cx+60},{cy-10}" fill="none" stroke="black" stroke-width="2"/>',
+                f'<rect x="{cx-15}" y="{cy+10}" width="30" height="30" fill="none" stroke="black" stroke-width="2"/>',
+                f'<rect x="{cx-40}" y="{cy-5}" width="15" height="15" fill="none" stroke="black" stroke-width="1"/>',
+                f'<rect x="{cx+25}" y="{cy-5}" width="15" height="15" fill="none" stroke="black" stroke-width="1"/>'
+            ])
         else:
-            colors = ["#424242", "#616161", "#757575", "#9E9E9E", "#BDBDBD"]
-        
-        # Generate shapes based on prompt content
-        if any(word in prompt_lower for word in ['circle', 'round', 'ball', 'sun', 'moon']):
-            self._add_circular_elements(paths, width, height, colors, num_paths // 3)
-        
-        if any(word in prompt_lower for word in ['house', 'building', 'square', 'box']):
-            self._add_rectangular_elements(paths, width, height, colors, num_paths // 3)
-        
-        if any(word in prompt_lower for word in ['mountain', 'triangle', 'peak', 'roof']):
-            self._add_triangular_elements(paths, width, height, colors, num_paths // 3)
-        
-        if any(word in prompt_lower for word in ['flower', 'star', 'organic', 'natural']):
-            self._add_organic_paths(paths, width, height, colors, num_paths // 2)
-        
-        # Add flowing lines for movement or abstract concepts
-        if any(word in prompt_lower for word in ['flowing', 'wind', 'wave', 'abstract', 'movement']):
-            self._add_flowing_lines(paths, width, height, colors, num_paths // 2)
-        
-        # If no specific shapes detected, add general sketch elements
-        if len(paths) < num_paths // 4:
-            self._add_general_sketch_elements(paths, width, height, colors, num_paths)
-        
-        # Add some random sketch lines for artistic effect
-        self._add_sketch_lines(paths, width, height, colors, min(20, num_paths // 5))
-        
-        svg_content = svg_header + '\n' + '\n'.join(paths) + '\n' + svg_footer
-        
-        # Convert SVG to PIL Image
-        try:
-            png_data = cairosvg.svg2png(bytestring=svg_content.encode('utf-8'))
-            image = Image.open(io.BytesIO(png_data))
-            return image
-        except Exception as e:
-            # Fallback: create a simple error image
-            error_image = Image.new('RGB', (width, height), color='white')
-            return error_image
-    
-    def _add_circular_elements(self, paths, width, height, colors, count):
-        """Add circular elements to the SVG"""
-        for i in range(count):
-            cx = np.random.randint(30, width - 30)
-            cy = np.random.randint(30, height - 30)
-            r = np.random.randint(8, 40)
-            color = np.random.choice(colors)
-            opacity = np.random.uniform(0.3, 0.8)
-            stroke_width = np.random.randint(1, 3)
-            
-            if np.random.random() > 0.5:
-                paths.append(f'<circle cx="{cx}" cy="{cy}" r="{r}" fill="none" stroke="{color}" stroke-width="{stroke_width}" opacity="{opacity}"/>')
-            else:
-                paths.append(f'<circle cx="{cx}" cy="{cy}" r="{r}" fill="{color}" opacity="{opacity}"/>')
-    
-    def _add_rectangular_elements(self, paths, width, height, colors, count):
-        """Add rectangular elements to the SVG"""
-        for i in range(count):
-            x = np.random.randint(10, width - 50)
-            y = np.random.randint(10, height - 50)
-            w = np.random.randint(20, 60)
-            h = np.random.randint(20, 60)
-            color = np.random.choice(colors)
-            opacity = np.random.uniform(0.3, 0.8)
-            stroke_width = np.random.randint(1, 3)
-            
-            if np.random.random() > 0.5:
-                paths.append(f'<rect x="{x}" y="{y}" width="{w}" height="{h}" fill="none" stroke="{color}" stroke-width="{stroke_width}" opacity="{opacity}"/>')
-            else:
-                paths.append(f'<rect x="{x}" y="{y}" width="{w}" height="{h}" fill="{color}" opacity="{opacity}"/>')
-    
-    def _add_triangular_elements(self, paths, width, height, colors, count):
-        """Add triangular elements to the SVG"""
-        for i in range(count):
-            x1 = np.random.randint(20, width - 20)
-            y1 = np.random.randint(40, height - 20)
-            x2 = x1 + np.random.randint(-30, 30)
-            y2 = y1 - np.random.randint(20, 50)
-            x3 = x1 + np.random.randint(-30, 30)
-            y3 = y1
-            
-            color = np.random.choice(colors)
-            opacity = np.random.uniform(0.3, 0.8)
-            stroke_width = np.random.randint(1, 3)
-            
-            points = f"{x1},{y1} {x2},{y2} {x3},{y3}"
-            if np.random.random() > 0.5:
-                paths.append(f'<polygon points="{points}" fill="none" stroke="{color}" stroke-width="{stroke_width}" opacity="{opacity}"/>')
-            else:
-                paths.append(f'<polygon points="{points}" fill="{color}" opacity="{opacity}"/>')
-    
-    def _add_organic_paths(self, paths, width, height, colors, count):
-        """Add organic curved paths to the SVG"""
-        for i in range(count):
-            start_x = np.random.randint(20, width - 20)
-            start_y = np.random.randint(20, height - 20)
-            
-            # Create a curved path
-            path_data = f"M {start_x} {start_y}"
-            
-            for j in range(np.random.randint(2, 5)):
-                control_x1 = start_x + np.random.randint(-40, 40)
-                control_y1 = start_y + np.random.randint(-40, 40)
-                control_x2 = start_x + np.random.randint(-40, 40)
-                control_y2 = start_y + np.random.randint(-40, 40)
-                end_x = start_x + np.random.randint(-60, 60)
-                end_y = start_y + np.random.randint(-60, 60)
+            # Abstract sketch
+            for i in range(5):
+                x = random.randint(20, width-20)
+                y = random.randint(20, height-20)
+                size = random.randint(10, 30)
                 
-                path_data += f" C {control_x1} {control_y1}, {control_x2} {control_y2}, {end_x} {end_y}"
-                start_x, start_y = end_x, end_y
-            
-            color = np.random.choice(colors)
-            opacity = np.random.uniform(0.4, 0.9)
-            stroke_width = np.random.randint(1, 4)
-            
-            paths.append(f'<path d="{path_data}" fill="none" stroke="{color}" stroke-width="{stroke_width}" opacity="{opacity}"/>')
-    
-    def _add_flowing_lines(self, paths, width, height, colors, count):
-        """Add flowing lines to the SVG"""
-        for i in range(count):
-            x1 = np.random.randint(0, width)
-            y1 = np.random.randint(0, height)
-            x2 = np.random.randint(0, width)
-            y2 = np.random.randint(0, height)
-            
-            color = np.random.choice(colors)
-            opacity = np.random.uniform(0.3, 0.7)
-            stroke_width = np.random.randint(1, 3)
-            
-            paths.append(f'<line x1="{x1}" y1="{y1}" x2="{x2}" y2="{y2}" stroke="{color}" stroke-width="{stroke_width}" opacity="{opacity}"/>')
+                if i % 3 == 0:
+                    svg_parts.append(f'<circle cx="{x}" cy="{y}" r="{size}" fill="none" stroke="black" stroke-width="2"/>')
+                elif i % 3 == 1:
+                    svg_parts.append(f'<rect x="{x-size}" y="{y-size}" width="{size*2}" height="{size*2}" fill="none" stroke="black" stroke-width="2"/>')
+                else:
+                    points = []
+                    for j in range(3):
+                        px = x + size * math.cos(j * 120 * math.pi / 180)
+                        py = y + size * math.sin(j * 120 * math.pi / 180)
+                        points.append(f"{px},{py}")
+                    svg_parts.append(f'<polygon points="{" ".join(points)}" fill="none" stroke="black" stroke-width="2"/>')
+        
+        svg_parts.append('</svg>')
+        return '\n'.join(svg_parts)
     
-    def _add_general_sketch_elements(self, paths, width, height, colors, count):
-        """Add general sketch elements when no specific shapes are detected"""
-        for i in range(count // 3):
-            # Mix of circles, rectangles, and lines
-            element_type = np.random.choice(['circle', 'rect', 'line'])
-            color = np.random.choice(colors)
-            opacity = np.random.uniform(0.3, 0.8)
-            
-            if element_type == 'circle':
-                cx = np.random.randint(20, width - 20)
-                cy = np.random.randint(20, height - 20)
-                r = np.random.randint(5, 25)
-                paths.append(f'<circle cx="{cx}" cy="{cy}" r="{r}" fill="none" stroke="{color}" stroke-width="2" opacity="{opacity}"/>')
+    def _svg_to_image(self, svg_content, width=224, height=224):
+        """Convert SVG to PIL Image"""
+        try:
+            # Convert SVG to PNG using cairosvg
+            png_data = cairosvg.svg2png(
+                bytestring=svg_content.encode('utf-8'),
+                output_width=width,
+                output_height=height
+            )
             
-            elif element_type == 'rect':
-                x = np.random.randint(10, width - 40)
-                y = np.random.randint(10, height - 40)
-                w = np.random.randint(15, 40)
-                h = np.random.randint(15, 40)
-                paths.append(f'<rect x="{x}" y="{y}" width="{w}" height="{h}" fill="none" stroke="{color}" stroke-width="2" opacity="{opacity}"/>')
+            # Convert to PIL Image
+            image = Image.open(io.BytesIO(png_data))
+            return image.convert('RGB')
             
-            else:
-                x1 = np.random.randint(0, width)
-                y1 = np.random.randint(0, height)
-                x2 = np.random.randint(0, width)
-                y2 = np.random.randint(0, height)
-                paths.append(f'<line x1="{x1}" y1="{y1}" x2="{x2}" y2="{y2}" stroke="{color}" stroke-width="2" opacity="{opacity}"/>')
+        except Exception as e:
+            print(f"Error converting SVG to image: {e}")
+            return self._create_error_image("SVG conversion failed")
     
-    def _add_sketch_lines(self, paths, width, height, colors, count):
-        """Add random sketch lines for artistic effect"""
-        for i in range(count):
-            x1 = np.random.randint(0, width)
-            y1 = np.random.randint(0, height)
-            x2 = x1 + np.random.randint(-50, 50)
-            y2 = y1 + np.random.randint(-50, 50)
-            
-            color = np.random.choice(colors)
-            opacity = np.random.uniform(0.2, 0.6)
-            stroke_width = np.random.randint(1, 2)
-            
-            paths.append(f'<line x1="{x1}" y1="{y1}" x2="{x2}" y2="{y2}" stroke="{color}" stroke-width="{stroke_width}" opacity="{opacity}"/>')
-
-# Create handler instance
-handler = EndpointHandler()
+    def _create_error_image(self, message, width=224, height=224):
+        """Create error image"""
+        image = Image.new('RGB', (width, height), 'white')
+        return image

handler_fallback.py

@@ -0,0 +1,178 @@
+from PIL import Image, ImageDraw
+import io
+import random
+import math
+
+class EndpointHandler:
+    def __init__(self):
+        """Initialize the DiffSketcher handler with fallback PIL drawing"""
+        pass
+    
+    def __call__(self, data):
+        """
+        Generate a sketch-style image using PIL drawing (fallback method)
+        
+        Args:
+            data (dict): Input data containing:
+                - inputs (str): Text prompt
+                - parameters (dict): Generation parameters
+        
+        Returns:
+            PIL.Image.Image: Generated sketch image
+        """
+        try:
+            # Extract inputs
+            prompt = data.get("inputs", "")
+            parameters = data.get("parameters", {})
+            
+            # Extract parameters
+            width = parameters.get("width", 224)
+            height = parameters.get("height", 224)
+            guidance_scale = parameters.get("guidance_scale", 7.5)
+            seed = parameters.get("seed", 42)
+            
+            # Set random seed for reproducibility
+            random.seed(seed)
+            
+            # Create white background
+            image = Image.new('RGB', (width, height), 'white')
+            draw = ImageDraw.Draw(image)
+            
+            # Generate sketch based on prompt keywords
+            self._draw_sketch_from_prompt(draw, prompt, width, height)
+            
+            return image
+            
+        except Exception as e:
+            # Return error image
+            error_image = Image.new('RGB', (224, 224), 'white')
+            error_draw = ImageDraw.Draw(error_image)
+            error_draw.text((10, 100), f"Error: {str(e)[:30]}", fill='red')
+            return error_image
+    
+    def _draw_sketch_from_prompt(self, draw, prompt, width, height):
+        """Draw a simple sketch based on prompt keywords"""
+        prompt_lower = prompt.lower()
+        
+        # Define colors for sketching
+        colors = ['black', 'gray', 'darkgray']
+        
+        if any(word in prompt_lower for word in ['car', 'vehicle', 'automobile']):
+            self._draw_car(draw, width, height, colors)
+        elif any(word in prompt_lower for word in ['house', 'building', 'home']):
+            self._draw_house(draw, width, height, colors)
+        elif any(word in prompt_lower for word in ['flower', 'plant', 'bloom']):
+            self._draw_flower(draw, width, height, colors)
+        elif any(word in prompt_lower for word in ['tree', 'forest']):
+            self._draw_tree(draw, width, height, colors)
+        elif any(word in prompt_lower for word in ['mountain', 'landscape']):
+            self._draw_mountain(draw, width, height, colors)
+        else:
+            self._draw_abstract(draw, width, height, colors)
+    
+    def _draw_car(self, draw, width, height, colors):
+        """Draw a simple car sketch"""
+        cx, cy = width // 2, height // 2
+        
+        # Car body
+        draw.rectangle([cx-60, cy-20, cx+60, cy+20], outline=colors[0], width=2)
+        
+        # Car roof
+        draw.rectangle([cx-40, cy-40, cx+40, cy-20], outline=colors[0], width=2)
+        
+        # Wheels
+        draw.ellipse([cx-50, cy+10, cx-30, cy+30], outline=colors[0], width=2)
+        draw.ellipse([cx+30, cy+10, cx+50, cy+30], outline=colors[0], width=2)
+        
+        # Windows
+        draw.rectangle([cx-35, cy-35, cx+35, cy-25], outline=colors[1], width=1)
+    
+    def _draw_house(self, draw, width, height, colors):
+        """Draw a simple house sketch"""
+        cx, cy = width // 2, height // 2
+        
+        # House base
+        draw.rectangle([cx-50, cy-10, cx+50, cy+40], outline=colors[0], width=2)
+        
+        # Roof
+        draw.polygon([cx-60, cy-10, cx, cy-50, cx+60, cy-10], outline=colors[0], width=2)
+        
+        # Door
+        draw.rectangle([cx-15, cy+10, cx+15, cy+40], outline=colors[1], width=2)
+        
+        # Windows
+        draw.rectangle([cx-40, cy-5, cx-25, cy+10], outline=colors[1], width=1)
+        draw.rectangle([cx+25, cy-5, cx+40, cy+10], outline=colors[1], width=1)
+    
+    def _draw_flower(self, draw, width, height, colors):
+        """Draw a simple flower sketch"""
+        cx, cy = width // 2, height // 2
+        
+        # Stem
+        draw.line([cx, cy+20, cx, cy+60], fill=colors[0], width=3)
+        
+        # Petals
+        for i in range(6):
+            angle = i * 60 * math.pi / 180
+            x = cx + 25 * math.cos(angle)
+            y = cy + 25 * math.sin(angle)
+            draw.ellipse([x-8, y-8, x+8, y+8], outline=colors[0], width=2)
+        
+        # Center
+        draw.ellipse([cx-8, cy-8, cx+8, cy+8], fill=colors[1], outline=colors[0], width=2)
+        
+        # Leaves
+        draw.ellipse([cx-10, cy+30, cx+10, cy+50], outline=colors[0], width=2)
+    
+    def _draw_tree(self, draw, width, height, colors):
+        """Draw a simple tree sketch"""
+        cx, cy = width // 2, height // 2
+        
+        # Trunk
+        draw.rectangle([cx-8, cy+10, cx+8, cy+60], outline=colors[0], width=2)
+        
+        # Tree crown (circle)
+        draw.ellipse([cx-40, cy-40, cx+40, cy+20], outline=colors[0], width=2)
+        
+        # Branches
+        for i in range(5):
+            angle = (i * 72 - 90) * math.pi / 180
+            x = cx + 30 * math.cos(angle)
+            y = cy + 30 * math.sin(angle)
+            draw.line([cx, cy, x, y], fill=colors[1], width=1)
+    
+    def _draw_mountain(self, draw, width, height, colors):
+        """Draw a simple mountain landscape"""
+        cx, cy = width // 2, height // 2
+        
+        # Mountains
+        draw.polygon([20, cy+30, 80, cy-40, 140, cy+30], outline=colors[0], width=2)
+        draw.polygon([100, cy+30, 160, cy-20, 200, cy+30], outline=colors[0], width=2)
+        
+        # Ground line
+        draw.line([0, cy+30, width, cy+30], fill=colors[1], width=1)
+        
+        # Sun
+        draw.ellipse([width-60, 20, width-20, 60], outline=colors[1], width=2)
+    
+    def _draw_abstract(self, draw, width, height, colors):
+        """Draw abstract shapes for unknown prompts"""
+        cx, cy = width // 2, height // 2
+        
+        # Random geometric shapes
+        for i in range(5):
+            x = random.randint(20, width-20)
+            y = random.randint(20, height-20)
+            size = random.randint(10, 30)
+            
+            if i % 3 == 0:
+                draw.ellipse([x-size, y-size, x+size, y+size], outline=colors[i%len(colors)], width=2)
+            elif i % 3 == 1:
+                draw.rectangle([x-size, y-size, x+size, y+size], outline=colors[i%len(colors)], width=2)
+            else:
+                points = []
+                for j in range(3):
+                    px = x + size * math.cos(j * 120 * math.pi / 180)
+                    py = y + size * math.sin(j * 120 * math.pi / 180)
+                    points.extend([px, py])
+                draw.polygon(points, outline=colors[i%len(colors)], width=2)

requirements.txt

@@ -1,9 +1,23 @@
-torch>=2.0.0
-torchvision>=0.15.0
-transformers>=4.21.0
-svgwrite>=1.4.0
-Pillow>=8.3.0
+torch>=1.12.0
+torchvision>=0.13.0
 numpy>=1.21.0
-requests>=2.25.0
-accelerate>=0.12.0
-safetensors>=0.3.0
+Pillow>=8.0.0
+cairosvg>=2.5.0
+omegaconf>=2.1.0
+hydra-core>=1.1.0
+diffusers>=0.20.0
+transformers>=4.20.0
+accelerate>=0.20.0
+svgwrite>=1.4.0
+svgpathtools>=1.4.0
+freetype-py>=2.3.0
+shapely>=1.8.0
+opencv-python>=4.5.0
+scikit-image>=0.19.0
+matplotlib>=3.5.0
+scipy>=1.8.0
+einops>=0.4.0
+timm>=0.6.0
+ftfy>=6.1.0
+regex>=2022.0.0
+tqdm>=4.64.0