#Create a  task.
curl -k 'https://techsz.aoscdn.com/api/tasks/visual/segmentation' \
-H 'X-API-KEY: YOUR_API_KEY' \
-F 'sync=0' \
-F 'image_url=YOU_IMG_URL'

#Get the cutout result
#Polling requests using the following methods 1. The polling interval is set to 1 second, 2. The polling time does not exceed 30 seconds
curl -k 'https://techsz.aoscdn.com/api/tasks/visual/segmentation/{task_id}' \
-H 'X-API-KEY: YOUR_API_KEY' \

<?php
//Create a task
$curl = curl_init();
curl_setopt($curl, CURLOPT_URL, 'https://techsz.aoscdn.com/api/tasks/visual/segmentation');
curl_setopt($curl, CURLOPT_HTTPHEADER, array(
    "X-API-KEY: YOUR_API_KEY",
    "Content-Type: multipart/form-data",
));
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
curl_setopt($curl, CURLOPT_POST, true);
curl_setopt($curl, CURLOPT_SSL_VERIFYPEER, false);
curl_setopt($curl, CURLOPT_POSTFIELDS, array('sync' => 0, 'image_url' => "YOUR_IMG_URL"));
$response = curl_exec($curl);
$result = curl_errno($curl) ? curl_error($curl) : $response;
curl_close($curl);
$result = json_decode($result, true);
if ( !isset($result["status"]) || $result["status"] != 200 ) {
    // request failed, log the details
    var_dump($result);
    die("post request failed");
}
//  var_dump($result);
$task_id = $result["data"]["task_id"];


//get the task result
// 1、"The polling interval is set to 1 second."
//2 "The polling time is around 30 seconds."
for ($i = 1; $i <= 30; $i++) {
    if ($i != 1) {
        sleep(1);
    }
    $curl = curl_init();
    curl_setopt($curl, CURLOPT_URL, "https://techsz.aoscdn.com/api/tasks/visual/segmentation/".$task_id);
    curl_setopt($curl, CURLOPT_HTTPHEADER, array(
        "X-API-KEY: YOUR_API_KEY",

    ));
    curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($curl, CURLOPT_SSL_VERIFYPEER, false);
    $response = curl_exec($curl);
    $result = curl_errno($curl) ? curl_error($curl) : $response;
    curl_close($curl);
    var_dump($result);
    $result = json_decode($result, true);
    if ( !isset($result["status"]) || $result["status"] != 200 ) {
        // Task exception, logging the error.
        //You can choose to continue the loop with 'continue' or break the loop with 'break'
        var_dump($result);
        continue;
    }
    if ( $result["data"]["state"] == 1 ) {
        // task success
        var_dump($result["data"]["image"]);
        break;
    } else if ( $result["data"]["state"] < 0) {
        // request failed, log the details
        var_dump($result);
        break;
    } else {
        // Task processing
        if ($i == 30) {
            //Task processing, abnormal situation, seeking assistance from customer service of picwish
        }
    }
}

public static void main(String[] args) throws Exception {
    String taskId = createTask();
    String dataString = pollingTaskResult(taskId, 0);
    System.out.println(dataString);
}

private static String createTask() throws Exception {
    OkHttpClient okHttpClient = new OkHttpClient.Builder().build();
    RequestBody requestBody = new MultipartBody.Builder()
            .setType(MultipartBody.FORM)
            .addFormDataPart("image_url", "IMAGE_HTTP_URL")
            .addFormDataPart("sync", "0")
            .build();
    Request request = new Request.Builder()
            .url("https://techsz.aoscdn.com/api/tasks/visual/segmentation")
            .addHeader("X-API-KEY", "YOUR_API_KEY")
            .post(requestBody)
            .build();
    Response response = okHttpClient.newCall(request).execute();
    JSONObject jsonObject = new JSONObject(response.body().string());
    int status = jsonObject.optInt("status");
    if (status != 200) {
        throw new Exception(jsonObject.optString("message"));
    }
    return jsonObject.getJSONObject("data").optString("task_id");
}

private static String pollingTaskResult(String taskId, int pollingTime) throws Exception {
    if (pollingTime >= 30) throw new IllegalStateException("Polling result timeout.");
    OkHttpClient okHttpClient = new OkHttpClient.Builder().build();
    Request taskRequest = new Request.Builder()
            .url("https://techsz.aoscdn.com/api/tasks/visual/segmentation/" + taskId)
            .addHeader("X-API-KEY", "YOUR_API_KEY")
            .get()
            .build();
    Response taskResponse = okHttpClient.newCall(taskRequest).execute();
    JSONObject jsonObject = new JSONObject(taskResponse.body().string());
    int state = jsonObject.getJSONObject("data").optInt("state");
    if (state < 0) { // Cutout error.
        throw new Exception(jsonObject.optString("message"));
    }
    if (state == 1) { // Cutout success and get result.
        return jsonObject.getJSONObject("data").toString();
    }
    Thread.sleep(1000);
    return pollingTaskResult(taskId, ++pollingTime);
}

const request = require("request");
const fs = require("fs");
const path = require('path')

const API_KEY = "YOUR_API_KEY";

(async function main() {
  const taskId = await createTask()
  const result = await polling(() => getTaskResult(taskId))
  console.log(`result: ${JSON.stringify(result, null, 2)}`)
})()


const polling = async (fn, delay = 1 * 1000, timeout = 30 * 1000) => {
  if (!fn) {
    throw new Error('fn is required')
  }
  try {
    const result = await fn()
    return result
  } catch (error) {
    if (error && 'data' in error) {
      throw new Error(JSON.stringify(error, null, 2))
    }
    if (timeout <= 0) {
      throw new Error('timeout')
    }
    await new Promise((resolve) => {
      setTimeout(() => {
        resolve()
      }, delay)
    })
    return polling(fn, delay, timeout - delay)
  }
}

function createTask() {
  return new Promise((resolve, reject) => {
    request(
      {
        method: "POST",
        url: "https://techsz.aoscdn.com/api/tasks/visual/segmentation",
        headers: {
          "X-API-KEY": API_KEY,
        },
        formData: {
          image_url: 'IMAGE_HTTP_URL',
        },
        json: true
      },
      function (error, response) {
        if (response.body.data) {
          resolve(response.body.data.task_id)
        } else {
          reject(response.body)
        }
      }
    );
  })
}

function getTaskResult(taskId) {
   return new Promise((resolve, reject) => {
    request(
      {
        method: "GET",
        url: `https://techsz.aoscdn.com/api/tasks/visual/segmentation/${taskId}`,
        headers: {
          "X-API-KEY": API_KEY,
        },
        json: true
      },
      function (error, response) {
        if (!response.body.data) reject(response.body)
        const { progress, state } = response.body.data
        if (state < 0) reject(response.body)
        if (progress >= 100) resolve(response.body)
        reject(null)
      }
    );
   })
}

import time
import requests

API_KEY = 'YOUR_API_KEY'
IMAGE_NETWORK_URL = 'YOUR_IMAGE_NETWORK_URL'

def create_task():
    headers = {'X-API-KEY': API_KEY}
    data = {'sync': '0', 'image_url': IMAGE_NETWORK_URL}
    url = 'https://techsz.aoscdn.com/api/tasks/visual/segmentation'

    # Create a task
    response = requests.post(url, headers=headers, data=data)

    task_id = None
    response_json = response.json()
    if 'status' in response_json and response_json['status'] == 200:
        result_tag = 'failed'
        if 'data' in response_json:
            response_json_data = response_json['data']
            if 'task_id' in response_json_data:
                result_tag = 'successful'
                task_id = response_json_data['task_id']
        print(f'Result of created task({result_tag}): {response_json}')
    else:
        # request failed, log the details
        print(f'Error: Failed to create task,{response.text}')
    return task_id

# get the task result
# 1、"The polling interval is set to 1 second."
# 2、"The polling time is around 30 seconds."
def polling_task_result(task_id,time_out=30):
    headers = {'X-API-KEY': API_KEY}
    url = f'https://techsz.aoscdn.com/api/tasks/visual/segmentation/{task_id}'
    for i in range(time_out):
        if i != 0:
            time.sleep(1)
        response = requests.get(url, headers=headers)
        response_json = response.json()
        if 'status' in response_json and response_json['status'] == 200:
            if 'data' in response_json:
                response_json_data = response_json['data']
                if 'state' in response_json_data:
                    task_state = response_json_data['state']
                    if task_state == 1:
                        # task success
                        print(f'Result(successful): {response_json}')
                        break
                    elif task_state < 0:
                        # Task exception, logging the error.
                        # You can choose to continue the loop with 'continue' or break the loop with 'break'
                        print(f'Result(failed): {response_json}')
                        break
            print(f'Result(polling): {response_json}')
            if i == time_out-1:
                # Timeout, log the details, and search for support from the picwish service.
                print('Error: Timeout while polling.')
        else:
            # Task exception, logging the error.
            # You can choose to continue the loop with 'continue' or break the loop with 'break'
            print(f'Error: Failed to get the task\'s result,{response.text}')
            break

def main():
    task_id = create_task()
    if task_id is None:
        print('Error: Failed to create task,task id is None.')
        return
    polling_task_result(task_id)

if __name__ == "__main__":
    main()

using System;
using System.IO;
using System.Net.Http;
using System.Threading.Tasks;
using Newtonsoft.Json.Linq;

class Program 
{
    public static HttpClient client = new HttpClient();
    private static string API_KEY = "YOUR_API_KEY";
    private static string url = "https://techsz.aoscdn.com/api/tasks/visual/segmentation";
    private static string imageUrl = "IMAGE_HTTP_URL";

    static async Task Main(string[] args) 
    {
        try 
        {
            //Create a task.
            var taskId = await CreateTask();
            //Retrieve the results by looping thirty times.
            var result = await Polling(() => GetTaskResult(taskId), TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(30));
            Console.WriteLine($"result: {result.ToString()}");
        } 
        catch (Exception ex) 
        {
            //Request from user server failed. Please record the relevant error logs. 
            Console.WriteLine(ex.Message);
        }
        Console.ReadKey();
    }

    static async Task<string> CreateTask() 
    {
        var requestUrl = url;
        var multipartContent = new MultipartFormDataContent();
        multipartContent.Add(new StringContent(imageUrl), "image_url");
        client.DefaultRequestHeaders.Add("X-API-KEY", API_KEY);

        //User server initiates a request.
        var response = await client.PostAsync(requestUrl, multipartContent);
        var responseJson = JObject.Parse(await response.Content.ReadAsStringAsync());

        if (responseJson["data"] != null) 
        {
            return responseJson["data"]["task_id"].ToString();
        } 
        else 
        {
            //Request from user server failed. Please record the relevant error logs. 
            throw new Exception(responseJson.ToString());
        }
    }

    static async Task<JObject> GetTaskResult(string taskId) 
    {
        var requestUrl = $"{url}/{taskId}";
        var response = await client.GetAsync(requestUrl);
        var responseJson = JObject.Parse(await response.Content.ReadAsStringAsync());

        if (responseJson["data"]["image"] != null) 
        {
            return responseJson;
        } 
        else 
        {
            //Task processing
            throw new Exception(responseJson.ToString());
        }
    }
    //Polling requests using the following methods 
    //1. The polling interval is set to 1 second, 
    //2. The polling time does not exceed 30 seconds
    static async Task<JObject> Polling(Func<Task<JObject>> fn, TimeSpan delay, TimeSpan timeout) 
    {
        var endTime = DateTime.Now + timeout;
        while (DateTime.Now < endTime) 
        {
            try 
            {
                return await fn();
            } 
            catch 
            {
                //You can choose to continue the loop with "continue" or break the loop with "break".
                Console.WriteLine("polling...");
                //Wait for one second between each loop iteration.
                await Task.Delay(delay);
            }
        }

        //Timeout, log the details, and search for support from the picwish service.
        throw new Exception("timeout");
    }
}

import Alamofire
import Foundation

let API_KEY = "{YOUR_API_KEY}"
let BASE_URL = "https://techsz.aoscdn.com/api/tasks/visual/segmentation"

/// Begin task
func startEraser() {
    createTask { taskId in
        // Task succeed, get result. Polling requests using the following methods 1. The polling interval is 				 set to 1 second, 2. The polling time does not exceed 30 seconds
        let startTime = CFAbsoluteTimeGetCurrent()
        getTaskResult(taskId: taskId, taskStartTime: startTime) { result in
            print(result)
        }
    }
}

/// Create a task
func createTask(completion: @escaping (String) -> Void) {
    let url = URL(string: BASE_URL)!
    let headers: HTTPHeaders = [
        "X-API-KEY": API_KEY
    ]
        
    AF.upload(multipartFormData: { multipartFormData in
        if let imageUrl = "{YOUR_IMAGE_NETWORK_URL}".data(using: .utf8) {
            multipartFormData.append(imageUrl, withName: "image_url", fileName: "test.jpg", mimeType: "image/jpeg")
        }
        if let data = "1".data(using: .utf8) {
            multipartFormData.append(data, withName: "output_type")
        }
    }, to: url, method: .post, headers: headers).responseData { response in
        switch response.result {
        case .success(let value):
            if let json = try? JSONSerialization.jsonObject(with: value) as? [String: Any],
               let data = json["data"] as? [String: Any],
               let taskId = data["task_id"] as? String {
                completion(taskId)
            }
        case .failure(let error):
            print(error)
        }
    }
}

/// Get result
func getTaskResult(taskId: String,
                   taskStartTime: CFAbsoluteTime,
                   completion: @escaping ([String: Any]) -> Void) {
    let url = URL(string: "\(BASE_URL)/\(taskId)")!

    let headers: HTTPHeaders = [
        "X-API-KEY": API_KEY
    ]
    
    AF.request(url, method: .get, headers: headers).responseData { response in
        switch response.result {
            case .success(let value):
                print(response.debugDescription)
                guard let json = try? JSONSerialization.jsonObject(with: value) as? [String: Any],
                      let data = json["data"] as? [String: Any],
                      let state = data["state"] as? Int else {
                    print("parse failed")
                    return
                }
                // Task failed, log the details, and exit the loop
                if state < 0 {
                    print("state < 0")
                    return
                }
                // Task successful
                if state == 1 {
                    if let imageUrlStr = data["image"] as? String, let maskUrlStr = data["mask"] as? String {
                        completion(["image": imageUrlStr, "mask": maskUrlStr])
                        return
                    }
                }
          			// Retrieve the results by looping only thirty times
                let endTime = CFAbsoluteTimeGetCurrent()
                if endTime - taskStartTime < 30 {
                    // Wait for one second between each loop iteration
                    sleep(1)
                    getTaskResult(taskId: taskId, taskStartTime: taskStartTime, completion: completion)
                    return
                }
                // Timeout, log the details, and search for support from the picwish service
                print("timeout")
            case .failure(let error):
                // Request from user server failed. Please record the relevant error logs
                print(error)
        }
    }
}

package main

import (
	"bytes"
	"encoding/json"
	"errors"
	"fmt"
	"io/ioutil"
	"mime/multipart"
	"net/http"
	"time"
)

const (
	APIKey  = "YOUR_API_KEY"
	BaseURL = "https://techsz.aoscdn.com/api/tasks/visual/segmentation"
)

// taskResponse 
type taskResponse struct {
	Status  int    `json:"status"`
	Message string `json:"message"`
	Data    struct {
		TaskId string `json:"task_id"`
	} `json:"data"`
}

type VisualSegmentationResponse struct {
	Status  int    `json:"status"`
	Message string `json:"message"`
	Data    struct {
		TaskId      string  `json:"task_id"`
		Image       string  `json:"image"`
		Mask        string  `json:"mask"`
		MaskObj     string  `json:"mask_obj"`
		ImageObj    string  `json:"image_obj"`
		ReturnType  uint    `json:"return_type"`
		OutputType  uint    `json:"output_type"`
		Type        string  `json:"type"`
		ResultType  string  `json:"result_type"`
		TimeElapsed float64 `json:"time_elapsed"`
		Progress    uint    `json:"progress"`
		State       int     `json:"state"`
		ImageWidth  uint    `json:"image_width"`
		ImageHeight uint    `json:"image_height"`
	} `json:"data"`
}

func createTask() (string, error) {

	body := &bytes.Buffer{}
	writer := multipart.NewWriter(body)
	_ = writer.WriteField("image_url", "YOUR_IMG_URL")
	err := writer.Close()
	if err != nil {
		fmt.Println("Close error", err)
		return "", err
	}

	if err != nil {
		return "", err
	}

	req, err := http.NewRequest("POST", BaseURL, body)
	if err != nil {
		return "", err
	}
	req.Header.Set("Content-Type", writer.FormDataContentType())
	req.Header.Set("X-API-KEY", APIKey)

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

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

	var taskResp *taskResponse
	err = json.Unmarshal(respBody, &taskResp)
	if err != nil {
		fmt.Println("Error parsing JSON:", err)
		return "", err
	}
	if taskResp.Status != 200 {
		// Request from user server failed. Please record the relevant error logs. 
		var taskError error
		taskError = errors.New("error task id")
		return "", taskError
	}
	return taskResp.Data.TaskId, nil
}

func getTaskResult(taskId string) (*VisualSegmentationResponse, error) {
	req, err := http.NewRequest("GET", fmt.Sprintf("%s/%s", BaseURL, taskId), nil)
	if err != nil {
		return nil, err
	}
	req.Header.Set("X-API-KEY", APIKey)
	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()
	respBody, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		//  failed. Please record the relevant error logs. 
		return nil, err
	}
	var taskResp *VisualSegmentationResponse
	err = json.Unmarshal(respBody, &taskResp)
	if err != nil {
		fmt.Println("Error parsing JSON:", err)
		return nil, err
	}
	return taskResp, err
}

func main() {
	taskId, err := createTask()
	if err != nil {
		fmt.Println("Error creating task:", err)
		return
	}

	//Retrieve the results by looping thirty times.
	for i := 0; i < 30; i++ {
		if i != 0 {
			time.Sleep(time.Second) // Wait for one second between each loop iteration.
		}
		result, err := getTaskResult(taskId)
		if err != nil {
			fmt.Println("Error getting task result:", err, taskId)
			break
		}
		if result.Status != 200 {
			// Request from user server failed. Please record the relevant error logs. 
			var taskError error
			taskError = errors.New("error get task id")
			fmt.Println("result error ", result, taskError, taskId)
			//You can choose to continue polling or break, both options are acceptable.
			continue
		} else {
			if result.Data.State == 1 {
				//Complete the task and end the polling.
				fmt.Println("result", result)
				break
			} else if result.Data.State < 0 {
				// Task failed, log the details, and exit the loop.
				fmt.Println("result", result)
				break
			}
			// Other tasks in the 'state' are in progress, continue polling.
			if i == 29 {
				// Timeout, log the details, and search for support from the Zuo Tang customer service.
				fmt.Println("result", result, taskId)
			}
		}
	}

}