图像生成模型

curl --request POST \
  --url https://$BASE_URL/v1/images/generations \
  --header 'authorization: Bearer 申请到的key' \
  --header 'content-type: application/json' \
  --data '{
    "model": "模型ID",
    "prompt": "想要图片的内容描述"
}'

import openai
 
client = openai.OpenAI(
    api_key="申请到的key",  
    base_url="https://$BASE_URL/v1/"
)
 
response = client.images.generate(
    model="模型ID",  # model to send to the proxy
    prompt="想要图片的内容描述",
)
print(response)

package main
 
import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "log"
    "net/http"
)
 
// 定义请求结构体
type GenerationRequest struct {
    Model  string `json:"model"`
    Prompt string `json:"prompt"`
}
 
func main() {
    // 1. 配置请求参数
    apiKey := "申请到的key"
    modelID := "模型ID"
    promptText := "想要图片的内容描述"
 
    // 2. 创建请求体
    reqBody := GenerationRequest{
        Model:  modelID,
        Prompt: promptText,
    }
 
    // 3. 序列化为JSON
    jsonData, err := json.Marshal(reqBody)
    if err != nil {
        log.Fatalf("JSON序列化失败: %v", err)
    }
 
    // 4. 创建HTTP请求
    req, err := http.NewRequest(
        "POST",
        "https://$BASE_URL/v1/images/generations",
        bytes.NewBuffer(jsonData),
    )
    if err != nil {
        log.Fatalf("创建请求失败: %v", err)
    }
 
    // 5. 设置请求头
    req.Header.Set("Authorization", "Bearer "+apiKey)
    req.Header.Set("Content-Type", "application/json")
 
    // 6. 发送请求
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        log.Fatalf("请求发送失败: %v", err)
    }
    defer resp.Body.Close()
 
    // 7. 处理响应
    if resp.StatusCode != http.StatusOK {
        log.Fatalf("请求失败，状态码: %d", resp.StatusCode)
    }
 
    // 8. 读取响应体
    body, err := io.ReadAll(resp.Body)
    if err != nil {
        log.Fatalf("读取响应失败: %v", err)
    }
 
    // 9. 输出结果
    fmt.Printf("生成结果:\n%s\n", body)
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
 
public class ImageGeneration {
    public static void main(String[] args) {
        try {
            // 1. 创建URL对象
            URL url = new URL("https://$BASE_URL/v1/images/generations");
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            
            // 2. 配置请求头和请求方法
            connection.setRequestMethod("POST");
            connection.setRequestProperty("Authorization", "Bearer 申请到的key");
            connection.setRequestProperty("Content-Type", "application/json");
            connection.setDoOutput(true);
            
            // 3. 构建JSON请求体
            String jsonInputString = "{"
                + "\"model\": \"模型ID\","
                + "\"prompt\": \"想要图片的内容描述\""
                + "}";
            
            // 4. 发送请求数据
            try(OutputStream os = connection.getOutputStream()) {
                byte[] input = jsonInputString.getBytes("utf-8");
                os.write(input, 0, input.length);
            }
            
            // 5. 处理响应
            int statusCode = connection.getResponseCode();
            if (statusCode == HttpURLConnection.HTTP_OK) {
                try(BufferedReader br = new BufferedReader(
                    new InputStreamReader(connection.getInputStream(), "utf-8"))) {
                    
                    StringBuilder response = new StringBuilder();
                    String responseLine;
                    while ((responseLine = br.readLine()) != null) {
                        response.append(responseLine);
                    }
                    System.out.println("生成结果：\n" + response.toString());
                }
            } else {
                System.out.println("请求失败，状态码: " + statusCode);
            }
            
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

const axios = require('axios');
 
async function generateImage() {
    // 配置参数
    const config = {
        headers: {
            'Authorization': 'Bearer 申请到的key',
            'Content-Type': 'application/json'
        }
    };
 
    // 请求体
    const data = {
        model: "模型ID",
        prompt: "想要图片的内容描述"
    };
 
    try {
        // 发送POST请求
        const response = await axios.post(
            'https://$BASE_URL/v1/images/generations',
            data,
            config
        );
 
        // 处理成功响应
        console.log('生成结果:', response.data);
        return response.data;
 
    } catch (error) {
        // 错误处理
        if (error.response) {
            console.error(`请求失败 [状态码 ${error.response.status}]:`, error.response.data);
        } else {
            console.error('请求错误:', error.message);
        }
        throw error;
    }
}
 
// 执行生成
generateImage()
    .then(data => console.log('生成的图片URL:', data.data[0].url))
    .catch(() => console.log('生成流程终止'));

# 文生图生成接口
curl --location 'https://$BASE_URL/v1/p003/text2image' \
--header 'Authorization: Bearer [申请的key]' \
--header 'Content-Type: application/json' \
--data '{
    "model": "WanX2.1-T2I-Plus", # 或 WanX2.1-T2I-Turbo
    "input": {
        "prompt": "蜜蜂采花"
    },
    "parameters": {
        "size": "1024*1024",
        "n": 1 #生成数量
    }
}'
   
# 查询接口，获取图片连接
curl --location --request GET 'https://$BASE_URL/v1/p003/tasks/{生成接口返回的task_id}' \
--header 'Authorization: Bearer [申请的key]' 

import requests
 
# 文生图生成接口
def text_to_image(api_key, base_url, prompt, model="WanX2.1-T2I-Plus", size="1024*1024", n=1):
url = f"https://{base_url}/v1/p003/text2image"
headers = {
    "Authorization": f"Bearer {api_key}",
    "Content-Type": "application/json"
}
payload = {
    "model": model,
    "input": {
        "prompt": prompt
    },
    "parameters": {
        "size": size,
        "n": n
    }
}
 
response = requests.post(url, headers=headers, json=payload)
response.raise_for_status()
return response.json()
 
# 查询接口，获取图片链接
def get_task_result(api_key, base_url, task_id):
url = f"https://{base_url}/v1/p003/tasks/{task_id}"
headers = {
    "Authorization": f"Bearer {api_key}"
}
 
response = requests.get(url, headers=headers)
response.raise_for_status()
return response.json()
 
# 使用示例
if __name__ == "__main__":
API_KEY = "[申请的key]"
BASE_URL = "$BASE_URL"  # 替换为实际的base URL
 
try:
    # 第一步：生成图片
    generation_result = text_to_image(
        api_key=API_KEY,
        base_url=BASE_URL,
        prompt="蜜蜂采花",
        model="WanX2.1-T2I-Plus"
    )
    print("生成结果:", generation_result)
    
    # 第二步：从output中提取task_id
    task_id = generation_result.get("output", {}).get("task_id")
    if task_id:
        print(f"获取到task_id: {task_id}")
        
        # 查询任务结果
        task_result = get_task_result(
            api_key=API_KEY,
            base_url=BASE_URL,
            task_id=task_id
        )
        print("任务结果:", task_result)
    else:
        print("生成结果中没有找到task_id")
        
except requests.exceptions.RequestException as e:
    print(f"请求出错: {e}")
except Exception as e:
    print(f"发生错误: {e}")

package main
 
import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)
 
// 文生图生成接口
func textToImage(apiKey, baseURL, prompt, model, size string, n int) (map[string]interface{}, error) {
    url := fmt.Sprintf("https://%s/v1/p003/text2image", baseURL)
 
    payload := map[string]interface{}{
        "model": model,
        "input": map[string]interface{}{
            "prompt": prompt,
        },
        "parameters": map[string]interface{}{
            "size": size,
            "n":    n,
        },
    }
 
    jsonPayload, err := json.Marshal(payload)
    if err != nil {
        return nil, fmt.Errorf("JSON编码失败: %v", err)
    }
 
    req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonPayload))
    if err != nil {
        return nil, fmt.Errorf("创建请求失败: %v", err)
    }
 
    req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", apiKey))
    req.Header.Set("Content-Type", "application/json")
 
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return nil, fmt.Errorf("请求失败: %v", err)
    }
    defer resp.Body.Close()
 
    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("请求返回非200状态码: %d", resp.StatusCode)
    }
 
    body, err := io.ReadAll(resp.Body)
    if err != nil {
        return nil, fmt.Errorf("读取响应体失败: %v", err)
    }
 
    var result map[string]interface{}
    if err := json.Unmarshal(body, &result); err != nil {
        return nil, fmt.Errorf("JSON解析失败: %v", err)
    }
 
    return result, nil
}
 
// 查询接口，获取图片链接
func getTaskResult(apiKey, baseURL, taskID string) (map[string]interface{}, error) {
    url := fmt.Sprintf("https://%s/v1/p003/tasks/%s", baseURL, taskID)
 
    req, err := http.NewRequest("GET", url, nil)
    if err != nil {
        return nil, fmt.Errorf("创建请求失败: %v", err)
    }
 
    req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", apiKey))
 
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return nil, fmt.Errorf("请求失败: %v", err)
    }
    defer resp.Body.Close()
 
    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("请求返回非200状态码: %d", resp.StatusCode)
    }
 
    body, err := io.ReadAll(resp.Body)
    if err != nil {
        return nil, fmt.Errorf("读取响应体失败: %v", err)
    }
 
    var result map[string]interface{}
    if err := json.Unmarshal(body, &result); err != nil {
        return nil, fmt.Errorf("JSON解析失败: %v", err)
    }
 
    return result, nil
}
 
func main() {
    apiKey := "[申请的key]"
    baseURL := "$BASE_URL" // 替换为实际的base URL
 
    // 第一步：生成图片
    generationResult, err := textToImage(
        apiKey,
        baseURL,
        "蜜蜂采花",
        "WanX2.1-T2I-Plus",
        "1024*1024",
        1,
    )
    if err != nil {
        fmt.Printf("生成图片失败: %v\n", err)
        return
    }
 
    fmt.Printf("生成结果: %+v\n", generationResult)
 
    // 第二步：从output中提取task_id
    output, ok := generationResult["output"].(map[string]interface{})
    if !ok {
        fmt.Println("生成结果中没有找到output字段")
        return
    }
 
    taskID, ok := output["task_id"].(string)
    if !ok {
        fmt.Println("output中没有找到task_id字段")
        return
    }
 
    fmt.Printf("获取到task_id: %s\n", taskID)
 
    // 查询任务结果
    taskResult, err := getTaskResult(apiKey, baseURL, taskID)
    if err != nil {
        fmt.Printf("查询任务结果失败: %v\n", err)
        return
    }
 
    fmt.Printf("任务结果: %+v\n", taskResult)
}

<dependency>
    <groupId>org.json</groupId>
    <artifactId>json</artifactId>
    <version>20231013</version>
</dependency>
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import org.json.JSONObject;
 
public class WanXImageGenerator {
 
    // 文生图生成接口
    public static JSONObject textToImage(String apiKey, String baseUrl, String prompt, 
                                        String model, String size, int n) throws Exception {
        String url = "https://" + baseUrl + "/v1/p003/text2image";
        
        JSONObject payload = new JSONObject();
        payload.put("model", model);
        
        JSONObject input = new JSONObject();
        input.put("prompt", prompt);
        payload.put("input", input);
        
        JSONObject parameters = new JSONObject();
        parameters.put("size", size);
        parameters.put("n", n);
        payload.put("parameters", parameters);
        
        HttpURLConnection conn = (HttpURLConnection) new URL(url).openConnection();
        conn.setRequestMethod("POST");
        conn.setRequestProperty("Authorization", "Bearer " + apiKey);
        conn.setRequestProperty("Content-Type", "application/json");
        conn.setDoOutput(true);
        
        try (OutputStream os = conn.getOutputStream()) {
            byte[] inputBytes = payload.toString().getBytes(StandardCharsets.UTF_8);
            os.write(inputBytes, 0, inputBytes.length);
        }
        
        if (conn.getResponseCode() != HttpURLConnection.HTTP_OK) {
            throw new Exception("HTTP error code: " + conn.getResponseCode());
        }
        
        try (BufferedReader br = new BufferedReader(
                new InputStreamReader(conn.getInputStream(), StandardCharsets.UTF_8))) {
            StringBuilder response = new StringBuilder();
            String responseLine;
            while ((responseLine = br.readLine()) != null) {
                response.append(responseLine.trim());
            }
            return new JSONObject(response.toString());
        }
    }
    
    // 查询接口，获取图片链接
    public static JSONObject getTaskResult(String apiKey, String baseUrl, String taskId) throws Exception {
        String url = "https://" + baseUrl + "/v1/p003/tasks/" + taskId;
        
        HttpURLConnection conn = (HttpURLConnection) new URL(url).openConnection();
        conn.setRequestMethod("GET");
        conn.setRequestProperty("Authorization", "Bearer " + apiKey);
        
        if (conn.getResponseCode() != HttpURLConnection.HTTP_OK) {
            throw new Exception("HTTP error code: " + conn.getResponseCode());
        }
        
        try (BufferedReader br = new BufferedReader(
                new InputStreamReader(conn.getInputStream(), StandardCharsets.UTF_8))) {
            StringBuilder response = new StringBuilder();
            String responseLine;
            while ((responseLine = br.readLine()) != null) {
                response.append(responseLine.trim());
            }
            return new JSONObject(response.toString());
        }
    }
    
    public static void main(String[] args) {
        String apiKey = "[申请的key]";
        String baseUrl = "$BASE_URL"; // 替换为实际的base URL
        
        try {
            // 第一步：生成图片
            JSONObject generationResult = textToImage(
                apiKey, 
                baseUrl, 
                "蜜蜂采花", 
                "WanX2.1-T2I-Plus", 
                "1024*1024", 
                1
            );
            System.out.println("生成结果: " + generationResult.toString(2));
            
            // 第二步：从output中提取task_id
            JSONObject output = generationResult.getJSONObject("output");
            String taskId = output.getString("task_id");
            System.out.println("获取到task_id: " + taskId);
            
            // 查询任务结果
            JSONObject taskResult = getTaskResult(apiKey, baseUrl, taskId);
            System.out.println("任务结果: " + taskResult.toString(2));
            
        } catch (Exception e) {
            System.err.println("发生错误: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

const https = require('https');
 
// 文生图生成接口
async function textToImage(apiKey, baseUrl, prompt, model = 'WanX2.1-T2I-Plus', size = '1024*1024', n = 1) {
  return new Promise((resolve, reject) => {
    const postData = JSON.stringify({
      model,
      input: { prompt },
      parameters: { size, n }
    });
 
    const options = {
      hostname: baseUrl,
      path: '/v1/p003/text2image',
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${apiKey}`,
        'Content-Type': 'application/json',
        'Content-Length': postData.length
      }
    };
 
    const req = https.request(options, (res) => {
      let data = '';
      res.on('data', (chunk) => data += chunk);
      res.on('end', () => {
        if (res.statusCode !== 200) {
          return reject(new Error(`HTTP error! status: ${res.statusCode}`));
        }
        resolve(JSON.parse(data));
      });
    });
 
    req.on('error', (error) => reject(error));
    req.write(postData);
    req.end();
  });
}
 
// 查询接口，获取图片链接
async function getTaskResult(apiKey, baseUrl, taskId) {
  return new Promise((resolve, reject) => {
    const options = {
      hostname: baseUrl,
      path: `/v1/p003/tasks/${taskId}`,
      method: 'GET',
      headers: {
        'Authorization': `Bearer ${apiKey}`
      }
    };
 
    const req = https.request(options, (res) => {
      let data = '';
      res.on('data', (chunk) => data += chunk);
      res.on('end', () => {
        if (res.statusCode !== 200) {
          return reject(new Error(`HTTP error! status: ${res.statusCode}`));
        }
        resolve(JSON.parse(data));
      });
    });
 
    req.on('error', (error) => reject(error));
    req.end();
  });
}
 
// 使用示例
(async () => {
  const API_KEY = '[申请的key]';
  const BASE_URL = '$BASE_URL'; // 替换为实际的base URL
 
  try {
    // 第一步：生成图片
    const generationResult = await textToImage(
      API_KEY,
      BASE_URL,
      '蜜蜂采花',
      'WanX2.1-T2I-Plus'
    );
    console.log('生成结果:', generationResult);
 
    // 第二步：从output中提取task_id
    const taskId = generationResult.output?.task_id;
    if (!taskId) {
      throw new Error('生成结果中没有找到task_id');
    }
    console.log(`获取到task_id: ${taskId}`);
 
    // 查询任务结果
    const taskResult = await getTaskResult(API_KEY, BASE_URL, taskId);
    console.log('任务结果:', taskResult);
 
  } catch (error) {
    console.error('发生错误:', error);
  }
})();