【2025最新】ChatGPT 4o图像API全指南：7大核心功能与省钱攻略

# 电商产品图生成示例
import openai
import json
from PIL import Image, ImageDraw, ImageFont
import requests
from io import BytesIO

# 使用laozhang.ai中转API
client = openai.OpenAI(
    base_url="https://api.laozhang.ai/v1",
    api_key="your-laozhang-api-key"
)

def generate_product_image(product_info, scene_type="standard"):
    """根据产品信息生成产品图"""
    # 构建产品描述提示词
    scenes = {
        "standard": "简洁的纯白背景产品展示",
        "lifestyle": "真实的生活场景中使用此产品",
        "seasonal": f"在{product_info.get('season', '夏季')}季节背景下的产品展示"
    }
    
    prompt = f"高品质电商产品图：{product_info['name']}。{product_info['description']}。"
    prompt += f"产品颜色：{product_info['color']}，材质：{product_info['material']}。"
    prompt += f"场景：{scenes[scene_type]}。风格：干净专业的电商展示图，光线明亮，细节清晰。"
    
    response = client.images.generate(
        model="gpt-4o-image",
        prompt=prompt,
        n=1,
        size="1024x1024",
        quality="hd",
        style="natural"
    )
    
    image_url = response.data[0].url
    
    # 下载图像并添加品牌水印
    img_response = requests.get(image_url)
    img = Image.open(BytesIO(img_response.content))
    
    # 添加水印
    draw = ImageDraw.Draw(img)
    font = ImageFont.truetype("arial.ttf", 30)
    draw.text((30, img.height - 50), f"{product_info['brand']} - {product_info['sku']}", 
              fill=(255, 255, 255, 128), font=font)
    
    # 保存图像
    output_path = f"products/{product_info['sku']}_{scene_type}.jpg"
    img.save(output_path)
    return output_path

# 使用示例
product = {
    "name": "超轻便折叠雨伞",
    "description": "一款便携式全自动折叠雨伞，采用纳米疏水材料，伞面黑色，伞骨由碳纤维制成",
    "color": "黑色",
    "material": "纳米疏水面料和碳纤维伞骨",
    "brand": "雨之轻",
    "sku": "UMB-2025-BLK",
    "season": "雨季"
}

standard_image = generate_product_image(product, "standard")
lifestyle_image = generate_product_image(product, "lifestyle")
print(f"标准产品图：{standard_image}")
print(f"场景产品图：{lifestyle_image}")
            

// 内容创作助手示例
const OpenAI = require('openai');
const natural = require('natural');
const tokenizer = new natural.WordTokenizer();
const fs = require('fs');

// 使用laozhang.ai中转API
const client = new OpenAI({
  baseURL: 'https://api.laozhang.ai/v1',
  apiKey: 'your-laozhang-api-key',
});

// 提取文本关键概念
async function extractConcepts(text) {
  try {
    const response = await client.chat.completions.create({
      model: "gpt-4o",
      messages: [
        {
          role: "system", 
          content: "你是一个专业的内容分析专家。请从文本中提取5个关键概念，用简短词汇表示。"
        },
        {
          role: "user",
          content: `分析这段文字，提取关键视觉概念：${text}`
        }
      ],
      temperature: 0.3,
    });
    
    const conceptsText = response.choices[0].message.content;
    // 解析返回的概念列表
    const conceptsArray = conceptsText.split('\n')
      .filter(line => line.trim().length > 0)
      .map(line => line.replace(/^\d+\.\s*/, '').trim());
    
    return conceptsArray;
  } catch (error) {
    console.error('提取概念错误:', error);
    return [];
  }
}

// 生成文章配图
async function generateArticleImage(text, style = "editorial") {
  try {
    // 提取关键概念
    const concepts = await extractConcepts(text);
    console.log('提取的关键概念:', concepts);
    
    // 构建图像生成提示词
    const styles = {
      "editorial": "专业杂志风格的插图，清晰明亮，适合博客文章",
      "infographic": "信息图表风格，包含图标和视觉数据表示",
      "sketch": "手绘草图风格，线条清晰，适合教程和指南"
    };
    
    const prompt = `创建一张${styles[style]}图像，展示以下概念：${concepts.join('、')}。
整体内容应与以下文章段落主题相符：${text.substring(0, 300)}...`;
    
    // 调用图像生成API
    const response = await client.images.generate({
      model: "gpt-4o-image",
      prompt: prompt,
      n: 1,
      size: "1024x1024",
      quality: "standard",
      style: "natural"
    });
    
    return {
      image_url: response.data[0].url,
      concepts: concepts,
      prompt: prompt
    };
  } catch (error) {
    console.error('图像生成错误:', error);
    return null;
  }
}

// 使用示例
const articleSection = `
人工智能在医疗诊断领域的应用正在迅速发展。
机器学习算法现在可以分析医学影像，如X光片、CT扫描和MRI图像，
以帮助医生更准确地诊断疾病。这些AI系统通过学习数百万张医学图像，
能够识别人眼可能错过的细微模式。据研究显示，在某些情况下，
AI辅助诊断的准确率已达到95%以上，甚至超过了部分专家医生。
然而，这并不意味着AI将取代医生，而是作为强大的辅助工具，
帮助医疗专业人员做出更准确、更快速的诊断决策。
`;

(async () => {
  const result = await generateArticleImage(articleSection, "editorial");
  console.log('生成结果:', result);
  
  // 保存结果记录
  fs.writeFileSync(
    `article_image_${Date.now()}.json`, 
    JSON.stringify(result, null, 2)
  );
})();
            

# 科学概念可视化工具
import openai
import gradio as gr

# 使用laozhang.ai中转API
client = openai.OpenAI(
    base_url="https://api.laozhang.ai/v1",
    api_key="your-laozhang-api-key"
)

def generate_concept_visualization(concept, grade_level, style):
    """生成科学概念的可视化图像"""
    # 根据年级调整复杂度
    complexity_map = {
        "小学": "简单易懂，使用基础比喻和明亮色彩",
        "初中": "适度复杂，包含基本科学细节，使用简化示意图",
        "高中": "包含详细科学元素，准确的结构和过程表示",
        "大学": "专业级别的细节，包含精确的科学表示和专业术语标注"
    }
    
    # 图像风格
    style_map = {
        "卡通": "卡通风格，可爱友好的角色和元素",
        "写实": "写实风格，准确的比例和细节",
        "信息图": "信息图表风格，包含图标、箭头和简洁文字说明",
        "手绘": "手绘风格，看起来像彩色粉笔或马克笔绘制"
    }
    
    prompt = f"""
    创建一张解释'{concept}'科学概念的教育图像。
    目标学生：{grade_level}学生
    图像特点：{complexity_map[grade_level]}
    视觉风格：{style_map[style]}
    图像应包含：
    1. 清晰的概念核心展示
    2. 关键组成部分或步骤的标注
    3. 至少一个日常生活中的应用或例子
    4. 简洁的中文标签标注重要元素
    整体设计应教育性强且视觉吸引力高，适合{grade_level}学生理解。
    """
    
    try:
        response = client.images.generate(
            model="gpt-4o-image",
            prompt=prompt,
            n=1,
            size="1024x1024",
            quality="standard",
            style="natural"
        )
        
        return response.data[0].url, prompt
    except Exception as e:
        return str(e), prompt

# 创建Gradio界面
def create_gradio_interface():
    with gr.Blocks(title="科学概念可视化工具") as app:
        gr.Markdown("# 科学概念可视化生成器")
        gr.Markdown("输入科学概念，选择目标学生年级和视觉风格，生成教育图像")
        
        with gr.Row():
            with gr.Column(scale=1):
                concept = gr.Textbox(label="科学概念", placeholder="输入科学概念，如：光合作用、电磁感应、DNA复制...")
                grade = gr.Dropdown(choices=["小学", "初中", "高中", "大学"], label="目标学生年级")
                style = gr.Dropdown(choices=["卡通", "写实", "信息图", "手绘"], label="视觉风格")
                submit_btn = gr.Button("生成可视化图像")
            
            with gr.Column(scale=1):
                output_image = gr.Image(label="生成的图像")
                output_prompt = gr.Textbox(label="使用的提示词", lines=6)
        
        submit_btn.click(
            fn=generate_concept_visualization,
            inputs=[concept, grade, style],
            outputs=[output_image, output_prompt]
        )
    
    return app

# 启动Gradio应用
if __name__ == "__main__":
    app = create_gradio_interface()
    app.launch()
            

# 图像内容审核系统
import openai
import json
import base64
import datetime
import os

# 使用laozhang.ai中转API
client = openai.OpenAI(
    base_url="https://api.laozhang.ai/v1",
    api_key="your-laozhang-api-key"
)

class ImageModerationSystem:
    def __init__(self):
        self.sensitive_categories = [
            "成人内容", "暴力内容", "仇恨言论", "自残内容", 
            "骚扰内容", "违禁品", "未成年人不适内容"
        ]
        self.logs_dir = "moderation_logs"
        os.makedirs(self.logs_dir, exist_ok=True)
    
    def analyze_image(self, image_path):
        """分析图像内容并进行审核"""
        try:
            # 编码图像为base64
            with open(image_path, "rb") as image_file:
                base64_image = base64.b64encode(image_file.read()).decode('utf-8')
            
            # 构建审核提示词
            prompt = f"""
            请分析这张图片，并进行以下内容审核：
            1. 详细描述图片包含的主要内容
            2. 检查图片是否包含以下任何敏感内容：{', '.join(self.sensitive_categories)}
            3. 识别图片中可能的商标、品牌标志或版权内容
            4. 为图片内容分配适合的年龄分级（全年龄、PG-13、R级、成人内容）
            5. 给出最终审核建议：通过、拒绝或需要人工审核

            以JSON格式返回结果，包含以下字段：
            {{"description": "图片描述", 
              "sensitive_content": [包含的敏感类别列表], 
              "brand_elements": [识别到的品牌元素], 
              "age_rating": "年龄分级", 
              "recommendation": "审核建议",
              "confidence": "置信度(0-1)"}}
            """
            
            # 调用API分析图像
            response = client.chat.completions.create(
                model="gpt-4o",
                response_format={"type": "json_object"},
                messages=[
                    {
                        "role": "user",
                        "content": [
                            {"type": "text", "text": prompt},
                            {
                                "type": "image_url",
                                "image_url": {
                                    "url": f"data:image/jpeg;base64,{base64_image}"
                                }
                            }
                        ]
                    }
                ],
                max_tokens=1000
            )
            
            # 解析JSON响应
            result = json.loads(response.choices[0].message.content)
            
            # 记录审核日志
            self._log_moderation(image_path, result)
            
            return result
            
        except Exception as e:
            error_msg = f"图像分析错误: {str(e)}"
            print(error_msg)
            return {
                "error": error_msg,
                "recommendation": "需要人工审核",
                "confidence": 0
            }
    
    def _log_moderation(self, image_path, result):
        """记录审核日志"""
        timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
        log_file = os.path.join(self.logs_dir, f"moderation_{timestamp}.json")
        
        log_data = {
            "timestamp": timestamp,
            "image_path": image_path,
            "moderation_result": result
        }
        
        with open(log_file, "w", encoding="utf-8") as f:
            json.dump(log_data, f, ensure_ascii=False, indent=2)
    
    def batch_process(self, images_dir):
        """批量处理目录中的所有图像"""
        results = []
        for filename in os.listdir(images_dir):
            if filename.lower().endswith(('.png', '.jpg', '.jpeg', '.gif', '.webp')):
                image_path = os.path.join(images_dir, filename)
                print(f"处理图像: {filename}")
                result = self.analyze_image(image_path)
                results.append({"filename": filename, "result": result})
        
        return results

# 使用示例
if __name__ == "__main__":
    moderator = ImageModerationSystem()
    
    # 分析单个图像
    result = moderator.analyze_image("test_image.jpg")
    print(json.dumps(result, ensure_ascii=False, indent=2))
    
    # 批量处理
    # batch_results = moderator.batch_process("images_to_moderate")