牛学长图片增强API说明文档-图片增强API接入

概述

牛学长图片增强API提供多种图像处理功能，包括超分辨率、降噪、上色、色彩增强、暗光增强、文字增强、动漫增强和人脸处理等。通过此API，您可以提交图片处理任务，然后使用任务状态查询API获取处理结果。

图片增强API

基本信息

接口地址： https://api-base.niuxuezhang.cn/api/photo-enhancer
请求方式： POST
Content-Type： application/json
鉴权方式：APIKEY（通过请求头传递）

请求参数

参数名	类型	必填	说明
model_list	array	是	模型列表，可选择多个模型进行处理，参考模型列表
img_url	string	是	图片URL地址，需确保可公开访问
extension	string	是	图片扩展名，如jpg、png等
upscale	int	否	放大倍数，可选值：1、2、4、8
exif	bool	否	是否保留EXIF信息
DPI	int64	否	输出图片DPI值

模型列表

编号	模型名称	model_list
1	通用高质量二倍	super_resolution_2x
2	通用高质量四倍	super_resolution_4x
3	降噪	denoise_4x
4	老照片上色	colorize
5	黑白上色	colorize_v2
6	色彩增强	color_enhance
7	暗光增强	light_enhance
8	文字超分二倍	text_enhance_2x
9	文字超分四倍	text_enhance_4x
10	动漫超分	anime_enhance
11	人脸柔和超分	face_enhance_1x
12	人脸柔和二倍超分	face_enhance_2x
13	人脸柔和四倍超分	face_enhance_4x

请求示例

请求头：

                      
                
APIKEY: your_api_key_here
Content-Type: application/json

请求体：

                      
                
{
  "model_list": ["super_resolution_2x", "denoise_4x"],
  "img_url": "https://example.com/image.jpg",
  "extension": ".jpg",
  "upscale": 2,
  "exif": true,
  "DPI": 300,
}

响应参数

成功响应：

                      
                
{
  "code": 200,
  "message": "",
  "data": {
    "job_id": "aaa"
  }
}

参数名	类型	说明
code	int	状态码，200表示成功
message	string	响应消息
data.job_id	string	任务ID，用于后续查询任务状态

错误码说明

错误码	说明
110400000	API密钥无效
110402001	账户余额不足
110400002	任务不存在
110400003	任务失败，请重试
110400004	demo 次数超限
110400005	输入的模型不支持
110400006	倍数不合法
110400007	输出格式不支持

任务状态查询API

基本信息

接口地址： https://api-base.niuxuezhang.cn/api/task-status
请求方式： POST
Content-Type： application/json
鉴权方式：APIKEY（通过请求头传递）

请求参数

参数名	类型	必填	说明
job_id	string	是	任务ID，通过图片增强API返回获取

响应参数

成功响应：

                      
                
{
  "code": 200,
  "message": "",
  "data": {
    "job_id": "aaa",
    "status": "COMPLETED",
    "res_url": "https://example.com/result.jpg",
    "original_url": "https://example.com/original.jpg"
  }
}

参数名	类型	说明
code	int	状态码，200表示成功
message	string	响应消息
data.job_id	string	任务ID
data.status	string	任务状态，参考状态码说明
data.res_url	string	结果图片URL，仅当status为COMPLETED时有效
data.original_url	string	原始图片URL

状态码说明

状态码	说明
CONVERTING	正在进行编辑任务中
COMPLETED	任务已完成
ERROR	编辑任务失败

请求示例

请求头：

                      
                
APIKEY: your_api_key_here
Content-Type: application/json

请求体：

                      
                
{
  "job_id": "aaa"
}

调用示例

                                        
# 提交图片增强任务：
curl -X POST 'https://api-base.niuxuezhang.com/api/photo-enhancer' \
-H 'Content-Type: application/json' \
-H 'APIKEY: your_api_key_here' \
-d '{
  "model_list": ["super_resolution_2x", "super_resolution_4x"],
  "img_url": "https://example.com/image.jpg",
  "extension": ".jpg",
  "upscale": 2,
  "exif": true,
  "DPI": 300,
}'

# 查询任务状态：
curl -X POST 'https://api-base.niuxuezhang.cn/api/task-status' \
-H 'Content-Type: application/json' \
-H 'APIKEY: your_api_key_here' \
-d '{
  "job_id": "aaa"
}'

                                        
import requests
import time
import json

# API配置
API_KEY = "your_api_key_here"
BASE_URL = "https://api-base.niuxuezhang.com/api"
HEADERS = {
    "Content-Type": "application/json",
    "APIKEY": API_KEY
}

def enhance_photo(img_url, models, extension="jpg", upscale=2):
    """提交图片增强任务"""
    url = f"{BASE_URL}/photo-enhancer"
    payload = {
        "model_list": models,
        "img_url": img_url,
        "extension": extension,
        "upscale": upscale,
        "exif": True, 
        "DPI": 300,
    }

    response = requests.post(url, headers=HEADERS, json=payload)
    return response.json()

def check_task_status(job_id):
    """查询任务状态"""
    url = f"{BASE_URL}/task-status"
    payload = {
        "job_id": job_id
    }

    response = requests.post(url, headers=HEADERS, json=payload)
    return response.json()

def main():
    # 提交图片增强任务
    img_url = "https://example.com/image.jpg"
    models = ["super_resolution_2x", "denoise_4x"]  # 使用通用高质量二倍和降噪

    result = enhance_photo(img_url, models)
    print("任务提交结果:", json.dumps(result, indent=2, ensure_ascii=False))

    if result["code"] == 200:
        job_id = result["data"]["job_id"]
        print(f"任务ID: {job_id}")

        # 轮询任务状态
        while True:
            status_result = check_task_status(job_id)
            print("任务状态:", json.dumps(status_result, indent=2, ensure_ascii=False))

            if status_result["code"] == 200:
                status = status_result["data"]["status"]
                if status == "COMPLETED":
                    print(f"任务完成，结果URL: {status_result['data']['res_url']}")
                    break
                elif status == "ERROR":
                    print("任务失败")
                    break

            print("任务处理中，等待5秒...")
            time.sleep(5)
    else:
        print(f"任务提交失败: {result['message']}")

if __name__ == "__main__":
    main()

   
                                                           
import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.ObjectNode;

public class PhotoEnhancerExample {
    private static final String API_KEY = "your_api_key_here";
    private static final String BASE_URL = "https://api-base.niuxuezhang.com/api";
    private static final HttpClient httpClient = HttpClient.newBuilder()
            .version(HttpClient.Version.HTTP_2)
            .connectTimeout(Duration.ofSeconds(10))
            .build();
    private static final ObjectMapper objectMapper = new ObjectMapper();

    public static void main(String[] args) throws Exception {
        // 提交图片增强任务
        String imgUrl = "https://example.com/image.jpg";
        List<String> models = Arrays.asList("super_resolution_2x", "denoise_4x"); // super_resolution_2x和降噪

        System.out.println("提交图片增强任务...");
        JsonNode result = enhancePhoto(imgUrl, models);
        System.out.println("任务提交结果: " + result.toString());

        if (result.get("code").asInt() == 200) {
            String jobId = result.get("data").get("job_id").asText();
            System.out.println("任务ID: " + jobId);

            // 轮询任务状态
            while (true) {
                JsonNode statusResult = checkTaskStatus(jobId);
                System.out.println("任务状态: " + statusResult.toString());

                if (statusResult.get("code").asInt() == 200) {
                    String status = statusResult.get("data").get("status").asText();
                    if ("COMPLETED".equals(status)) {
                        System.out.println("任务完成，结果URL: " + statusResult.get("data").get("res_url").asText());
                        break;
                    } else if ("ERROR".equals(status)) {
                        System.out.println("任务失败");
                        break;
                    }
                }

                System.out.println("任务处理中，等待5秒...");
                Thread.sleep(5000);
            }
        } else {
            System.out.println("任务提交失败: " + result.get("message").asText());
        }
    }

    // 提交图片增强任务
    private static JsonNode enhancePhoto(String imgUrl, List<String> models) throws IOException, InterruptedException {
        String url = BASE_URL + "/photo-enhancer";

        ObjectNode requestBody = objectMapper.createObjectNode();
        ArrayNode modelList = requestBody.putArray("model_list");
        models.forEach(modelList::add);

        requestBody.put("img_url", imgUrl);
        requestBody.put("extension", ".jpg");
        requestBody.put("upscale", 2);
        requestBody.put("exif", true);
        requestBody.put("DPI", 300);

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(url))
                .header("Content-Type", "application/json")
                .header("APIKEY", API_KEY)
                .POST(HttpRequest.BodyPublishers.ofString(requestBody.toString()))
                .build();

        HttpResponse<String> response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());
        return objectMapper.readTree(response.body());
    }

    // 查询任务状态
    private static JsonNode checkTaskStatus(String jobId) throws IOException, InterruptedException {
        String url = BASE_URL + "/task-status";

        ObjectNode requestBody = objectMapper.createObjectNode();
        requestBody.put("job_id", jobId);

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(url))
                .header("Content-Type", "application/json")
                .header("APIKEY", API_KEY)
                .POST(HttpRequest.BodyPublishers.ofString(requestBody.toString()))
                .build();

        HttpResponse<String> response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());
        return objectMapper.readTree(response.body());
    }
}

                                        
const axios = require('axios');

// API配置
const API_KEY = 'your_api_key_here';
const BASE_URL = 'https://api-base.niuxuezhang.com/api';
const HEADERS = {
  'Content-Type': 'application/json',
  'APIKEY': API_KEY
};

/**
 * 提交图片增强任务
 * @param {string} imgUrl - 图片URL
 * @param {string[]} models - 模型列表
 * @returns {Promise} - 返回Promise对象
 */
async function enhancePhoto(imgUrl, models) {
  const url = `${BASE_URL}/photo-enhancer`;
  const payload = {
    model_list: models,
    img_url: imgUrl,
    extension: '.jpg',
    upscale: 2,
    exif: true,
    DPI: 300
  };

  try {
    const response = await axios.post(url, payload, { headers: HEADERS });
    return response.data;
  } catch (error) {
    console.error('提交任务失败:', error.response ? error.response.data : error.message);
    throw error;
  }
}

/**
 * 查询任务状态
 * @param {string} jobId - 任务ID
 * @returns {Promise} - 返回Promise对象
 */
async function checkTaskStatus(jobId) {
  const url = `${BASE_URL}/task-status`;
  const payload = {
    job_id: jobId
  };

  try {
    const response = await axios.post(url, payload, { headers: HEADERS });
    return response.data;
  } catch (error) {
    console.error('查询任务状态失败:', error.response ? error.response.data : error.message);
    throw error;
  }
}

/**
 * 等待指定时间
 * @param {number} ms - 毫秒数
 * @returns {Promise} - 返回Promise对象
 */
function sleep(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

/**
 * 主函数
 */
async function main() {
  try {
    // 提交图片增强任务
    const imgUrl = 'https://example.com/image.jpg';
    const models = ['super_resolution_2x', 'denoise_4x']; // 通用高质量二倍和降噪

    console.log('提交图片增强任务...');
    const result = await enhancePhoto(imgUrl, models);
    console.log('任务提交结果:', JSON.stringify(result, null, 2));

    if (result.code === 200) {
      const jobId = result.data.job_id;
      console.log(`任务ID: ${jobId}`);

      // 轮询任务状态
      let isCompleted = false;
      while (!isCompleted) {
        console.log('查询任务状态...');
        const statusResult = await checkTaskStatus(jobId);
        console.log('任务状态:', JSON.stringify(statusResult, null, 2));

        if (statusResult.code === 200) {
          const status = statusResult.data.status;
          if (status === 'COMPLETED') {
            console.log(`任务完成，结果URL: ${statusResult.data.res_url}`);
            isCompleted = true;
          } else if (status === 'ERROR') {
            console.log('任务失败');
            isCompleted = true;
          } else {
            console.log('任务处理中，等待5秒...');
            await sleep(5000);
          }
        } else {
          console.log(`查询任务状态失败: ${statusResult.message}`);
          isCompleted = true;
        }
      }
    } else {
      console.log(`任务提交失败: ${result.message}`);
    }
  } catch (error) {
    console.error('处理过程中出错:', error);
  }
}

// 执行主函数
main();

                                        
package main
import (
  "bytes"
  "encoding/json"
  "fmt"
  "io/ioutil"
  "net/http"
  "time"
)

const (
  APIKEY  = "your_api_key_here"
  BaseURL = "https://api-base.niuxuezhang.com/api"
)

// PhotoEnhancerTaskRequest 图片增强任务请求
type PhotoEnhancerTaskRequest struct {
  ModelList  []string `json:"model_list"`
  ImgUrl     string   `json:"img_url"`
  Extension  string   `json:"extension"`
  Upscale    int      `json:"upscale"`
  Exif       bool     `json:"exif"`
  DPI        int64    `json:"DPI"`
}

// ApiStatusRequest 任务状态请求
type ApiStatusRequest struct {
  JobID string `json:"job_id"`
}

// ResponseData 通用响应数据结构
type ResponseData struct {
  Code    int             `json:"code"`
  Message string          `json:"message"`
  Data    json.RawMessage `json:"data"`
}

// JobData 任务ID数据
type JobData struct {
  JobID string `json:"job_id"`
}

// JobStatusResponse 任务状态响应
type JobStatusResponse struct {
  JobID       string `json:"job_id"`
  Status      string `json:"status"`
  ResUrl      string `json:"res_url"`
  OriginalUrl string `json:"original_url"`
}

// 提交图片增强任务
func enhancePhoto(imgUrl string, models []string) (*JobData, error) {
  url := fmt.Sprintf("%s/photo-enhancer", BaseURL)

  requestData := PhotoEnhancerTaskRequest{
    ModelList:  models,
    ImgUrl:     imgUrl,
    Extension:  "jpg",
    Upscale:    2,
    Exif:       true,
    DPI:        300,
  }

  requestBody, err := json.Marshal(requestData)
  if err != nil {
    return nil, err
  }

  req, err := http.NewRequest("POST", url, bytes.NewBuffer(requestBody))
  if err != nil {
    return nil, err
  }

  req.Header.Set("Content-Type", "application/json")
  req.Header.Set("APIKEY", APIKEY)

  client := &http.Client{}
  resp, err := client.Do(req)
  if err != nil {
    return nil, err
  }
  defer resp.Body.Close()

  body, err := ioutil.ReadAll(resp.Body)
  if err != nil {
    return nil, err
  }

  var responseData ResponseData
  err = json.Unmarshal(body, &responseData)
  if err != nil {
    return nil, err
  }

  if responseData.Code != 200 {
    return nil, fmt.Errorf("API错误: %s", responseData.Message)
  }

  var jobData JobData
  err = json.Unmarshal(responseData.Data, &jobData)
  if err != nil {
    return nil, err
  }

  return &jobData, nil
}

// 查询任务状态
func checkTaskStatus(jobID string) (*JobStatusResponse, error) {
  url := fmt.Sprintf("%s/task-status", BaseURL)

  requestData := ApiStatusRequest{
    JobID: jobID,
  }

  requestBody, err := json.Marshal(requestData)
  if err != nil {
    return nil, err
  }

  req, err := http.NewRequest("POST", url, bytes.NewBuffer(requestBody))
  if err != nil {
    return nil, err
  }

  req.Header.Set("Content-Type", "application/json")
  req.Header.Set("APIKEY", APIKEY)

  client := &http.Client{}
  resp, err := client.Do(req)
  if err != nil {
    return nil, err
  }
  defer resp.Body.Close()

  body, err := ioutil.ReadAll(resp.Body)
  if err != nil {
    return nil, err
  }

  var responseData ResponseData
  err = json.Unmarshal(body, &responseData)
  if err != nil {
    return nil, err
  }

  if responseData.Code != 200 {
    return nil, fmt.Errorf("API错误: %s", responseData.Message)
  }

  var statusData JobStatusResponse
  err = json.Unmarshal(responseData.Data, &statusData)
  if err != nil {
    return nil, err
  }

  return &statusData, nil
}

func main() {
  // 提交图片增强任务
  imgUrl := "https://example.com/image.jpg"
  models := []string{"super_resolution_2x", "denoise_4x"} // 使用通用高质量二倍和降噪

  fmt.Println("提交图片增强任务...")
  jobData, err := enhancePhoto(imgUrl, models)
  if err != nil {
    fmt.Printf("提交任务失败: %v\n", err)
    return
  }

  fmt.Printf("任务已提交，任务ID: %s\n", jobData.JobID)

  // 轮询任务状态
  for {
    fmt.Println("查询任务状态...")
    statusData, err := checkTaskStatus(jobData.JobID)
    if err != nil {
      fmt.Printf("查询任务状态失败: %v\n", err)
      return
    }

    fmt.Printf("任务状态: %s\n", statusData.Status)

    if statusData.Status == "COMPLETED" {
      fmt.Printf("任务完成，结果URL: %s\n", statusData.ResUrl)
      break
    } else if statusData.Status == "ERROR" {
      fmt.Println("任务失败")
      break
    }

    fmt.Println("任务处理中，等待5秒...")
    time.Sleep(5 * time.Second)
  }
}

价格说明

您可以通过在线充值和支付方式购买API调用点

查看价格列表

常见问题

Q1: 上传的图片格式有什么要求？

A1: 目前支持jpg，png，jpeg，webp，tif，tiff，bmp，jfif，tga，heic 等图片格式上传。

Q2: 支持的图片有大小限制吗？

A2: 目前支持上传的最大分辨率为8K。

牛学长图片增强API介绍

概述

图片增强API

基本信息

请求参数

模型列表

请求示例

响应参数

错误码说明

任务状态查询API

基本信息

请求参数

响应参数

状态码说明

请求示例

调用示例

价格说明

常见问题