Update: Add versatile SVG generator implementation

handler.py

@@ -24,12 +24,12 @@ except ImportError:
     subprocess.check_call(["pip", "install", "git+https://github.com/openai/CLIP.git"])
     import clip
 
-# Import the simplified DiffSketcher
+# Import the versatile SVG generator
 try:
-    from simplified_diffsketcher import SimplifiedDiffSketcher
+    from versatile_svg_generator import VersatileSVGGenerator
 except ImportError:
-    print("Warning: simplified_diffsketcher not found. Using placeholder.")
-    SimplifiedDiffSketcher = None
+    print("Warning: versatile_svg_generator not found. Using placeholder.")
+    VersatileSVGGenerator = None
 
 class EndpointHandler:
     def __init__(self, model_dir):
@@ -38,14 +38,14 @@ class EndpointHandler:
         self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
         print(f"Initializing model on device: {self.device}")
         
-        # Initialize the simplified DiffSketcher if available
-        if SimplifiedDiffSketcher is not None:
+        # Initialize the versatile SVG generator if available
+        if VersatileSVGGenerator is not None:
             try:
-                self.model = SimplifiedDiffSketcher(model_dir)
+                self.model = VersatileSVGGenerator(model_dir)
                 self.use_model = True
-                print("Simplified DiffSketcher initialized successfully")
+                print("Versatile SVG generator initialized successfully")
             except Exception as e:
-                print(f"Error initializing simplified DiffSketcher: {e}")
+                print(f"Error initializing versatile SVG generator: {e}")
                 self.use_model = False
         else:
             self.use_model = False
@@ -76,11 +76,11 @@ class EndpointHandler:
             # Generate SVG using the model or placeholder
             if self.use_model:
                 try:
-                    # Use the simplified DiffSketcher
+                    # Use the versatile SVG generator
                     result = self.model(prompt)
                     image = result["image"]
                 except Exception as e:
-                    print(f"Error using simplified DiffSketcher: {e}")
+                    print(f"Error using versatile SVG generator: {e}")
                     # Fall back to placeholder
                     svg_content = self.generate_placeholder_svg(prompt)
                     png_data = cairosvg.svg2png(bytestring=svg_content.encode("utf-8"))

versatile_svg_generator.py

@@ -0,0 +1,1160 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+Versatile SVG Generator that creates different types of objects based on the prompt.
+"""
+
+import os
+import io
+import base64
+import torch
+import numpy as np
+from PIL import Image
+import cairosvg
+import random
+from pathlib import Path
+import re
+
+class VersatileSVGGenerator:
+    def __init__(self, model_dir):
+        """Initialize the versatile SVG generator"""
+        self.model_dir = model_dir
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        print(f"Initializing versatile SVG generator on device: {self.device}")
+        
+        # Load CLIP model if available
+        try:
+            import clip
+            self.clip_model, _ = clip.load("ViT-B-32", device=self.device)
+            self.clip_available = True
+            print("CLIP model loaded successfully")
+        except Exception as e:
+            print(f"Error loading CLIP model: {e}")
+            self.clip_available = False
+    
+    def generate_svg(self, prompt, num_paths=20, width=512, height=512):
+        """Generate an SVG from a text prompt"""
+        print(f"Generating SVG for prompt: {prompt}")
+        
+        # Use CLIP to encode the prompt if available
+        if self.clip_available:
+            try:
+                import clip
+                with torch.no_grad():
+                    text = clip.tokenize([prompt]).to(self.device)
+                    text_features = self.clip_model.encode_text(text)
+                    text_features = text_features.cpu().numpy()[0]
+                    # Normalize features
+                    text_features = text_features / np.linalg.norm(text_features)
+            except Exception as e:
+                print(f"Error encoding prompt with CLIP: {e}")
+                text_features = np.random.randn(512)  # Random features as fallback
+        else:
+            # Generate random features if CLIP is not available
+            text_features = np.random.randn(512)
+        
+        # Determine what type of object to generate based on the prompt
+        object_type = self._determine_object_type(prompt)
+        
+        # Generate SVG based on the object type
+        if object_type == "car":
+            svg_content = self._generate_car_svg(prompt, text_features, num_paths, width, height)
+        elif object_type == "landscape":
+            svg_content = self._generate_landscape_svg(prompt, text_features, num_paths, width, height)
+        elif object_type == "animal":
+            svg_content = self._generate_animal_svg(prompt, text_features, num_paths, width, height)
+        elif object_type == "building":
+            svg_content = self._generate_building_svg(prompt, text_features, num_paths, width, height)
+        elif object_type == "face":
+            svg_content = self._generate_face_svg(prompt, text_features, num_paths, width, height)
+        else:
+            svg_content = self._generate_abstract_svg(prompt, text_features, num_paths, width, height)
+        
+        return svg_content
+    
+    def _determine_object_type(self, prompt):
+        """Determine what type of object to generate based on the prompt"""
+        prompt = prompt.lower()
+        
+        # Check for car-related terms
+        car_terms = ["car", "vehicle", "truck", "suv", "sedan", "convertible", "sports car", "automobile"]
+        for term in car_terms:
+            if term in prompt:
+                return "car"
+        
+        # Check for landscape-related terms
+        landscape_terms = ["landscape", "mountain", "forest", "beach", "ocean", "sea", "lake", "river", "sunset", "sunrise", "sky"]
+        for term in landscape_terms:
+            if term in prompt:
+                return "landscape"
+        
+        # Check for animal-related terms
+        animal_terms = ["animal", "dog", "cat", "bird", "horse", "lion", "tiger", "elephant", "bear", "fish", "pet"]
+        for term in animal_terms:
+            if term in prompt:
+                return "animal"
+        
+        # Check for building-related terms
+        building_terms = ["building", "house", "skyscraper", "tower", "castle", "mansion", "apartment", "office", "structure"]
+        for term in building_terms:
+            if term in prompt:
+                return "building"
+        
+        # Check for face-related terms
+        face_terms = ["face", "portrait", "person", "man", "woman", "boy", "girl", "human", "head", "smile"]
+        for term in face_terms:
+            if term in prompt:
+                return "face"
+        
+        # Default to abstract
+        return "abstract"
+    
+    def _generate_car_svg(self, prompt, features, num_paths=20, width=512, height=512):
+        """Generate a car-like SVG based on the prompt and features"""
+        # Start SVG
+        svg_content = f"""<svg width="{width}" height="{height}" xmlns="http://www.w3.org/2000/svg">
+            <rect width="100%" height="100%" fill="#f8f8f8"/>
+        """
+        
+        # Use the features to determine car properties
+        car_color_hue = int((features[0] + 1) * 180) % 360  # Map to 0-360 hue
+        car_size = 0.6 + 0.2 * features[1]  # Size variation
+        car_style = int(abs(features[2] * 3)) % 3  # 0: sedan, 1: SUV, 2: sports car
+        
+        # Calculate car dimensions
+        car_width = int(width * 0.7 * car_size)
+        car_height = int(height * 0.3 * car_size)
+        car_x = (width - car_width) // 2
+        car_y = height // 2
+        
+        # Generate car body based on style
+        if car_style == 0:  # Sedan
+            # Car body (rounded rectangle)
+            svg_content += f"""<rect x="{car_x}" y="{car_y}" width="{car_width}" height="{car_height}" 
+                rx="20" ry="20" fill="hsl({car_color_hue}, 80%, 50%)" stroke="black" stroke-width="2" />"""
+            
+            # Windshield
+            windshield_width = car_width * 0.7
+            windshield_height = car_height * 0.5
+            windshield_x = car_x + (car_width - windshield_width) // 2
+            windshield_y = car_y - windshield_height * 0.3
+            svg_content += f"""<rect x="{windshield_x}" y="{windshield_y}" width="{windshield_width}" height="{windshield_height}" 
+                rx="10" ry="10" fill="#a8d8ff" stroke="black" stroke-width="1" />"""
+            
+            # Wheels
+            wheel_radius = car_height * 0.4
+            wheel_y = car_y + car_height * 0.8
+            svg_content += f"""<circle cx="{car_x + car_width * 0.2}" cy="{wheel_y}" r="{wheel_radius}" fill="black" />"""
+            svg_content += f"""<circle cx="{car_x + car_width * 0.8}" cy="{wheel_y}" r="{wheel_radius}" fill="black" />"""
+            svg_content += f"""<circle cx="{car_x + car_width * 0.2}" cy="{wheel_y}" r="{wheel_radius * 0.6}" fill="#444" />"""
+            svg_content += f"""<circle cx="{car_x + car_width * 0.8}" cy="{wheel_y}" r="{wheel_radius * 0.6}" fill="#444" />"""
+            
+        elif car_style == 1:  # SUV
+            # Car body (taller rectangle)
+            svg_content += f"""<rect x="{car_x}" y="{car_y - car_height * 0.3}" width="{car_width}" height="{car_height * 1.3}" 
+                rx="15" ry="15" fill="hsl({car_color_hue}, 80%, 50%)" stroke="black" stroke-width="2" />"""
+            
+            # Windshield
+            windshield_width = car_width * 0.6
+            windshield_height = car_height * 0.6
+            windshield_x = car_x + (car_width - windshield_width) // 2
+            windshield_y = car_y - car_height * 0.2
+            svg_content += f"""<rect x="{windshield_x}" y="{windshield_y}" width="{windshield_width}" height="{windshield_height}" 
+                rx="8" ry="8" fill="#a8d8ff" stroke="black" stroke-width="1" />"""
+            
+            # Wheels (larger)
+            wheel_radius = car_height * 0.45
+            wheel_y = car_y + car_height * 0.7
+            svg_content += f"""<circle cx="{car_x + car_width * 0.2}" cy="{wheel_y}" r="{wheel_radius}" fill="black" />"""
+            svg_content += f"""<circle cx="{car_x + car_width * 0.8}" cy="{wheel_y}" r="{wheel_radius}" fill="black" />"""
+            svg_content += f"""<circle cx="{car_x + car_width * 0.2}" cy="{wheel_y}" r="{wheel_radius * 0.6}" fill="#444" />"""
+            svg_content += f"""<circle cx="{car_x + car_width * 0.8}" cy="{wheel_y}" r="{wheel_radius * 0.6}" fill="#444" />"""
+            
+        else:  # Sports car
+            # Car body (low, sleek shape)
+            svg_content += f"""<path d="M {car_x} {car_y + car_height * 0.5} 
+                C {car_x + car_width * 0.1} {car_y - car_height * 0.2}, 
+                {car_x + car_width * 0.3} {car_y - car_height * 0.3}, 
+                {car_x + car_width * 0.5} {car_y - car_height * 0.2} 
+                S {car_x + car_width * 0.9} {car_y}, 
+                {car_x + car_width} {car_y + car_height * 0.3} 
+                L {car_x + car_width} {car_y + car_height * 0.7} 
+                C {car_x + car_width * 0.9} {car_y + car_height}, 
+                {car_x + car_width * 0.1} {car_y + car_height}, 
+                {car_x} {car_y + car_height * 0.7} Z" 
+                fill="hsl({car_color_hue}, 90%, 45%)" stroke="black" stroke-width="2" />"""
+            
+            # Windshield
+            windshield_width = car_width * 0.4
+            windshield_x = car_x + car_width * 0.3
+            windshield_y = car_y - car_height * 0.1
+            svg_content += f"""<path d="M {windshield_x} {windshield_y} 
+                C {windshield_x + windshield_width * 0.1} {windshield_y - car_height * 0.15}, 
+                {windshield_x + windshield_width * 0.9} {windshield_y - car_height * 0.15}, 
+                {windshield_x + windshield_width} {windshield_y} Z" 
+                fill="#a8d8ff" stroke="black" stroke-width="1" />"""
+            
+            # Wheels (low profile)
+            wheel_radius = car_height * 0.35
+            wheel_y = car_y + car_height * 0.7
+            svg_content += f"""<ellipse cx="{car_x + car_width * 0.2}" cy="{wheel_y}" rx="{wheel_radius * 1.2}" ry="{wheel_radius}" fill="black" />"""
+            svg_content += f"""<ellipse cx="{car_x + car_width * 0.8}" cy="{wheel_y}" rx="{wheel_radius * 1.2}" ry="{wheel_radius}" fill="black" />"""
+            svg_content += f"""<ellipse cx="{car_x + car_width * 0.2}" cy="{wheel_y}" rx="{wheel_radius * 0.7}" ry="{wheel_radius * 0.6}" fill="#444" />"""
+            svg_content += f"""<ellipse cx="{car_x + car_width * 0.8}" cy="{wheel_y}" rx="{wheel_radius * 0.7}" ry="{wheel_radius * 0.6}" fill="#444" />"""
+        
+        # Add headlights
+        headlight_radius = car_width * 0.05
+        headlight_y = car_y + car_height * 0.3
+        svg_content += f"""<circle cx="{car_x + car_width * 0.1}" cy="{headlight_y}" r="{headlight_radius}" fill="yellow" stroke="black" stroke-width="1" />"""
+        svg_content += f"""<circle cx="{car_x + car_width * 0.9}" cy="{headlight_y}" r="{headlight_radius}" fill="yellow" stroke="black" stroke-width="1" />"""
+        
+        # Add prompt as text
+        svg_content += f"""<text x="{width/2}" y="{height - 20}" font-family="Arial" font-size="12" text-anchor="middle">{prompt}</text>"""
+        
+        # Close SVG
+        svg_content += "</svg>"
+        
+        return svg_content
+    
+    def _generate_landscape_svg(self, prompt, features, num_paths=20, width=512, height=512):
+        """Generate a landscape SVG based on the prompt and features"""
+        # Start SVG
+        svg_content = f"""<svg width="{width}" height="{height}" xmlns="http://www.w3.org/2000/svg">
+            <defs>
+                <linearGradient id="skyGradient" x1="0%" y1="0%" x2="0%" y2="100%">
+                    <stop offset="0%" stop-color="#87CEEB" />
+                    <stop offset="100%" stop-color="#E0F7FF" />
+                </linearGradient>
+            </defs>
+            <rect width="100%" height="100%" fill="url(#skyGradient)"/>
+        """
+        
+        # Use features to determine landscape properties
+        mountain_count = int(abs(features[0] * 5)) + 3
+        tree_count = int(abs(features[1] * 20)) + 5
+        has_sun = features[2] > 0
+        has_water = features[3] > 0
+        
+        # Draw mountains
+        for i in range(mountain_count):
+            mountain_height = height * (0.3 + 0.2 * abs(features[i % len(features)]))
+            mountain_width = width * (0.2 + 0.1 * abs(features[(i+1) % len(features)]))
+            mountain_x = width * (i / mountain_count)
+            mountain_color = f"hsl({int(120 + features[i % len(features)] * 20)}, 30%, {30 + int(abs(features[i % len(features)] * 20))}%)"
+            
+            svg_content += f"""<path d="M {mountain_x} {height} 
+                L {mountain_x + mountain_width/2} {height - mountain_height} 
+                L {mountain_x + mountain_width} {height} Z" 
+                fill="{mountain_color}" stroke="none" />"""
+        
+        # Draw sun if present
+        if has_sun:
+            sun_x = width * (0.1 + 0.8 * abs(features[4]))
+            sun_y = height * 0.2
+            sun_radius = width * 0.08
+            svg_content += f"""<circle cx="{sun_x}" cy="{sun_y}" r="{sun_radius}" fill="yellow" stroke="none">
+                <animate attributeName="r" values="{sun_radius};{sun_radius*1.05};{sun_radius}" dur="4s" repeatCount="indefinite" />
+            </circle>"""
+        
+        # Draw water if present
+        if has_water:
+            water_height = height * 0.3
+            water_y = height - water_height
+            svg_content += f"""<rect x="0" y="{water_y}" width="{width}" height="{water_height}" fill="#4a86e8" opacity="0.7">
+                <animate attributeName="height" values="{water_height};{water_height*1.02};{water_height}" dur="3s" repeatCount="indefinite" />
+            </rect>"""
+            
+            # Add waves
+            for i in range(5):
+                wave_y = water_y + i * water_height / 5
+                svg_content += f"""<path d="M 0 {wave_y} 
+                    Q {width/4} {wave_y-5}, {width/2} {wave_y} 
+                    T {width} {wave_y}" 
+                    fill="none" stroke="white" stroke-width="1" opacity="0.3" />"""
+        
+        # Draw trees
+        for i in range(tree_count):
+            tree_x = width * (0.1 + 0.8 * (i / tree_count))
+            tree_y = height * 0.8
+            tree_height = height * (0.1 + 0.1 * abs(features[i % len(features)]))
+            tree_width = tree_height * 0.6
+            
+            # Tree trunk
+            svg_content += f"""<rect x="{tree_x - tree_width/8}" y="{tree_y - tree_height/3}" 
+                width="{tree_width/4}" height="{tree_height/3}" 
+                fill="#8B4513" stroke="none" />"""
+            
+            # Tree foliage
+            svg_content += f"""<path d="M {tree_x - tree_width/2} {tree_y - tree_height/3} 
+                L {tree_x} {tree_y - tree_height} 
+                L {tree_x + tree_width/2} {tree_y - tree_height/3} Z" 
+                fill="#228B22" stroke="none" />
+                
+                <path d="M {tree_x - tree_width/2} {tree_y - tree_height/2} 
+                L {tree_x} {tree_y - tree_height * 1.1} 
+                L {tree_x + tree_width/2} {tree_y - tree_height/2} Z" 
+                fill="#228B22" stroke="none" />"""
+        
+        # Add prompt as text
+        svg_content += f"""<text x="{width/2}" y="{height - 20}" font-family="Arial" font-size="12" text-anchor="middle" fill="black">{prompt}</text>"""
+        
+        # Close SVG
+        svg_content += "</svg>"
+        
+        return svg_content
+    
+    def _generate_animal_svg(self, prompt, features, num_paths=20, width=512, height=512):
+        """Generate an animal SVG based on the prompt and features"""
+        # Start SVG
+        svg_content = f"""<svg width="{width}" height="{height}" xmlns="http://www.w3.org/2000/svg">
+            <rect width="100%" height="100%" fill="#f8f8f8"/>
+        """
+        
+        # Determine animal type from prompt
+        animal_type = "generic"
+        if "dog" in prompt.lower() or "puppy" in prompt.lower():
+            animal_type = "dog"
+        elif "cat" in prompt.lower() or "kitten" in prompt.lower():
+            animal_type = "cat"
+        elif "bird" in prompt.lower():
+            animal_type = "bird"
+        elif "fish" in prompt.lower():
+            animal_type = "fish"
+        
+        # Use features to determine animal properties
+        animal_color_hue = int((features[0] + 1) * 180) % 360  # Map to 0-360 hue
+        animal_size = 0.5 + 0.3 * features[1]  # Size variation
+        
+        # Calculate animal dimensions
+        animal_width = int(width * 0.6 * animal_size)
+        animal_height = int(height * 0.4 * animal_size)
+        animal_x = (width - animal_width) // 2
+        animal_y = height // 2
+        
+        if animal_type == "dog":
+            # Dog body (oval)
+            svg_content += f"""<ellipse cx="{animal_x + animal_width * 0.5}" cy="{animal_y + animal_height * 0.5}" 
+                rx="{animal_width * 0.5}" ry="{animal_height * 0.3}" 
+                fill="hsl({animal_color_hue}, 70%, 60%)" stroke="black" stroke-width="2" />"""
+            
+            # Dog head (circle)
+            head_radius = animal_width * 0.2
+            svg_content += f"""<circle cx="{animal_x + animal_width * 0.8}" cy="{animal_y + animal_height * 0.3}" 
+                r="{head_radius}" fill="hsl({animal_color_hue}, 70%, 60%)" stroke="black" stroke-width="2" />"""
+            
+            # Dog ears
+            svg_content += f"""<ellipse cx="{animal_x + animal_width * 0.75}" cy="{animal_y + animal_height * 0.15}" 
+                rx="{head_radius * 0.5}" ry="{head_radius * 0.8}" 
+                fill="hsl({animal_color_hue}, 70%, 50%)" stroke="black" stroke-width="1" />"""
+            svg_content += f"""<ellipse cx="{animal_x + animal_width * 0.85}" cy="{animal_y + animal_height * 0.15}" 
+                rx="{head_radius * 0.5}" ry="{head_radius * 0.8}" 
+                fill="hsl({animal_color_hue}, 70%, 50%)" stroke="black" stroke-width="1" />"""
+            
+            # Dog eyes
+            svg_content += f"""<circle cx="{animal_x + animal_width * 0.75}" cy="{animal_y + animal_height * 0.25}" 
+                r="{head_radius * 0.15}" fill="black" />"""
+            svg_content += f"""<circle cx="{animal_x + animal_width * 0.85}" cy="{animal_y + animal_height * 0.25}" 
+                r="{head_radius * 0.15}" fill="black" />"""
+            
+            # Dog nose
+            svg_content += f"""<ellipse cx="{animal_x + animal_width * 0.9}" cy="{animal_y + animal_height * 0.35}" 
+                rx="{head_radius * 0.2}" ry="{head_radius * 0.15}" 
+                fill="black" />"""
+            
+            # Dog legs
+            leg_width = animal_width * 0.1
+            leg_height = animal_height * 0.4
+            svg_content += f"""<rect x="{animal_x + animal_width * 0.3}" y="{animal_y + animal_height * 0.6}" 
+                width="{leg_width}" height="{leg_height}" 
+                fill="hsl({animal_color_hue}, 70%, 55%)" stroke="black" stroke-width="1" />"""
+            svg_content += f"""<rect x="{animal_x + animal_width * 0.5}" y="{animal_y + animal_height * 0.6}" 
+                width="{leg_width}" height="{leg_height}" 
+                fill="hsl({animal_color_hue}, 70%, 55%)" stroke="black" stroke-width="1" />"""
+            
+            # Dog tail
+            svg_content += f"""<path d="M {animal_x + animal_width * 0.1} {animal_y + animal_height * 0.4} 
+                C {animal_x} {animal_y + animal_height * 0.2}, 
+                {animal_x - animal_width * 0.1} {animal_y + animal_height * 0.3}, 
+                {animal_x - animal_width * 0.05} {animal_y + animal_height * 0.5}" 
+                fill="none" stroke="hsl({animal_color_hue}, 70%, 55%)" stroke-width="{leg_width}" stroke-linecap="round" />"""
+            
+        elif animal_type == "cat":
+            # Cat body (oval)
+            svg_content += f"""<ellipse cx="{animal_x + animal_width * 0.5}" cy="{animal_y + animal_height * 0.5}" 
+                rx="{animal_width * 0.4}" ry="{animal_height * 0.25}" 
+                fill="hsl({animal_color_hue}, 70%, 60%)" stroke="black" stroke-width="2" />"""
+            
+            # Cat head (circle)
+            head_radius = animal_width * 0.18
+            svg_content += f"""<circle cx="{animal_x + animal_width * 0.8}" cy="{animal_y + animal_height * 0.3}" 
+                r="{head_radius}" fill="hsl({animal_color_hue}, 70%, 60%)" stroke="black" stroke-width="2" />"""
+            
+            # Cat ears (triangles)
+            svg_content += f"""<path d="M {animal_x + animal_width * 0.75} {animal_y + animal_height * 0.2} 
+                L {animal_x + animal_width * 0.7} {animal_y + animal_height * 0.05} 
+                L {animal_x + animal_width * 0.65} {animal_y + animal_height * 0.2} Z" 
+                fill="hsl({animal_color_hue}, 70%, 50%)" stroke="black" stroke-width="1" />"""
+            svg_content += f"""<path d="M {animal_x + animal_width * 0.85} {animal_y + animal_height * 0.2} 
+                L {animal_x + animal_width * 0.9} {animal_y + animal_height * 0.05} 
+                L {animal_x + animal_width * 0.95} {animal_y + animal_height * 0.2} Z" 
+                fill="hsl({animal_color_hue}, 70%, 50%)" stroke="black" stroke-width="1" />"""
+            
+            # Cat eyes (almond shaped)
+            svg_content += f"""<ellipse cx="{animal_x + animal_width * 0.75}" cy="{animal_y + animal_height * 0.25}" 
+                rx="{head_radius * 0.15}" ry="{head_radius * 0.08}" 
+                fill="black" />"""
+            svg_content += f"""<ellipse cx="{animal_x + animal_width * 0.85}" cy="{animal_y + animal_height * 0.25}" 
+                rx="{head_radius * 0.15}" ry="{head_radius * 0.08}" 
+                fill="black" />"""
+            
+            # Cat nose
+            svg_content += f"""<path d="M {animal_x + animal_width * 0.8} {animal_y + animal_height * 0.3} 
+                L {animal_x + animal_width * 0.78} {animal_y + animal_height * 0.33} 
+                L {animal_x + animal_width * 0.82} {animal_y + animal_height * 0.33} Z" 
+                fill="pink" stroke="black" stroke-width="0.5" />"""
+            
+            # Cat whiskers
+            svg_content += f"""<path d="M {animal_x + animal_width * 0.78} {animal_y + animal_height * 0.32} 
+                L {animal_x + animal_width * 0.65} {animal_y + animal_height * 0.3}" 
+                fill="none" stroke="black" stroke-width="0.5" />"""
+            svg_content += f"""<path d="M {animal_x + animal_width * 0.78} {animal_y + animal_height * 0.34} 
+                L {animal_x + animal_width * 0.65} {animal_y + animal_height * 0.35}" 
+                fill="none" stroke="black" stroke-width="0.5" />"""
+            svg_content += f"""<path d="M {animal_x + animal_width * 0.82} {animal_y + animal_height * 0.32} 
+                L {animal_x + animal_width * 0.95} {animal_y + animal_height * 0.3}" 
+                fill="none" stroke="black" stroke-width="0.5" />"""
+            svg_content += f"""<path d="M {animal_x + animal_width * 0.82} {animal_y + animal_height * 0.34} 
+                L {animal_x + animal_width * 0.95} {animal_y + animal_height * 0.35}" 
+                fill="none" stroke="black" stroke-width="0.5" />"""
+            
+            # Cat legs
+            leg_width = animal_width * 0.08
+            leg_height = animal_height * 0.3
+            svg_content += f"""<rect x="{animal_x + animal_width * 0.35}" y="{animal_y + animal_height * 0.6}" 
+                width="{leg_width}" height="{leg_height}" 
+                fill="hsl({animal_color_hue}, 70%, 55%)" stroke="black" stroke-width="1" />"""
+            svg_content += f"""<rect x="{animal_x + animal_width * 0.55}" y="{animal_y + animal_height * 0.6}" 
+                width="{leg_width}" height="{leg_height}" 
+                fill="hsl({animal_color_hue}, 70%, 55%)" stroke="black" stroke-width="1" />"""
+            
+            # Cat tail
+            svg_content += f"""<path d="M {animal_x + animal_width * 0.1} {animal_y + animal_height * 0.4} 
+                C {animal_x} {animal_y + animal_height * 0.2}, 
+                {animal_x - animal_width * 0.1} {animal_y + animal_height * 0.1}, 
+                {animal_x - animal_width * 0.15} {animal_y + animal_height * 0.3}" 
+                fill="none" stroke="hsl({animal_color_hue}, 70%, 55%)" stroke-width="{leg_width}" stroke-linecap="round" />"""
+            
+        elif animal_type == "bird":
+            # Bird body (oval)
+            svg_content += f"""<ellipse cx="{animal_x + animal_width * 0.5}" cy="{animal_y + animal_height * 0.5}" 
+                rx="{animal_width * 0.3}" ry="{animal_height * 0.25}" 
+                fill="hsl({animal_color_hue}, 90%, 60%)" stroke="black" stroke-width="2" />"""
+            
+            # Bird head
+            head_radius = animal_width * 0.15
+            svg_content += f"""<circle cx="{animal_x + animal_width * 0.8}" cy="{animal_y + animal_height * 0.4}" 
+                r="{head_radius}" fill="hsl({animal_color_hue}, 90%, 60%)" stroke="black" stroke-width="2" />"""
+            
+            # Bird beak
+            svg_content += f"""<path d="M {animal_x + animal_width * 0.9} {animal_y + animal_height * 0.4} 
+                L {animal_x + animal_width * 1.0} {animal_y + animal_height * 0.35} 
+                L {animal_x + animal_width * 0.9} {animal_y + animal_height * 0.45} Z" 
+                fill="orange" stroke="black" stroke-width="1" />"""
+            
+            # Bird eye
+            svg_content += f"""<circle cx="{animal_x + animal_width * 0.85}" cy="{animal_y + animal_height * 0.35}" 
+                r="{head_radius * 0.2}" fill="black" />"""
+            
+            # Bird wings
+            svg_content += f"""<path d="M {animal_x + animal_width * 0.5} {animal_y + animal_height * 0.4} 
+                C {animal_x + animal_width * 0.4} {animal_y + animal_height * 0.2}, 
+                {animal_x + animal_width * 0.3} {animal_y + animal_height * 0.1}, 
+                {animal_x + animal_width * 0.2} {animal_y + animal_height * 0.3}" 
+                fill="hsl({animal_color_hue}, 90%, 50%)" stroke="black" stroke-width="1" />"""
+            
+            # Bird tail
+            svg_content += f"""<path d="M {animal_x + animal_width * 0.2} {animal_y + animal_height * 0.5} 
+                L {animal_x} {animal_y + animal_height * 0.4} 
+                L {animal_x + animal_width * 0.1} {animal_y + animal_height * 0.5} 
+                L {animal_x} {animal_y + animal_height * 0.6} Z" 
+                fill="hsl({animal_color_hue}, 90%, 40%)" stroke="black" stroke-width="1" />"""
+            
+            # Bird legs
+            leg_width = animal_width * 0.02
+            leg_height = animal_height * 0.2
+            svg_content += f"""<rect x="{animal_x + animal_width * 0.45}" y="{animal_y + animal_height * 0.75}" 
+                width="{leg_width}" height="{leg_height}" 
+                fill="orange" stroke="black" stroke-width="1" />"""
+            svg_content += f"""<rect x="{animal_x + animal_width * 0.55}" y="{animal_y + animal_height * 0.75}" 
+                width="{leg_width}" height="{leg_height}" 
+                fill="orange" stroke="black" stroke-width="1" />"""
+            
+        elif animal_type == "fish":
+            # Fish body (oval)
+            svg_content += f"""<ellipse cx="{animal_x + animal_width * 0.5}" cy="{animal_y + animal_height * 0.5}" 
+                rx="{animal_width * 0.4}" ry="{animal_height * 0.25}" 
+                fill="hsl({animal_color_hue}, 90%, 60%)" stroke="black" stroke-width="2" />"""
+            
+            # Fish tail
+            svg_content += f"""<path d="M {animal_x + animal_width * 0.1} {animal_y + animal_height * 0.3} 
+                L {animal_x - animal_width * 0.1} {animal_y + animal_height * 0.5} 
+                L {animal_x + animal_width * 0.1} {animal_y + animal_height * 0.7} Z" 
+                fill="hsl({animal_color_hue}, 90%, 50%)" stroke="black" stroke-width="1" />"""
+            
+            # Fish eye
+            svg_content += f"""<circle cx="{animal_x + animal_width * 0.7}" cy="{animal_y + animal_height * 0.4}" 
+                r="{animal_width * 0.05}" fill="black" />"""
+            svg_content += f"""<circle cx="{animal_x + animal_width * 0.7}" cy="{animal_y + animal_height * 0.4}" 
+                r="{animal_width * 0.02}" fill="white" />"""
+            
+            # Fish fins
+            svg_content += f"""<path d="M {animal_x + animal_width * 0.5} {animal_y + animal_height * 0.25} 
+                C {animal_x + animal_width * 0.6} {animal_y}, 
+                {animal_x + animal_width * 0.7} {animal_y}, 
+                {animal_x + animal_width * 0.8} {animal_y + animal_height * 0.25}" 
+                fill="hsl({animal_color_hue}, 90%, 50%)" stroke="black" stroke-width="1" />"""
+            
+            svg_content += f"""<path d="M {animal_x + animal_width * 0.5} {animal_y + animal_height * 0.75} 
+                C {animal_x + animal_width * 0.6} {animal_y + animal_height}, 
+                {animal_x + animal_width * 0.7} {animal_y + animal_height}, 
+                {animal_x + animal_width * 0.8} {animal_y + animal_height * 0.75}" 
+                fill="hsl({animal_color_hue}, 90%, 50%)" stroke="black" stroke-width="1" />"""
+            
+            # Fish scales (simplified)
+            for i in range(5):
+                for j in range(3):
+                    scale_x = animal_x + animal_width * (0.3 + i * 0.1)
+                    scale_y = animal_y + animal_height * (0.4 + (j-1) * 0.1)
+                    scale_radius = animal_width * 0.03
+                    svg_content += f"""<circle cx="{scale_x}" cy="{scale_y}" r="{scale_radius}" 
+                        fill="none" stroke="hsl({animal_color_hue}, 90%, 40%)" stroke-width="0.5" />"""
+            
+            # Water bubbles
+            for i in range(3):
+                bubble_x = animal_x + animal_width * (0.8 + i * 0.1)
+                bubble_y = animal_y + animal_height * (0.3 - i * 0.1)
+                bubble_radius = animal_width * (0.02 + i * 0.01)
+                svg_content += f"""<circle cx="{bubble_x}" cy="{bubble_y}" r="{bubble_radius}" 
+                    fill="white" fill-opacity="0.7" stroke="lightblue" stroke-width="0.5" />"""
+            
+        else:  # Generic animal
+            # Body (oval)
+            svg_content += f"""<ellipse cx="{animal_x + animal_width * 0.5}" cy="{animal_y + animal_height * 0.5}" 
+                rx="{animal_width * 0.4}" ry="{animal_height * 0.25}" 
+                fill="hsl({animal_color_hue}, 70%, 60%)" stroke="black" stroke-width="2" />"""
+            
+            # Head (circle)
+            head_radius = animal_width * 0.2
+            svg_content += f"""<circle cx="{animal_x + animal_width * 0.8}" cy="{animal_y + animal_height * 0.4}" 
+                r="{head_radius}" fill="hsl({animal_color_hue}, 70%, 60%)" stroke="black" stroke-width="2" />"""
+            
+            # Eyes
+            svg_content += f"""<circle cx="{animal_x + animal_width * 0.75}" cy="{animal_y + animal_height * 0.35}" 
+                r="{head_radius * 0.15}" fill="black" />"""
+            svg_content += f"""<circle cx="{animal_x + animal_width * 0.85}" cy="{animal_y + animal_height * 0.35}" 
+                r="{head_radius * 0.15}" fill="black" />"""
+            
+            # Legs
+            leg_width = animal_width * 0.08
+            leg_height = animal_height * 0.3
+            svg_content += f"""<rect x="{animal_x + animal_width * 0.3}" y="{animal_y + animal_height * 0.6}" 
+                width="{leg_width}" height="{leg_height}" 
+                fill="hsl({animal_color_hue}, 70%, 55%)" stroke="black" stroke-width="1" />"""
+            svg_content += f"""<rect x="{animal_x + animal_width * 0.5}" y="{animal_y + animal_height * 0.6}" 
+                width="{leg_width}" height="{leg_height}" 
+                fill="hsl({animal_color_hue}, 70%, 55%)" stroke="black" stroke-width="1" />"""
+            
+            # Tail
+            svg_content += f"""<path d="M {animal_x + animal_width * 0.1} {animal_y + animal_height * 0.5} 
+                C {animal_x} {animal_y + animal_height * 0.4}, 
+                {animal_x - animal_width * 0.1} {animal_y + animal_height * 0.3}, 
+                {animal_x - animal_width * 0.05} {animal_y + animal_height * 0.6}" 
+                fill="none" stroke="hsl({animal_color_hue}, 70%, 55%)" stroke-width="{leg_width}" stroke-linecap="round" />"""
+        
+        # Add prompt as text
+        svg_content += f"""<text x="{width/2}" y="{height - 20}" font-family="Arial" font-size="12" text-anchor="middle">{prompt}</text>"""
+        
+        # Close SVG
+        svg_content += "</svg>"
+        
+        return svg_content
+    
+    def _generate_building_svg(self, prompt, features, num_paths=20, width=512, height=512):
+        """Generate a building SVG based on the prompt and features"""
+        # Start SVG
+        svg_content = f"""<svg width="{width}" height="{height}" xmlns="http://www.w3.org/2000/svg">
+            <defs>
+                <linearGradient id="skyGradient" x1="0%" y1="0%" x2="0%" y2="100%">
+                    <stop offset="0%" stop-color="#87CEEB" />
+                    <stop offset="100%" stop-color="#E0F7FF" />
+                </linearGradient>
+            </defs>
+            <rect width="100%" height="100%" fill="url(#skyGradient)"/>
+        """
+        
+        # Determine building type from prompt
+        building_type = "generic"
+        if "house" in prompt.lower():
+            building_type = "house"
+        elif "skyscraper" in prompt.lower() or "tower" in prompt.lower():
+            building_type = "skyscraper"
+        elif "castle" in prompt.lower():
+            building_type = "castle"
+        
+        # Use features to determine building properties
+        building_color_hue = int((features[0] + 1) * 180) % 360  # Map to 0-360 hue
+        building_size = 0.5 + 0.3 * features[1]  # Size variation
+        
+        # Calculate building dimensions
+        building_width = int(width * 0.6 * building_size)
+        building_height = int(height * 0.7 * building_size)
+        building_x = (width - building_width) // 2
+        building_y = height - building_height
+        
+        if building_type == "house":
+            # House base
+            svg_content += f"""<rect x="{building_x}" y="{building_y + building_height * 0.3}" 
+                width="{building_width}" height="{building_height * 0.7}" 
+                fill="hsl({building_color_hue}, 30%, 70%)" stroke="black" stroke-width="2" />"""
+            
+            # House roof
+            svg_content += f"""<path d="M {building_x - building_width * 0.1} {building_y + building_height * 0.3} 
+                L {building_x + building_width * 0.5} {building_y} 
+                L {building_x + building_width * 1.1} {building_y + building_height * 0.3} Z" 
+                fill="hsl({(building_color_hue + 30) % 360}, 50%, 40%)" stroke="black" stroke-width="2" />"""
+            
+            # House door
+            door_width = building_width * 0.2
+            door_height = building_height * 0.4
+            door_x = building_x + (building_width - door_width) / 2
+            door_y = building_y + building_height - door_height
+            svg_content += f"""<rect x="{door_x}" y="{door_y}" 
+                width="{door_width}" height="{door_height}" 
+                fill="hsl({(building_color_hue + 60) % 360}, 30%, 40%)" stroke="black" stroke-width="1" />"""
+            
+            # Door knob
+            svg_content += f"""<circle cx="{door_x + door_width * 0.8}" cy="{door_y + door_height * 0.5}" 
+                r="{door_width * 0.1}" fill="gold" stroke="black" stroke-width="0.5" />"""
+            
+            # Windows
+            window_width = building_width * 0.15
+            window_height = building_height * 0.15
+            window_spacing = building_width * 0.25
+            
+            for i in range(2):
+                for j in range(2):
+                    window_x = building_x + window_spacing + i * window_spacing
+                    window_y = building_y + building_height * 0.4 + j * window_spacing
+                    svg_content += f"""<rect x="{window_x}" y="{window_y}" 
+                        width="{window_width}" height="{window_height}" 
+                        fill="#a8d8ff" stroke="black" stroke-width="1" />"""
+                    
+                    # Window crossbars
+                    svg_content += f"""<path d="M {window_x} {window_y + window_height/2} 
+                        L {window_x + window_width} {window_y + window_height/2}" 
+                        fill="none" stroke="black" stroke-width="0.5" />"""
+                    svg_content += f"""<path d="M {window_x + window_width/2} {window_y} 
+                        L {window_x + window_width/2} {window_y + window_height}" 
+                        fill="none" stroke="black" stroke-width="0.5" />"""
+            
+            # Chimney
+            chimney_width = building_width * 0.1
+            chimney_height = building_height * 0.3
+            chimney_x = building_x + building_width * 0.7
+            chimney_y = building_y + building_height * 0.1 - chimney_height
+            svg_content += f"""<rect x="{chimney_x}" y="{chimney_y}" 
+                width="{chimney_width}" height="{chimney_height}" 
+                fill="hsl({(building_color_hue + 30) % 360}, 30%, 30%)" stroke="black" stroke-width="1" />"""
+            
+        elif building_type == "skyscraper":
+            # Skyscraper base
+            svg_content += f"""<rect x="{building_x}" y="{building_y}" 
+                width="{building_width}" height="{building_height}" 
+                fill="hsl({building_color_hue}, 20%, 70%)" stroke="black" stroke-width="2" />"""
+            
+            # Skyscraper top
+            top_width = building_width * 0.7
+            top_height = building_height * 0.1
+            top_x = building_x + (building_width - top_width) / 2
+            svg_content += f"""<rect x="{top_x}" y="{building_y - top_height}" 
+                width="{top_width}" height="{top_height}" 
+                fill="hsl({building_color_hue}, 20%, 50%)" stroke="black" stroke-width="1" />"""
+            
+            # Antenna
+            antenna_width = building_width * 0.02
+            antenna_height = building_height * 0.15
+            antenna_x = building_x + building_width / 2 - antenna_width / 2
+            antenna_y = building_y - top_height - antenna_height
+            svg_content += f"""<rect x="{antenna_x}" y="{antenna_y}" 
+                width="{antenna_width}" height="{antenna_height}" 
+                fill="silver" stroke="black" stroke-width="0.5" />"""
+            
+            # Windows (grid pattern)
+            window_width = building_width * 0.08
+            window_height = building_height * 0.05
+            window_spacing_x = building_width * 0.12
+            window_spacing_y = building_height * 0.08
+            
+            for i in range(int(building_width / window_spacing_x) - 1):
+                for j in range(int(building_height / window_spacing_y) - 1):
+                    window_x = building_x + window_spacing_x * (i + 0.5)
+                    window_y = building_y + window_spacing_y * (j + 0.5)
+                    
+                    # Randomize window lighting
+                    window_color = "#a8d8ff"
+                    if random.random() < 0.3:  # 30% chance of lit window
+                        window_color = "#ffff88"
+                    
+                    svg_content += f"""<rect x="{window_x}" y="{window_y}" 
+                        width="{window_width}" height="{window_height}" 
+                        fill="{window_color}" stroke="black" stroke-width="0.5" />"""
+            
+            # Entrance
+            entrance_width = building_width * 0.3
+            entrance_height = building_height * 0.1
+            entrance_x = building_x + (building_width - entrance_width) / 2
+            entrance_y = building_y + building_height - entrance_height
+            svg_content += f"""<rect x="{entrance_x}" y="{entrance_y}" 
+                width="{entrance_width}" height="{entrance_height}" 
+                fill="hsl({(building_color_hue + 60) % 360}, 30%, 40%)" stroke="black" stroke-width="1" />"""
+            
+        elif building_type == "castle":
+            # Castle base
+            svg_content += f"""<rect x="{building_x}" y="{building_y + building_height * 0.2}" 
+                width="{building_width}" height="{building_height * 0.8}" 
+                fill="hsl({building_color_hue}, 15%, 60%)" stroke="black" stroke-width="2" />"""
+            
+            # Castle towers
+            tower_width = building_width * 0.2
+            tower_height = building_height * 1.0
+            
+            # Left tower
+            svg_content += f"""<rect x="{building_x - tower_width * 0.5}" y="{building_y}" 
+                width="{tower_width}" height="{tower_height}" 
+                fill="hsl({building_color_hue}, 15%, 50%)" stroke="black" stroke-width="2" />"""
+            
+            # Right tower
+            svg_content += f"""<rect x="{building_x + building_width - tower_width * 0.5}" y="{building_y}" 
+                width="{tower_width}" height="{tower_height}" 
+                fill="hsl({building_color_hue}, 15%, 50%)" stroke="black" stroke-width="2" />"""
+            
+            # Crenellations (castle top)
+            crenel_width = building_width * 0.05
+            crenel_height = building_height * 0.05
+            crenel_count = int(building_width / crenel_width)
+            
+            for i in range(crenel_count):
+                if i % 2 == 0:
+                    crenel_x = building_x + i * crenel_width
+                    svg_content += f"""<rect x="{crenel_x}" y="{building_y + building_height * 0.15}" 
+                        width="{crenel_width}" height="{crenel_height}" 
+                        fill="hsl({building_color_hue}, 15%, 60%)" stroke="black" stroke-width="1" />"""
+            
+            # Tower crenellations
+            tower_crenel_count = int(tower_width / crenel_width)
+            
+            # Left tower crenellations
+            for i in range(tower_crenel_count):
+                if i % 2 == 0:
+                    crenel_x = building_x - tower_width * 0.5 + i * crenel_width
+                    svg_content += f"""<rect x="{crenel_x}" y="{building_y - crenel_height}" 
+                        width="{crenel_width}" height="{crenel_height}" 
+                        fill="hsl({building_color_hue}, 15%, 50%)" stroke="black" stroke-width="1" />"""
+            
+            # Right tower crenellations
+            for i in range(tower_crenel_count):
+                if i % 2 == 0:
+                    crenel_x = building_x + building_width - tower_width * 0.5 + i * crenel_width
+                    svg_content += f"""<rect x="{crenel_x}" y="{building_y - crenel_height}" 
+                        width="{crenel_width}" height="{crenel_height}" 
+                        fill="hsl({building_color_hue}, 15%, 50%)" stroke="black" stroke-width="1" />"""
+            
+            # Castle door (gate)
+            door_width = building_width * 0.25
+            door_height = building_height * 0.4
+            door_x = building_x + (building_width - door_width) / 2
+            door_y = building_y + building_height - door_height
+            
+            # Gate arch
+            svg_content += f"""<path d="M {door_x} {door_y + door_height * 0.5} 
+                A {door_width/2} {door_height/2} 0 0 1 {door_x + door_width} {door_y + door_height * 0.5} 
+                L {door_x + door_width} {door_y + door_height} 
+                L {door_x} {door_y + door_height} Z" 
+                fill="hsl({(building_color_hue + 30) % 360}, 30%, 30%)" stroke="black" stroke-width="1" />"""
+            
+            # Windows
+            window_width = building_width * 0.1
+            window_height = building_height * 0.15
+            window_spacing = building_width * 0.25
+            
+            for i in range(3):
+                window_x = building_x + window_spacing * (i + 0.5)
+                window_y = building_y + building_height * 0.4
+                
+                # Arched window
+                svg_content += f"""<path d="M {window_x} {window_y + window_height * 0.5} 
+                    A {window_width/2} {window_height/2} 0 0 1 {window_x + window_width} {window_y + window_height * 0.5} 
+                    L {window_x + window_width} {window_y + window_height} 
+                    L {window_x} {window_y + window_height} Z" 
+                    fill="#a8d8ff" stroke="black" stroke-width="1" />"""
+            
+            # Tower windows (slits)
+            slit_width = tower_width * 0.1
+            slit_height = tower_height * 0.1
+            
+            # Left tower slits
+            for i in range(3):
+                slit_x = building_x - tower_width * 0.5 + tower_width * 0.45
+                slit_y = building_y + tower_height * (0.2 + i * 0.2)
+                svg_content += f"""<rect x="{slit_x}" y="{slit_y}" 
+                    width="{slit_width}" height="{slit_height}" 
+                    fill="black" />"""
+            
+            # Right tower slits
+            for i in range(3):
+                slit_x = building_x + building_width - tower_width * 0.5 + tower_width * 0.45
+                slit_y = building_y + tower_height * (0.2 + i * 0.2)
+                svg_content += f"""<rect x="{slit_x}" y="{slit_y}" 
+                    width="{slit_width}" height="{slit_height}" 
+                    fill="black" />"""
+            
+        else:  # Generic building
+            # Building base
+            svg_content += f"""<rect x="{building_x}" y="{building_y}" 
+                width="{building_width}" height="{building_height}" 
+                fill="hsl({building_color_hue}, 30%, 70%)" stroke="black" stroke-width="2" />"""
+            
+            # Building roof
+            roof_height = building_height * 0.2
+            svg_content += f"""<path d="M {building_x - building_width * 0.05} {building_y} 
+                L {building_x + building_width * 0.5} {building_y - roof_height} 
+                L {building_x + building_width * 1.05} {building_y} Z" 
+                fill="hsl({(building_color_hue + 30) % 360}, 50%, 40%)" stroke="black" stroke-width="2" />"""
+            
+            # Building door
+            door_width = building_width * 0.2
+            door_height = building_height * 0.3
+            door_x = building_x + (building_width - door_width) / 2
+            door_y = building_y + building_height - door_height
+            svg_content += f"""<rect x="{door_x}" y="{door_y}" 
+                width="{door_width}" height="{door_height}" 
+                fill="hsl({(building_color_hue + 60) % 360}, 30%, 40%)" stroke="black" stroke-width="1" />"""
+            
+            # Windows
+            window_width = building_width * 0.15
+            window_height = building_height * 0.15
+            window_spacing_x = building_width * 0.25
+            window_spacing_y = building_height * 0.25
+            
+            for i in range(3):
+                for j in range(2):
+                    window_x = building_x + window_spacing_x * (i + 0.5)
+                    window_y = building_y + window_spacing_y * (j + 0.5)
+                    svg_content += f"""<rect x="{window_x}" y="{window_y}" 
+                        width="{window_width}" height="{window_height}" 
+                        fill="#a8d8ff" stroke="black" stroke-width="1" />"""
+        
+        # Add prompt as text
+        svg_content += f"""<text x="{width/2}" y="{height - 20}" font-family="Arial" font-size="12" text-anchor="middle">{prompt}</text>"""
+        
+        # Close SVG
+        svg_content += "</svg>"
+        
+        return svg_content
+    
+    def _generate_face_svg(self, prompt, features, num_paths=20, width=512, height=512):
+        """Generate a face SVG based on the prompt and features"""
+        # Start SVG
+        svg_content = f"""<svg width="{width}" height="{height}" xmlns="http://www.w3.org/2000/svg">
+            <rect width="100%" height="100%" fill="#f8f8f8"/>
+        """
+        
+        # Use features to determine face properties
+        face_color_hue = int((features[0] + 1) * 20) % 40 + 10  # Map to 10-50 hue (skin tones)
+        face_size = 0.5 + 0.2 * features[1]  # Size variation
+        face_shape = int(abs(features[2] * 3)) % 3  # 0: round, 1: oval, 2: square
+        
+        # Calculate face dimensions
+        face_width = int(width * 0.6 * face_size)
+        face_height = int(height * 0.7 * face_size)
+        face_x = (width - face_width) // 2
+        face_y = (height - face_height) // 2
+        
+        # Draw face shape
+        if face_shape == 0:  # Round
+            svg_content += f"""<circle cx="{width/2}" cy="{height/2}" r="{face_width/2}" 
+                fill="hsl({face_color_hue}, 50%, 80%)" stroke="black" stroke-width="2" />"""
+        elif face_shape == 1:  # Oval
+            svg_content += f"""<ellipse cx="{width/2}" cy="{height/2}" rx="{face_width/2}" ry="{face_height/2}" 
+                fill="hsl({face_color_hue}, 50%, 80%)" stroke="black" stroke-width="2" />"""
+        else:  # Square with rounded corners
+            svg_content += f"""<rect x="{face_x}" y="{face_y}" width="{face_width}" height="{face_height}" 
+                rx="{face_width/10}" ry="{face_height/10}" 
+                fill="hsl({face_color_hue}, 50%, 80%)" stroke="black" stroke-width="2" />"""
+        
+        # Determine gender from prompt
+        is_female = any(term in prompt.lower() for term in ["woman", "girl", "female", "lady"])
+        
+        # Draw eyes
+        eye_width = face_width * 0.15
+        eye_height = face_height * 0.08
+        eye_y = face_y + face_height * 0.35
+        left_eye_x = face_x + face_width * 0.3 - eye_width / 2
+        right_eye_x = face_x + face_width * 0.7 - eye_width / 2
+        
+        # Eye whites
+        svg_content += f"""<ellipse cx="{left_eye_x + eye_width/2}" cy="{eye_y + eye_height/2}" 
+            rx="{eye_width/2}" ry="{eye_height/2}" fill="white" stroke="black" stroke-width="1" />"""
+        svg_content += f"""<ellipse cx="{right_eye_x + eye_width/2}" cy="{eye_y + eye_height/2}" 
+            rx="{eye_width/2}" ry="{eye_height/2}" fill="white" stroke="black" stroke-width="1" />"""
+        
+        # Pupils
+        pupil_size = eye_width * 0.3
+        svg_content += f"""<circle cx="{left_eye_x + eye_width/2}" cy="{eye_y + eye_height/2}" 
+            r="{pupil_size}" fill="black" />"""
+        svg_content += f"""<circle cx="{right_eye_x + eye_width/2}" cy="{eye_y + eye_height/2}" 
+            r="{pupil_size}" fill="black" />"""
+        
+        # Eyebrows
+        brow_width = eye_width * 1.2
+        brow_height = eye_height * 0.5
+        brow_y = eye_y - eye_height * 0.8
+        
+        svg_content += f"""<path d="M {left_eye_x} {brow_y} 
+            Q {left_eye_x + brow_width/2} {brow_y - brow_height}, {left_eye_x + brow_width} {brow_y}" 
+            fill="none" stroke="black" stroke-width="2" />"""
+        svg_content += f"""<path d="M {right_eye_x} {brow_y} 
+            Q {right_eye_x + brow_width/2} {brow_y - brow_height}, {right_eye_x + brow_width} {brow_y}" 
+            fill="none" stroke="black" stroke-width="2" />"""
+        
+        # Nose
+        nose_width = face_width * 0.1
+        nose_height = face_height * 0.15
+        nose_x = face_x + face_width / 2 - nose_width / 2
+        nose_y = face_y + face_height * 0.5 - nose_height / 2
+        
+        svg_content += f"""<path d="M {nose_x + nose_width/2} {nose_y} 
+            L {nose_x} {nose_y + nose_height} 
+            L {nose_x + nose_width} {nose_y + nose_height}" 
+            fill="none" stroke="black" stroke-width="1" />"""
+        
+        # Mouth
+        mouth_width = face_width * 0.4
+        mouth_height = face_height * 0.05
+        mouth_x = face_x + face_width / 2 - mouth_width / 2
+        mouth_y = face_y + face_height * 0.7
+        
+        # Smiling mouth
+        svg_content += f"""<path d="M {mouth_x} {mouth_y} 
+            Q {mouth_x + mouth_width/2} {mouth_y + mouth_height}, {mouth_x + mouth_width} {mouth_y}" 
+            fill="none" stroke="black" stroke-width="1.5" />"""
+        
+        # Hair
+        hair_color_hue = int((features[3] + 1) * 180) % 360  # Map to 0-360 hue
+        
+        if is_female:
+            # Long hair for female
+            svg_content += f"""<path d="M {face_x + face_width * 0.1} {face_y + face_height * 0.2} 
+                C {face_x - face_width * 0.1} {face_y + face_height * 0.5}, 
+                {face_x - face_width * 0.2} {face_y + face_height}, 
+                {face_x + face_width * 0.1} {face_y + face_height * 1.1} 
+                L {face_x + face_width * 0.9} {face_y + face_height * 1.1} 
+                C {face_x + face_width * 1.2} {face_y + face_height}, 
+                {face_x + face_width * 1.1} {face_y + face_height * 0.5}, 
+                {face_x + face_width * 0.9} {face_y + face_height * 0.2} Z" 
+                fill="hsl({hair_color_hue}, 70%, 40%)" stroke="black" stroke-width="1" />"""
+            
+            # Hair on top of head
+            svg_content += f"""<path d="M {face_x + face_width * 0.1} {face_y + face_height * 0.2} 
+                C {face_x + face_width * 0.3} {face_y - face_height * 0.1}, 
+                {face_x + face_width * 0.7} {face_y - face_height * 0.1}, 
+                {face_x + face_width * 0.9} {face_y + face_height * 0.2} Z" 
+                fill="hsl({hair_color_hue}, 70%, 40%)" stroke="black" stroke-width="1" />"""
+        else:
+            # Short hair for male
+            svg_content += f"""<path d="M {face_x} {face_y + face_height * 0.3} 
+                C {face_x + face_width * 0.1} {face_y}, 
+                {face_x + face_width * 0.9} {face_y}, 
+                {face_x + face_width} {face_y + face_height * 0.3} Z" 
+                fill="hsl({hair_color_hue}, 70%, 40%)" stroke="black" stroke-width="1" />"""
+            
+            # Hair sides
+            svg_content += f"""<path d="M {face_x} {face_y + face_height * 0.3} 
+                L {face_x - face_width * 0.05} {face_y + face_height * 0.5} 
+                L {face_x} {face_y + face_height * 0.5} Z" 
+                fill="hsl({hair_color_hue}, 70%, 40%)" stroke="black" stroke-width="1" />"""
+            
+            svg_content += f"""<path d="M {face_x + face_width} {face_y + face_height * 0.3} 
+                L {face_x + face_width * 1.05} {face_y + face_height * 0.5} 
+                L {face_x + face_width} {face_y + face_height * 0.5} Z" 
+                fill="hsl({hair_color_hue}, 70%, 40%)" stroke="black" stroke-width="1" />"""
+        
+        # Add ears
+        ear_width = face_width * 0.1
+        ear_height = face_height * 0.2
+        left_ear_x = face_x - ear_width / 2
+        right_ear_x = face_x + face_width - ear_width / 2
+        ear_y = face_y + face_height * 0.4
+        
+        svg_content += f"""<ellipse cx="{left_ear_x}" cy="{ear_y}" 
+            rx="{ear_width/2}" ry="{ear_height/2}" 
+            fill="hsl({face_color_hue}, 50%, 75%)" stroke="black" stroke-width="1" />"""
+        
+        svg_content += f"""<ellipse cx="{right_ear_x}" cy="{ear_y}" 
+            rx="{ear_width/2}" ry="{ear_height/2}" 
+            fill="hsl({face_color_hue}, 50%, 75%)" stroke="black" stroke-width="1" />"""
+        
+        # Add prompt as text
+        svg_content += f"""<text x="{width/2}" y="{height - 20}" font-family="Arial" font-size="12" text-anchor="middle">{prompt}</text>"""
+        
+        # Close SVG
+        svg_content += "</svg>"
+        
+        return svg_content
+    
+    def _generate_abstract_svg(self, prompt, features, num_paths=20, width=512, height=512):
+        """Generate an abstract SVG based on the prompt and features"""
+        # Start SVG
+        svg_content = f"""<svg width="{width}" height="{height}" xmlns="http://www.w3.org/2000/svg">
+            <rect width="100%" height="100%" fill="#f8f8f8"/>
+        """
+        
+        # Use features to determine abstract properties
+        color_scheme = int(abs(features[0] * 5)) % 5  # 0-4 color schemes
+        shape_complexity = int(abs(features[1] * 10)) + 5  # 5-15 shapes
+        use_gradients = features[2] > 0
+        
+        # Define color schemes
+        color_schemes = [
+            # Warm colors
+            [f"hsl({h}, 80%, 60%)" for h in range(0, 61, 15)],
+            # Cool colors
+            [f"hsl({h}, 80%, 60%)" for h in range(180, 241, 15)],
+            # Complementary
+            [f"hsl({h}, 80%, 60%)" for h in range(0, 361, 180)],
+            # Monochromatic
+            [f"hsl(210, 80%, {l}%)" for l in range(30, 91, 15)],
+            # Rainbow
+            [f"hsl({h}, 80%, 60%)" for h in range(0, 361, 60)]
+        ]
+        
+        colors = color_schemes[color_scheme]
+        
+        # Add gradients if needed
+        if use_gradients:
+            svg_content += """<defs>"""
+            for i, color in enumerate(colors[:-1]):
+                svg_content += f"""
+                <linearGradient id="gradient{i}" x1="0%" y1="0%" x2="100%" y2="100%">
+                    <stop offset="0%" stop-color="{color}" />
+                    <stop offset="100%" stop-color="{colors[i+1]}" />
+                </linearGradient>"""
+            svg_content += """</defs>"""
+        
+        # Generate shapes based on prompt hash
+        prompt_hash = sum(ord(c) for c in prompt)
+        random.seed(prompt_hash)
+        
+        for i in range(shape_complexity):
+            shape_type = i % 4  # 0: circle, 1: rectangle, 2: polygon, 3: path
+            x = random.randint(0, width)
+            y = random.randint(0, height)
+            size = random.randint(20, 150)
+            color_idx = i % len(colors)
+            fill = f"url(#gradient{color_idx})" if use_gradients and color_idx < len(colors) - 1 else colors[color_idx]
+            opacity = 0.3 + random.random() * 0.7
+            
+            if shape_type == 0:  # Circle
+                svg_content += f"""<circle cx="{x}" cy="{y}" r="{size/2}" 
+                    fill="{fill}" stroke="none" opacity="{opacity}" />"""
+            elif shape_type == 1:  # Rectangle
+                svg_content += f"""<rect x="{x - size/2}" y="{y - size/2}" width="{size}" height="{size * 0.8}" 
+                    rx="{size/10}" ry="{size/10}" 
+                    fill="{fill}" stroke="none" opacity="{opacity}" 
+                    transform="rotate({random.randint(0, 90)}, {x}, {y})" />"""
+            elif shape_type == 2:  # Polygon
+                points = []
+                sides = random.randint(3, 8)
+                for j in range(sides):
+                    angle = j * 2 * 3.14159 / sides
+                    px = x + size/2 * np.cos(angle)
+                    py = y + size/2 * np.sin(angle)
+                    points.append(f"{px},{py}")
+                
+                svg_content += f"""<polygon points="{' '.join(points)}" 
+                    fill="{fill}" stroke="none" opacity="{opacity}" />"""
+            else:  # Path (curved)
+                path = f"M {x} {y} "
+                control_points = random.randint(2, 5)
+                for j in range(control_points):
+                    cx1 = x + random.randint(-size, size)
+                    cy1 = y + random.randint(-size, size)
+                    cx2 = x + random.randint(-size, size)
+                    cy2 = y + random.randint(-size, size)
+                    ex = x + random.randint(-size, size)
+                    ey = y + random.randint(-size, size)
+                    path += f"C {cx1} {cy1}, {cx2} {cy2}, {ex} {ey} "
+                
+                svg_content += f"""<path d="{path}" 
+                    fill="none" stroke="{colors[color_idx]}" stroke-width="{random.randint(1, 10)}" 
+                    opacity="{opacity}" stroke-linecap="round" />"""
+        
+        # Add text elements based on the prompt
+        words = re.findall(r'\b\w+\b', prompt)
+        for i, word in enumerate(words[:5]):  # Use up to 5 words from the prompt
+            text_x = random.randint(width // 4, width * 3 // 4)
+            text_y = random.randint(height // 4, height * 3 // 4)
+            text_size = random.randint(10, 40)
+            text_color = colors[i % len(colors)]
+            text_opacity = 0.7 + random.random() * 0.3
+            text_rotation = random.randint(-45, 45)
+            
+            svg_content += f"""<text x="{text_x}" y="{text_y}" 
+                font-family="Arial" font-size="{text_size}" text-anchor="middle" 
+                fill="{text_color}" opacity="{text_opacity}" 
+                transform="rotate({text_rotation}, {text_x}, {text_y})">{word}</text>"""
+        
+        # Add prompt as text
+        svg_content += f"""<text x="{width/2}" y="{height - 20}" font-family="Arial" font-size="12" text-anchor="middle">{prompt}</text>"""
+        
+        # Close SVG
+        svg_content += "</svg>"
+        
+        return svg_content
+    
+    def svg_to_png(self, svg_content):
+        """Convert SVG content to PNG"""
+        try:
+            png_data = cairosvg.svg2png(bytestring=svg_content.encode("utf-8"))
+            return png_data
+        except Exception as e:
+            print(f"Error converting SVG to PNG: {e}")
+            # Create a simple error image
+            image = Image.new("RGB", (512, 512), color="#ff0000")
+            from PIL import ImageDraw
+            draw = ImageDraw.Draw(image)
+            draw.text((256, 256), f"Error: {str(e)}", fill="white", anchor="mm")
+            
+            # Convert PIL Image to PNG data
+            buffer = io.BytesIO()
+            image.save(buffer, format="PNG")
+            return buffer.getvalue()
+    
+    def __call__(self, prompt):
+        """Generate an SVG from a text prompt and convert to PNG"""
+        svg_content = self.generate_svg(prompt)
+        png_data = self.svg_to_png(svg_content)
+        
+        # Create a PIL Image from the PNG data
+        image = Image.open(io.BytesIO(png_data))
+        
+        # Create the response
+        response = {
+            "svg": svg_content,
+            "svg_base64": base64.b64encode(svg_content.encode("utf-8")).decode("utf-8"),
+            "png_base64": base64.b64encode(png_data).decode("utf-8"),
+            "image": image
+        }
+        
+        return response