文生图AI 有比较牛的免费版吗

[sonic2080]

目前最厉害的生图AI 好像是midjourney 特别贵 根本用不起 有什么平替吗

[Hanawa]

豆包啊，国内的免费版基本都有文生图吧

[Rickywong (王)]

kimi能文生图吗

[YARUN (迷途)]

谷歌的，马斯克的

[Hanawa]

确实，记混了，已修改

[sakuraL]

sd3.5

[xqc]

midjourney 算工具吧，对标的免费工具应该就是Stable Diffusion

[handsome (大帅哥)]

flux呀

[kaed]

那肯定是大善人的imageFX了

[sonic2080]

SD 要收费

[sonic2080]

这个还不错

[sjs1 (吃饭睡觉)]

genspark

[xqc]

我以为你要本地搞，是用秋叶佬的绘世启动器
https://www.bilibili.com/opus/897873624905547794

[sonic2080]

不搞本地的 没有牛逼的显卡训练，也只能是人工弱智

[xqc]

不太懂文生图，只是之前准备搞AIGC检测的时候了解了下 计划已经破产了

[sonic2080]

打算做做自媒体账号弄粉丝 做做AI 图片 AI视频啥的

[zhangshiwu (张十五)]

字节旗下的即梦 AI 可以，每天送 88 积分

[wnndedi (S大魔导)]

可灵 即梦，我一直用的即梦，最近可能用的人越来越多，时间有所变长

[komorebi]

基于站内多个大佬的贡献

根据https://linux.do/t/topic/326665 中提供genspark api
根据https://linux.do/t/topic/185085 中的dall-e-3转chat
实现对话生图的效果，由于个人对代码有一些修改，包含了一部分敏感信息，因此删减后得到如下可以直接运行的脚本，放到cloudflare上的worker里直接运行

function base64ToArrayBuffer(base64) {
    const binaryString = atob(base64);
    const len = binaryString.length;
    const bytes = new Uint8Array(len);
    for (let i = 0; i < len; i++) {
        bytes[i] = binaryString.charCodeAt(i);
    }
    return bytes;
}

async function generateImage(prompt, draw_model, requestUrl) {
    const URL_genspark = "https://gs.aytsao.cn/v1/images/generations";
    const AUTH_TOKEN_gs = `sk-genspark2api`;
    const DEFAULT_SIZE = "1:1";
    let size = DEFAULT_SIZE;
    let cleanPrompt = prompt;


    const paramPattern = /---(\S+)/g;
    let match;
    const params = {};
    while ((match = paramPattern.exec(prompt)) !== null) {
        const param = match[1].trim();
        params[param.toLowerCase()] = match.index;
    }

    // 检查和处理尺寸参数
    for (const param in params) {
        if (isSizeValid(param)) {
            size = param;
            cleanPrompt = cleanPrompt.slice(0, params[param]).trim();
            break; // 假设同一时间只会有一个有效尺寸
        }
    }

    if (draw_model.endsWith("-genspark")) {
        try {
            const jsonBody = {
                model: draw_model.replace(/-genspark$/, ""),
                prompt: cleanPrompt || " ",
                aspect_ratio: size,
                "safety_filter_level": "BLOCK_ONLY_HIGH",
                "person_generation": "ALLOW_ADULT"
            };
            const response = await fetch(URL_genspark, {
                method: 'POST',
                headers: {
                    'Authorization': `Bearer ${AUTH_TOKEN_gs}`,
                    'Accept': 'application/json',
                    'Content-Type': 'application/json'
                },
                body: JSON.stringify(jsonBody)
            });

            if (response.ok) {
                const jsonResponse = await response.json();
                return {
                    prompt: cleanPrompt,
                    created: Math.floor(Date.now() / 1000),
                    data: jsonResponse["data"],
                    size: size
                };
            }
            console.error(response);
        } catch (e) {
            console.error("Error generating image:", e);
        }
    }

    // 默认响应  
    return {
        prompt: cleanPrompt,
        created: Math.floor(Date.now() / 1000),
        data: [{ url: "https://pic.netbian.com/uploads/allimg/240808/192001-17231160015724.jpg" }],
        size: size
    };
}

function isSizeValid(size) {
    return ["16:9", "1:1", "9:16", "3:2", "3:4", "1:2"].includes(size);
}

function generateFakeStream(imageData, prompt, draw_model) {
    const encoder = new TextEncoder();
    const chunks = [
        `🎨 使用提示词：\n${prompt}\n`,
        `📐 图像规格：${imageData.size}\n`,
        "🖼️ 正在根据提示词生成图像...\n",
        "🔄 图像正在处理中...\n",
        "⏳ 即将完成...\n",
        `🌟 生成成功！\n图像生成完毕，以下是结果：\n\n${imageData.data
            .map((image, index) => `![生成的图像 ${index + 1}](${image.url})`)
            .join("\n\n")  // 使用换行符连接多个图像
        }`
    ];

    let index = 0;

    return new ReadableStream({
        start(controller) {
            function push() {
                if (index < chunks.length) {
                    const chunk = chunks[index++];
                    const data = JSON.stringify({
                        id: `chatcmpl-${Date.now()}`,
                        object: 'chat.completion.chunk',
                        created: imageData.created,
                        model: draw_model,
                        choices: [{
                            index: 0,
                            delta: { role: 'assistant', content: chunk },
                            finish_reason: index === chunks.length ? 'stop' : null
                        }]
                    });
                    controller.enqueue(encoder.encode(`data: ${data}\n\n`));
                    setTimeout(push, 500); // Simulate processing time  
                } else {
                    controller.enqueue(encoder.encode('data: [DONE]\n\n'));
                    controller.close();
                }
            }
            push();
        }
    });
}

function generateNonStreamResponse(imageData, prompt, draw_model) {
    const content = `🎨 使用提示词：${prompt}\n` +
        `📐 图像规格：${imageData.size}\n` +
        `🌟 图像生成成功！\n` +
        `以下是结果：\n\n` +
        `🌟 生成成功！\n图像生成完毕，以下是结果：\n\n${imageData.data
            .map((image, index) => `![生成的图像 ${index + 1}](${image.url})`)
            .join("\n\n")  // 使用换行符连接多个图像
        }`;
    return {
        id: `chatcmpl-${Date.now()}`,
        object: 'chat.completion',
        created: imageData.created,
        model: draw_model,
        choices: [{
            index: 0,
            message: {
                role: 'assistant',
                content: content
            },
            finish_reason: 'stop'
        }]
    };
}

async function handleRequest(request) {
    if (request.method === "OPTIONS") {
        return new Response("OK", {
            headers: {
                'Content-Type': 'application/json',
                'Access-Control-Allow-Origin': '*',
                'Access-Control-Allow-Methods': 'GET, POST, PUT, OPTIONS',
                'Access-Control-Allow-Headers': '*',
            },
        });
    }
    // 处理 GET 请求  
    if (request.method === 'GET') {
        return new Response(JSON.stringify({
            data: [
                {
                    "id": "flux-genspark",
                    "object": "model"
                },
                {
                    "id": "flux-speed-genspark",
                    "object": "model"
                },
                {
                    "id": "flux-pro/ultra-genspark",
                    "object": "model"
                },
                {
                    "id": "ideogram-genspark",
                    "object": "model"
                },
                {
                    "id": "recraft-v3-genspark",
                    "object": "model"
                },
                {
                    "id": "dall-e-3-genspark",
                    "object": "model"
                },
                {
                    "id": "imagen3-genspark",
                    "object": "model"
                }
            ],
            "success": true
        }), {
            headers: {
                'Content-Type': 'application/json',
                'Access-Control-Allow-Origin': '*',
                'Access-Control-Allow-Methods': 'GET, POST, PUT, OPTIONS',
                'Access-Control-Allow-Headers': '*',
            },
        });
    }

    // 处理 POST 请求  
    if (request.method !== 'POST') {
        return new Response('Only POST requests are allowed', { status: 405 });
    }

    let json;
    try {
        json = await request.json();
    } catch (err) {
        return new Response('Invalid JSON', { status: 400 });
    }

    // 从 OpenAI 格式的请求中提取用户的最后一条消息  
    const messages = json.messages || [];
    const lastUserMessage = messages.reverse().find(msg => msg.role === 'user');
    const prompt = lastUserMessage ? lastUserMessage.content : '';
    const draw_model = json.model || "flux-genspark";

    if (!prompt) {
        return new Response('No valid prompt found in the request', { status: 400 });
    }

    const imageData = await generateImage(prompt, draw_model, request.url);
    const prompt_ = imageData.prompt;
    // 检查是否请求流式响应  
    const isStreamRequested = json.stream === true;

    if (isStreamRequested) {
        const stream = generateFakeStream(imageData, prompt_, draw_model);
        return new Response(stream, {
            headers: { 'Content-Type': 'text/event-stream' }
        });
    } else {
        const response = generateNonStreamResponse(imageData, prompt_, draw_model);
        return new Response(JSON.stringify(response), {
            headers: {
                'Content-Type': 'application/json',
                'Access-Control-Allow-Origin': '*',
                'Access-Control-Allow-Methods': 'GET, POST, PUT, OPTIONS',
                'Access-Control-Allow-Headers': '*',
            }
        });
    }
}

addEventListener('fetch', event => {
    const url = new URL(event.request.url);
    event.respondWith(handleRequest(event.request));
});

效果如下：

[sonic2080]

这俩链接 我都打不开。。。。