GPT 图像生成

import openai

# 配置 YeLIn AI 的接入点和密钥
openai.api_base = "https://api.yelinai.com/v1"
openai.api_key = "your-api-key"

# 生成图像
response = openai.Image.create(
    model="gpt-image-1",
    prompt="A serene landscape with mountains and a lake at sunset",
    n=1,
    size="1024x1024"
)

# 获取生成的图像 URL
image_url = response['data'][0]['url']
print(f"Generated image URL: {image_url}")

{
  "created": 1702486395,
  "data": [
    {
      "url": "https://..."
    }
  ]
}

import openai
import requests
from PIL import Image
from io import BytesIO

# 配置
openai.api_base = "https://api.yelinai.com/v1"
openai.api_key = "your-api-key"

# 生成图像（使用新参数）
def generate_image(prompt, size="auto", quality="auto", output_format="png", n=1):
    try:
        response = openai.Image.create(
            model="gpt-image-1",
            prompt=prompt,
            n=n,
            size=size,
            quality=quality,
            output_format=output_format
        )
        
        # 返回图像 URLs
        return [item['url'] for item in response['data']]
    
    except Exception as e:
        print(f"Error generating image: {e}")
        return None

# 高级示例：使用压缩和背景设置
def generate_advanced_image(prompt, compression=None):
    params = {
        "model": "gpt-image-1",
        "prompt": prompt,
        "size": "1536x1024",  # 横向图片
        "quality": "high",
        "output_format": "jpeg" if compression else "png",
        "background": "transparent"
    }
    
    # 如果需要压缩，添加压缩参数
    if compression:
        params["output_compression"] = compression
    
    try:
        response = openai.Image.create(**params)
        return response['data'][0]['url']
    except Exception as e:
        print(f"Error: {e}")
        return None

# 下载并保存图像
def save_image(url, filename):
    response = requests.get(url)
    img = Image.open(BytesIO(response.content))
    img.save(filename)
    print(f"Image saved as {filename}")

# 使用示例
prompts = [
    "A futuristic city with flying cars and neon lights",
    "A cozy coffee shop in autumn with warm lighting",
    "An abstract art piece with vibrant colors and geometric shapes"
]

for i, prompt in enumerate(prompts):
    print(f"Generating: {prompt}")
    urls = generate_image(prompt)
    if urls:
        save_image(urls[0], f"image_{i+1}.png")

const OpenAI = require('openai');
const fs = require('fs');
const https = require('https');

// 初始化客户端
const openai = new OpenAI({
  apiKey: 'your-api-key',
  baseURL: 'https://api.yelinai.com/v1'
});

// 生成图像（使用新参数）
async function generateImage(prompt, options = {}) {
  try {
    const response = await openai.images.generate({
      model: "gpt-image-1",
      prompt: prompt,
      n: options.n || 1,
      size: options.size || "auto",
      quality: options.quality || "auto",
      output_format: options.format || "png",
      background: options.background || "auto",
      ...options.compression && { output_compression: options.compression }
    });
    
    return response.data[0].url;
  } catch (error) {
    console.error('Error generating image:', error);
    return null;
  }
}

// 高级示例：生成高质量横向图片
async function generateLandscapeImage(prompt) {
  const options = {
    size: "1536x1024",
    quality: "high",
    format: "jpeg",
    compression: 85  // 85% 质量
  };
  
  return await generateImage(prompt, options);
}

// 下载图像
function downloadImage(url, filepath) {
  return new Promise((resolve, reject) => {
    const file = fs.createWriteStream(filepath);
    https.get(url, (response) => {
      response.pipe(file);
      file.on('finish', () => {
        file.close();
        console.log(`Image saved to \`$\{filepath}`);
        resolve();
      });
    }).on('error', reject);
  });
}

// 使用示例
async function main() {
  const prompt = "A beautiful Japanese garden with cherry blossoms";
  const imageUrl = await generateImage(prompt);
  
  if (imageUrl) {
    await downloadImage(imageUrl, 'japanese_garden.png');
  }
}

main();

curl https://api.yelinai.com/v1/images/generations \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{
    "model": "gpt-image-1",
    "prompt": "A white siamese cat sitting on a windowsill",
    "n": 1,
    "size": "1024x1024"
  }'

# 基础提示词
prompt_basic = "a cat"

# 优化后的提示词
prompt_detailed = "a fluffy white Persian cat sitting on a vintage velvet cushion, soft natural lighting, professional photography, shallow depth of field"

styles = [
    "in the style of Studio Ghibli anime",
    "photorealistic, professional photography",
    "digital art, concept art style",
    "oil painting, impressionist style",
    "minimalist, flat design illustration"
]

compositions = [
    "close-up portrait, centered composition",
    "wide angle landscape shot, rule of thirds",
    "aerial view, bird's eye perspective",
    "low angle shot, dramatic perspective"
]

import asyncio
import aiohttp
import openai

async def generate_batch_images(prompts, size="1024x1024"):
    """批量生成图像"""
    tasks = []
    
    async with aiohttp.ClientSession() as session:
        for prompt in prompts:
            task = generate_single_image(session, prompt, size)
            tasks.append(task)
        
        results = await asyncio.gather(*tasks)
    
    return results

async def generate_single_image(session, prompt, size):
    """异步生成单张图像"""
    headers = {
        "Authorization": f"Bearer {openai.api_key}",
        "Content-Type": "application/json"
    }
    
    data = {
        "model": "gpt-image-1",
        "prompt": prompt,
        "n": 1,
        "size": size
    }
    
    async with session.post(
        f"{openai.api_base}/images/generations",
        headers=headers,
        json=data
    ) as response:
        result = await response.json()
        return {
            "prompt": prompt,
            "url": result['data'][0]['url']
        }

# 使用示例
prompts = [
    "A majestic eagle soaring over mountains",
    "A underwater coral reef teeming with colorful fish",
    "A cozy cabin in a snowy forest at night",
    "A bustling Tokyo street with neon signs"
]

# 运行批量生成
results = asyncio.run(generate_batch_images(prompts))
for result in results:
    print(f"Prompt: {result['prompt']}")
    print(f"URL: {result['url']}\n")

import time
from openai import OpenAI

client = OpenAI(
    api_key="your-api-key",
    base_url="https://api.yelinai.com/v1"
)

def generate_with_retry(prompt, max_retries=3):
    """带重试机制的图像生成"""
    for attempt in range(max_retries):
        try:
            response = client.images.generate(
                model="gpt-image-1",
                prompt=prompt,
                n=1,
                size="1024x1024"
            )
            return response.data[0].url
        
        except Exception as e:
            if attempt < max_retries - 1:
                wait_time = 2 ** attempt  # 指数退避
                print(f"Error: {e}. Retrying in {wait_time} seconds...")
                time.sleep(wait_time)
            else:
                print(f"Failed after {max_retries} attempts: {e}")
                return None