Quick start

curl -X POST \
     -H "X-Api-Key: YOUR_API_KEY" \
     -H "Content-Type: application/json" \
     -d '{
            "image": "https://gcs-airbrush.mr.pixocial.com/f5e6df0c59ea56b1863893b6f9ea2a11.png",
            "maskType": "clothes",
            "modelId": "002",
            "backgroundTypes": ["original", "transparent", "preset"],
            "presetBackgroundId": "035",
            "count": 1
        }' \
     https://open.vmake.ai/api/v3/image/ai-fashion-model/tasks

curl -X GET \
     -H "X-Api-Key: YOUR_API_KEY" \
     https://open.vmake.ai/api/v3/image/ai-fashion-model/tasks/0f1c2d3e-4f5g-6h7i-8j9k-a1b2c3d4e5f6

package main
 
import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "log"
    "net/http"
    "time"
)
 
func main() {
    taskId, err := createTask()
    if err != nil {
        log.Fatalln("failed to create task:", err.Error())
        return
    }
    log.Println("task created successfully:", taskId)
 
    var results []TaskResult
    for {
        taskInfo, err := checkTask(taskId)
        if err != nil {
            log.Fatalln("failed to check task:", err.Error())
            return
        }
 
        if taskInfo.Status == "error" {
            log.Fatalln("task failed:", taskInfo.Message)
            return
        }
 
        log.Printf("task status: %s, progress: %d%%\n", taskInfo.Status, taskInfo.Progress)
 
        if taskInfo.Status == "pending" || taskInfo.Status == "running" {
            time.Sleep(3 * time.Second)
            continue
        }
 
        if taskInfo.Status == "success" {
            results = taskInfo.Results
            break
        }
    }
    log.Println("task completed successfully")
 
    for _, result := range results {
        log.Println("original background image: ", result.OriginalBackgroundImage.DownloadUrl)
        log.Println("preset background image: ", result.PresetBackgroundImage.DownloadUrl)
        log.Println("transparent background image: ", result.TransparentBackgroundImage.DownloadUrl)
    }
}
 
const apiKey = "YOUR_API_KEY"
 
type ResponseBody[D any] struct {
    Code    int    `json:"code"`
    Message string `json:"message"`
    Data    D      `json:"data,omitempty"`
}
 
// createTask creates an asynchronous task to generate AI fashion models
func createTask() (taskId string, err error) {
    data := map[string]any{
        "image":              "https://gcs-airbrush.mr.pixocial.com/f5e6df0c59ea56b1863893b6f9ea2a11.png",
        "maskType":           "clothes",
        "modelId":      "002",
        "backgroundTypes":    []string{"original", "transparent", "preset"},
        "presetBackgroundId": "035",
        "count":              1,
    }
 
    jsonData, err := json.Marshal(data)
    if err != nil {
        return "", err
    }
 
    request, err := http.NewRequest("POST", "https://open.vmake.ai/api/v3/image/ai-fashion-model/tasks", bytes.NewBuffer(jsonData))
    if err != nil {
        return "", err
    }
    request.Header.Set("X-Api-Key", apiKey)
    request.Header.Set("Content-Type", "application/json")
 
    client := &http.Client{}
    response, err := client.Do(request)
    if err != nil {
        return "", err
    }
    defer func() { err = response.Body.Close() }()
 
    if response.StatusCode != http.StatusOK {
        return "", fmt.Errorf("failed to create task: %s", response.Status)
    }
 
    bodyBytes, err := io.ReadAll(response.Body)
    if err != nil {
        return "", err
    }
 
    responseBody := new(ResponseBody[map[string]any])
    err = json.Unmarshal(bodyBytes, responseBody)
    if err != nil {
        return "", err
    }
 
    code := responseBody.Code
    message := responseBody.Message
    if code != 0 {
        return "", fmt.Errorf("failed to create task: %s", message)
    }
 
    taskId = responseBody.Data["taskId"].(string)
    return taskId, err
}
 
type TaskInfo struct {
    TaskId   string       `json:"taskId"`
    Status   string       `json:"status"`
    Message  string       `json:"message"`
    Progress int          `json:"progress"`
    Results  []TaskResult `json:"results,omitempty"`
}
 
type TaskResult struct {
    OriginalBackgroundImage    ResultImage `json:"originalBackgroundImage,omitempty"`
    PresetBackgroundImage      ResultImage `json:"presetBackgroundImage,omitempty"`
    TransparentBackgroundImage ResultImage `json:"transparentBackgroundImage,omitempty"`
}
 
type ResultImage struct {
    ImageWidth  int    `json:"imageWidth"`
    ImageHeight int    `json:"imageHeight"`
    ImageFormat string `json:"imageFormat"`
    FileSize    int    `json:"fileSize"`
    DownloadUrl string `json:"downloadUrl"`
}
 
func checkTask(taskId string) (taskInfo *TaskInfo, err error) {
    request, err := http.NewRequest("GET", fmt.Sprintf("https://open.vmake.ai/api/v3/image/ai-fashion-model/tasks/%s", taskId), nil)
    if err != nil {
        return nil, err
    }
    request.Header.Set("X-Api-Key", apiKey)
 
    client := &http.Client{}
    response, err := client.Do(request)
    if err != nil {
        return nil, err
    }
    defer func() { err = response.Body.Close() }()
 
    if response.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("failed to check task: %s", response.Status)
    }
 
    bodyBytes, err := io.ReadAll(response.Body)
    if err != nil {
        return nil, err
    }
    responseBody := new(ResponseBody[TaskInfo])
    err = json.Unmarshal(bodyBytes, responseBody)
    if err != nil {
        return nil, err
    }
 
    code := responseBody.Code
    message := responseBody.Message
    if code != 0 {
        return nil, fmt.Errorf("failed to create task: %s", message)
    }
 
    return &responseBody.Data, err
}