DALL-E 3 Image Generation Tutorial

import openai

client = openai.OpenAI(
    api_key="your-api-key",
    base_url="https://api.n1n.ai/v1"
)

# Basic image generation
response = client.images.generate(
    model="dall-e-3",
    prompt="A cute cartoon cat sitting on the moon, surrounded by stars, cyberpunk style",
    size="1024x1024",  # 1024x1024, 1024x1792, 1792x1024
    quality="hd",  # standard or hd
    n=1  # DALL-E 3 only supports n=1
)

image_url = response.data[0].url
print(f"Generated image URL: {image_url}")

# Advanced parameter control
response = client.images.generate(
    model="dall-e-3",
    prompt="Professional commercial photography: A delicate latte coffee, wooden desktop, soft morning light, depth of field effect",
    size="1792x1024",  # Horizontal high resolution
    quality="hd",
    style="natural",  # natural or vivid
    response_format="b64_json"  # Return base64 encoding
)

# Save base64 image
import base64
from PIL import Image
from io import BytesIO

if response_format == "b64_json":
    image_data = base64.b64decode(response.data[0].b64_json)
    image = Image.open(BytesIO(image_data))
    image.save("generated_image.png")

# DALL-E 3 Prompt Engineering
class DallE3PromptBuilder:
    """Build high-quality DALL-E 3 prompts"""
    
    def __init__(self):
        self.prompt_parts = []
    
    def add_subject(self, subject: str):
        """Add subject"""
        self.prompt_parts.append(f"Subject: {subject}")
        return self
    
    def add_style(self, style: str):
        """Add artistic style"""
        styles_map = {
            "realistic": "photorealistic, high detail, professional photography",
            "anime": "anime style, manga aesthetic, cel shading",
            "oil_painting": "oil painting, impressionist, thick brushstrokes",
            "watercolor": "watercolor painting, soft edges, flowing colors",
            "3d_render": "3D rendered, octane render, ray tracing",
            "pixel_art": "pixel art, 8-bit style, retro gaming aesthetic"
        }
        self.prompt_parts.append(styles_map.get(style, style))
        return self
    
    def add_lighting(self, lighting: str):
        """Add lighting effects"""
        self.prompt_parts.append(f"Lighting: {lighting}")
        return self
    
    def add_composition(self, composition: str):
        """Add composition"""
        self.prompt_parts.append(f"Composition: {composition}")
        return self
    
    def add_quality_tags(self):
        """Add quality tags"""
        quality_tags = [
            "masterpiece",
            "best quality",
            "highly detailed",
            "sharp focus",
            "professional"
        ]
        self.prompt_parts.extend(quality_tags)
        return self
    
    def build(self) -> str:
        """Build final prompt"""
        return ", ".join(self.prompt_parts)

# usingExample
prompt_builder = DallE3PromptBuilder()
prompt = (prompt_builder
    .add_subject("a majestic dragon perched on a mountain peak")
    .add_style("3d_render")
    .add_lighting("dramatic sunset lighting, golden hour")
    .add_composition("rule of thirds, dynamic angle")
    .add_quality_tags()
    .build())

print(f"Optimized prompt: {prompt}")

# Batch generate different styles
def generate_style_variations(base_prompt: str):
    styles = ["natural", "vivid"]
    sizes = ["1024x1024", "1024x1792", "1792x1024"]
    results = []
    
    for style in styles:
        for size in sizes:
            response = client.images.generate(
                model="dall-e-3",
                prompt=base_prompt,
                size=size,
                style=style,
                quality="hd"
            )
            results.append({
                "style": style,
                "size": size,
                "url": response.data[0].url
            })
    
    return results

# Advanced use cases
class DallE3Applications:
    def __init__(self, api_key: str):
        self.client = openai.OpenAI(api_key=api_key)
    
    def generate_product_mockup(self, product: str, context: str):
        """Product rendering generation"""
        prompt = f"""
        Professional product photography of {product}.
        Context: {context}
        Style: Clean, minimalist, high-end commercial photography
        Lighting: Soft studio lighting with subtle shadows
        Background: Simple gradient or solid color
        Focus: Sharp focus on product with slight depth of field
        """
        
        response = self.client.images.generate(
            model="dall-e-3",
            prompt=prompt,
            size="1792x1024",
            quality="hd",
            style="natural"
        )
        
        return response.data[0].url
    
    def create_storyboard(self, scenes: list):
        """Create storyboard"""
        storyboard = []
        
        for i, scene in enumerate(scenes):
            prompt = f"""
            Storyboard frame {i+1}:
            {scene['description']}
            Style: Professional storyboard illustration, pencil sketch style
            Composition: {scene.get('shot_type', 'medium shot')}
            Characters: {scene.get('characters', 'N/A')}
            """
            
            response = self.client.images.generate(
                model="dall-e-3",
                prompt=prompt,
                size="1024x1024",
                quality="standard"
            )
            
            storyboard.append({
                "scene": i+1,
                "image_url": response.data[0].url,
                "description": scene['description']
            })
        
        return storyboard
    
    def generate_logo_concept(self, brand_name: str, industry: str, values: list):
        """Logo concept design"""
        prompt = f"""
        Modern logo design for '{brand_name}'
        Industry: {industry}
        Brand values: {', '.join(values)}
        Style: Minimalist, scalable, memorable
        Design: Vector-style, clean lines, professional
        Color scheme: Suitable for both light and dark backgrounds
        """
        
        response = self.client.images.generate(
            model="dall-e-3",
            prompt=prompt,
            size="1024x1024",
            quality="hd",
            style="vivid"
        )
        
        return response.data[0].url

# Use case examples
app = DallE3Applications(api_key="your-key")

# 1. E-commerce product images
product_image = app.generate_product_mockup(
    product="wireless headphones",
    context="premium audio equipment for professionals"
)

# 2. Storyboard creation
scenes = [
    {"description": "Hero enters ancient temple", "shot_type": "wide shot"},
    {"description": "Close-up of mysterious artifact glowing", "shot_type": "close-up"},
    {"description": "Hero running from collapsing temple", "shot_type": "action shot"}
]
storyboard = app.create_storyboard(scenes)

# 3. LogoDesign
logo = app.generate_logo_concept(
    brand_name="TechNova",
    industry="AI Technology",
    values=["innovation", "simplicity", "future"]
)