키포인트 감지

Roboflow에서 호스팅되는 객체 감지 모델에서 추론을 실행합니다.

호스팅된 API를 사용하여 Python으로 추론을 실행하려면 다음을 사용하세요. roboflow Python 패키지:

from roboflow import Roboflow
rf = Roboflow(api_key="API_KEY")
project = rf.workspace().project("MODEL_ENDPOINT")
model = project.version(VERSION).model

# 로컬 이미지에서 추론
print(model.predict("your_image.jpg", confidence=40, overlap=30).json())

# 예측 결과를 시각화
# model.predict("your_image.jpg", confidence=40, overlap=30).save("prediction.jpg")

# 다른 곳에 호스팅된 이미지에서 추론
# print(model.predict("URL_OF_YOUR_IMAGE", hosted=True, confidence=40, overlap=30).json())

Linux 또는 MacOS

로컬 파일의 JSON 예측을 가져오려면 YOUR_IMAGE.jpg:

base64 YOUR_IMAGE.jpg | curl -d @- \\
"https://serverless.roboflow.com/your-model/42?api_key=YOUR_KEY"

웹의 다른 곳에 호스팅된 이미지에 대해 URL을 통해 추론할 때는 (잊지 말고 URL 인코딩하세요):

curl -X POST "https://serverless.roboflow.com/your-model/42?\
api_key=YOUR_KEY&\
image=https%3A%2F%2Fi.imgur.com%2FPEEvqPN.png"

Windows

설치해야 합니다 Windows용 curl 및 Windows용 GNU base64 도구. 이를 수행하는 가장 쉬운 방법은 git for Windows 설치 프로그램 을 사용하는 것입니다. 이 설치 프로그램에는 curl 및 base64 설치 중 "명령 프롬프트에서 Git 및 선택적 Unix 도구 사용"을 선택하면 명령줄 도구도 포함됩니다.

그다음 위와 동일한 명령을 사용할 수 있습니다.

Node.js

이 예제에서는 POST 요청을 수행하기 위해 axios 를 사용하므로 먼저 npm install axios 를 설치하세요.

로컬 이미지에 대해 추론하기

const axios = require("axios");
const fs = require("fs");

const image = fs.readFileSync("YOUR_IMAGE.jpg", {
    encoding: "base64"
});

axios({
    method: "POST",
    url: "https://serverless.roboflow.com/your-model/42",
    params: {
        api_key: "YOUR_KEY"
    },
    data: image,
    headers: {
        "Content-Type": "application/x-www-form-urlencoded"
    }
})
.then(function(response) {
    console.log(response.data);
})
.catch(function(error) {
    console.log(error.message);
});

URL을 통해 다른 곳에 호스팅된 이미지에 대해 추론하기

const axios = require("axios");

axios({
    method: "POST",
    url: "https://serverless.roboflow.com/your-model/42",
    params: {
        api_key: "YOUR_KEY",
        image: "https://i.imgur.com/PEEvqPN.png"
    }
})
.then(function(response) {
    console.log(response.data);
})
.catch(function(error) {
    console.log(error.message);
});

Web

우리는 다음을 통해 실시간 온디바이스 추론을 사용할 수 있습니다 roboflow.js; 자세한 내용은 여기 문서를 참조하세요.

Swift

로컬 이미지에 대해 추론하기

import UIKit

// 이미지를 불러와 Base64로 변환
let image = UIImage(named: "your-image-path") // 업로드할 이미지의 경로 예: image.jpg
let imageData = image?.jpegData(compressionQuality: 1)
let fileContent = imageData?.base64EncodedString()
let postData = fileContent!.data(using: .utf8)

// API_KEY, Model, Model Version으로 Inference Server 요청 초기화
var request = URLRequest(url: URL(string: "https://serverless.roboflow.com/your-model/your-model-version?api_key=YOUR_APIKEY&name=YOUR_IMAGE.jpg")!,timeoutInterval: Double.infinity)
request.addValue("application/x-www-form-urlencoded", forHTTPHeaderField: "Content-Type")
request.httpMethod = "POST"
request.httpBody = postData

// POST 요청 실행
URLSession.shared.dataTask(with: request, completionHandler: { data, response, error in
    
    // 응답을 문자열로 파싱
    guard let data = data else {
        print(String(describing: error))
        return
    }
    
    // 응답 문자열을 Dictionary로 변환
    do {
        let dict = try JSONSerialization.jsonObject(with: data, options: []) as? [String: Any]
    } catch {
        print(error.localizedDescription)
    }
    
    // 문자열 응답 출력
    print(String(data: data, encoding: .utf8)!)
}).resume()

Objective C

Objective-C 스니펫을 요청하려면 여기를 클릭하세요.

Kotlin

로컬 이미지에 대해 추론하기

import java.io.*
import java.net.HttpURLConnection
import java.net.URL
import java.nio.charset.StandardCharsets
import java.util.*

fun main() {
    // 이미지 경로 가져오기
    val filePath = System.getProperty("user.dir") + System.getProperty("file.separator") + "YOUR_IMAGE.jpg"
    val file = File(filePath)

    // Base 64 인코딩
    val encodedFile: String
    val fileInputStreamReader = FileInputStream(file)
    val bytes = ByteArray(file.length().toInt())
    fileInputStreamReader.read(bytes)
    encodedFile = String(Base64.getEncoder().encode(bytes), StandardCharsets.US_ASCII)
    val API_KEY = "" // API Key
    val MODEL_ENDPOINT = "dataset/v" // Model endpoint 설정 (Dataset URL에서 확인)

    // URL 구성
    val uploadURL ="https://serverless.roboflow.com/" + MODEL_ENDPOINT + "?api_key=" + API_KEY + "&name=YOUR_IMAGE.jpg";

    // Http 요청
    var connection: HttpURLConnection? = null
    try {
        // URL에 대한 연결 구성
        val url = URL(uploadURL)
        connection = url.openConnection() as HttpURLConnection
        connection.requestMethod = "POST"
        connection.setRequestProperty("Content-Type",
                "application/x-www-form-urlencoded")
        connection.setRequestProperty("Content-Length",
                Integer.toString(encodedFile.toByteArray().size))
        connection.setRequestProperty("Content-Language", "en-US")
        connection.useCaches = false
        connection.doOutput = true

        // 요청 전송
        val wr = DataOutputStream(
                connection.outputStream)
        wr.writeBytes(encodedFile)
        wr.close()

        // 응답 가져오기
        val stream = connection.inputStream
        val reader = BufferedReader(InputStreamReader(stream))
        var line: String?
        while (reader.readLine().also { line = it } != null) {
            println(line)
        }
        reader.close()
    } catch (e: Exception) {
        e.printStackTrace()
    } finally {
        connection?.disconnect()
    }
}
main()

URL을 통해 다른 곳에 호스팅된 이미지에 대해 추론하기

import java.io.BufferedReader
import java.io.DataOutputStream
import java.io.InputStreamReader
import java.net.HttpURLConnection
import java.net.URL
import java.net.URLEncoder

fun main() {
    val imageURL = "https://i.imgur.com/PEEvqPN.png" // Image URL로 교체
    val API_KEY = "" // API Key
    val MODEL_ENDPOINT = "dataset/v" // Model endpoint 설정

    // 업로드 URL
    val uploadURL = "https://serverless.roboflow.com/" + MODEL_ENDPOINT + "?api_key=" + API_KEY + "&image=" + URLEncoder.encode(imageURL, "utf-8");

    // Http 요청
    var connection: HttpURLConnection? = null
    try {
        // URL에 대한 연결 구성
        val url = URL(uploadURL)
        connection = url.openConnection() as HttpURLConnection
        connection.requestMethod = "POST"
        connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded")
        connection.setRequestProperty("Content-Length", Integer.toString(uploadURL.toByteArray().size))
        connection.setRequestProperty("Content-Language", "en-US")
        connection.useCaches = false
        connection.doOutput = true

        // 요청 전송
        val wr = DataOutputStream(connection.outputStream)
        wr.writeBytes(uploadURL)
        wr.close()

        // 응답 가져오기
        val stream = URL(uploadURL).openStream()
        val reader = BufferedReader(InputStreamReader(stream))
        var line: String?
        while (reader.readLine().also { line = it } != null) {
            println(line)
        }
        reader.close()
    } catch (e: Exception) {
        e.printStackTrace()
    } finally {
        connection?.disconnect()
    }
}

main()

Java

로컬 이미지에 대해 추론하기

import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.util.Base64;

public class InferenceLocal {
    public static void main(String[] args) throws IOException {
        // 이미지 경로 가져오기
        String filePath = System.getProperty("user.dir") + System.getProperty("file.separator") + "YOUR_IMAGE.jpg";
        File file = new File(filePath);

        // Base 64 인코딩
        String encodedFile;
        FileInputStream fileInputStreamReader = new FileInputStream(file);
        byte[] bytes = new byte[(int) file.length()];
        fileInputStreamReader.read(bytes);
        encodedFile = new String(Base64.getEncoder().encode(bytes), StandardCharsets.US_ASCII);

        String API_KEY = ""; // API Key
        String MODEL_ENDPOINT = "dataset/v"; // Model endpoint

        // URL 구성
        String uploadURL = "https://serverless.roboflow.com/" + MODEL_ENDPOINT + "?api_key=" + API_KEY
                + "&name=YOUR_IMAGE.jpg";

        // Http 요청
        HttpURLConnection connection = null;
        try {
            // URL에 대한 연결 구성
            URL url = new URL(uploadURL);
            connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("POST");
            connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");

            connection.setRequestProperty("Content-Length", Integer.toString(encodedFile.getBytes().length));
            connection.setRequestProperty("Content-Language", "en-US");
            connection.setUseCaches(false);
            connection.setDoOutput(true);

            // 요청 전송
            DataOutputStream wr = new DataOutputStream(connection.getOutputStream());
            wr.writeBytes(encodedFile);
            wr.close();

            // 응답 가져오기
            InputStream stream = connection.getInputStream();
            BufferedReader reader = new BufferedReader(new InputStreamReader(stream));
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
            reader.close();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (connection != null) {
                connection.disconnect();
            }
        }

    }

}

URL을 통해 다른 곳에 호스팅된 이미지에 대해 추론하기

import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;

public class InferenceHosted {
    public static void main(String[] args) {
        String imageURL = "https://i.imgur.com/PEEvqPN.png"; // Image URL로 교체
        String API_KEY = ""; // API Key
        String MODEL_ENDPOINT = "dataset/v"; // Model endpoint

        // 업로드 URL
        String uploadURL = "https://serverless.roboflow.com/" + MODEL_ENDPOINT + "?api_key=" + API_KEY + "&image="
                + URLEncoder.encode(imageURL, StandardCharsets.UTF_8);

        // Http 요청
        HttpURLConnection connection = null;
        try {
            // URL에 대한 연결 구성
            URL url = new URL(uploadURL);
            connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("POST");
            connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");

            connection.setRequestProperty("Content-Length", Integer.toString(uploadURL.getBytes().length));
            connection.setRequestProperty("Content-Language", "en-US");
            connection.setUseCaches(false);
            connection.setDoOutput(true);

            // 요청 전송
            DataOutputStream wr = new DataOutputStream(connection.getOutputStream());
            wr.writeBytes(uploadURL);
            wr.close();

            // 응답 가져오기
            InputStream stream = new URL(uploadURL).openStream();
            BufferedReader reader = new BufferedReader(new InputStreamReader(stream));
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
            reader.close();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (connection != null) {
                connection.disconnect();
            }
        }
    }
}

Gemfile

Gemfile

source "https://rubygems.org"

gem "httparty", "~> 0.18.1"
gem "base64", "~> 0.1.0"
gem "cgi", "~> 0.2.1"

Gemfile.lock

Gemfile.lock

GEM
  remote: https://rubygems.org/
  specs:
    base64 (0.1.0)
    cgi (0.2.1)
    httparty (0.18.1)
      mime-types (~> 3.0)
      multi_xml (>= 0.5.2)
    mime-types (3.3.1)
      mime-types-data (~> 3.2015)
    mime-types-data (3.2021.0225)
    multi_xml (0.6.0)

PLATFORMS
  x64-mingw32
  x86_64-linux

DEPENDENCIES
  base64 (~> 0.1.0)
  cgi (~> 0.2.1)
  httparty (~> 0.18.1)

BUNDLED WITH
   2.2.15

로컬 이미지에 대해 추론하기

require 'base64'
require 'httparty'

encoded = Base64.encode64(File.open("YOUR_IMAGE.jpg", "rb").read)
model_endpoint = "dataset/v" # Model endpoint 설정
api_key = "" # API KEY 입력

params = "?api_key=" + api_key
+ "&name=YOUR_IMAGE.jpg"

response = HTTParty.post(
    "https://serverless.roboflow.com/" + model_endpoint + params,
    body: encoded, 
    headers: {
    'Content-Type' => 'application/x-www-form-urlencoded',
    'charset' => 'utf-8'
  })

  puts response

URL을 통해 다른 곳에 호스팅된 이미지에 대해 추론하기

require 'httparty'
require 'cgi'

model_endpoint = "dataset/v" # Model endpoint 설정
api_key = "" # API KEY 입력
img_url = "https://i.imgur.com/PEEvqPN.png" # URL 구성

img_url = CGI::escape(img_url)

params =  "?api_key=" + api_key + "&image=" + img_url

response = HTTParty.post(
    "https://serverless.roboflow.com/" + model_endpoint + params,
    headers: {
    'Content-Type' => 'application/x-www-form-urlencoded',
    'charset' => 'utf-8'
  })

puts response

로컬 이미지에 대해 추론하기

<?php

// 이미지를 Base 64로 인코딩
$data = base64_encode(file_get_contents("YOUR_IMAGE.jpg"));

$api_key = ""; // API Key 설정
$model_endpoint = "dataset/v"; // Model endpoint 설정 (Dataset URL에서 확인)

// Http 요청 URL
$url = "https://serverless.roboflow.com/" . $model_endpoint
. "?api_key=" . $api_key
. "&name=YOUR_IMAGE.jpg";

// Http 요청 설정 + 전송
$options = array(
  'http' => array (
    'header' => "Content-type: application/x-www-form-urlencoded\r\n",
    'method'  => 'POST',
    'content' => $data
  ));

$context  = stream_context_create($options);
$result = file_get_contents($url, false, $context);
echo $result;
?>

URL을 통해 다른 곳에 호스팅된 이미지에 대해 추론하기

<?php

$api_key = ""; // API Key 설정
$model_endpoint = "dataset/v"; // Model endpoint 설정 (Dataset URL에서 확인)
$img_url = "https://i.imgur.com/PEEvqPN.png";

// Http 요청 URL
$url =  "https://serverless.roboflow.com/" . $model_endpoint
. "?api_key=" . $api_key
. "&image=" . urlencode($img_url);

// Http 요청 설정 + 전송
$options = array(
  'http' => array (
    'header' => "Content-type: application/x-www-form-urlencoded\r\n",
    'method'  => 'POST'
  ));

$context  = stream_context_create($options);
$result = file_get_contents($url, false, $context);
echo $result;
?>

로컬 이미지에 대해 추론하기

package main

import (
    "bufio"
    "encoding/base64"
    "fmt"
    "io/ioutil"
    "os"
	"net/http"
	"strings"
)

func main() {
	api_key := ""  // API Key
	model_endpoint := "dataset/v" // Model endpoint 설정

    // 디스크에서 파일 열기.
    f, _ := os.Open("YOUR_IMAGE.jpg")

    // 전체 JPG를 바이트 슬라이스로 읽기.
    reader := bufio.NewReader(f)
    content, _ := ioutil.ReadAll(reader)

    // base64로 인코딩.
    data := base64.StdEncoding.EncodeToString(content)
	uploadURL := "https://serverless.roboflow.com/" + model_endpoint + "?api_key=" + api_key + "&name=YOUR_IMAGE.jpg"

	req, _ := http.NewRequest("POST", uploadURL, strings.NewReader(data))
    req.Header.Set("Accept", "application/json")

    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()

   	bytes, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(bytes))

}

URL을 통해 다른 곳에 호스팅된 이미지에 대해 추론하기

package main

import (
    "fmt"
	"net/http"
	"net/url"
  "io/ioutil"
)

func main() {
	api_key := ""  // API Key
	model_endpoint := "dataset/v" // Model endpoint 설정
	img_url := "https://i.ibb.co/jzr27x0/YOUR-IMAGE.jpg"


	uploadURL := "https://serverless.roboflow.com/" + model_endpoint + "?api_key=" + api_key + "&image=" + url.QueryEscape(img_url)

	req, _ := http.NewRequest("POST", uploadURL, nil)
    req.Header.Set("Accept", "application/json")

    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()

   	bytes, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(bytes))


}

로컬 이미지에 대해 추론하기

using System;
using System.IO;
using System.Net;
using System.Text;

namespace InferenceLocal
{
    class InferenceLocal
    {

        static void Main(string[] args)
        {
            byte[] imageArray = System.IO.File.ReadAllBytes(@"YOUR_IMAGE.jpg");
            string encoded = Convert.ToBase64String(imageArray);
            byte[] data = Encoding.ASCII.GetBytes(encoded);
            string API_KEY = ""; // API 키
            string MODEL_ENDPOINT = "dataset/v"; // 모델 엔드포인트 설정

            // URL 구성
            string uploadURL =
                    "https://serverless.roboflow.com/" + MODEL_ENDPOINT + "?api_key=" + API_KEY
                + "&name=YOUR_IMAGE.jpg";

            // 서비스 요청 구성
            ServicePointManager.Expect100Continue = true;
            ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;

            // 요청 구성
            WebRequest request = WebRequest.Create(uploadURL);
            request.Method = "POST";
            request.ContentType = "application/x-www-form-urlencoded";
            request.ContentLength = data.Length;

            // 데이터 쓰기
            using (Stream stream = request.GetRequestStream())
            {
                stream.Write(data, 0, data.Length);
            }

            // 응답 가져오기
            string responseContent = null;
            using (WebResponse response = request.GetResponse())
            {
                using (Stream stream = response.GetResponseStream())
                {
                    using (StreamReader sr99 = new StreamReader(stream))
                    {
                        responseContent = sr99.ReadToEnd();
                    }
                }
            }

            Console.WriteLine(responseContent);

        }
    }
}

URL을 통해 다른 곳에 호스팅된 이미지에 대해 추론하기

using System;
using System.IO;
using System.Net;
using System.Web;

namespace InferenceHosted
{
    class InferenceHosted
    {
        static void Main(string[] args)
        {
            string API_KEY = ""; // API 키
            string imageURL = "https://i.ibb.co/jzr27x0/YOUR-IMAGE.jpg";
            string MODEL_ENDPOINT = "dataset/v"; // 모델 엔드포인트 설정

            // URL 구성
            string uploadURL =
                    "https://serverless.roboflow.com/" + MODEL_ENDPOINT
                    + "?api_key=" + API_KEY
                    + "&image=" + HttpUtility.UrlEncode(imageURL);

            // 서비스 포인트 구성
            ServicePointManager.Expect100Continue = true;
            ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;

            // Http 요청 구성
            WebRequest request = WebRequest.Create(uploadURL);
            request.Method = "POST";
            request.ContentType = "application/x-www-form-urlencoded";
            request.ContentLength = 0;

            // 응답 가져오기
            string responseContent = null;
            using (WebResponse response = request.GetResponse())
            {
                using (Stream stream = response.GetResponseStream())
                {
                    using (StreamReader sr99 = new StreamReader(stream))
                    {
                        responseContent = sr99.ReadToEnd();
                    }
                }
            }

            Console.WriteLine(responseContent);

        }
    }
}

응답 객체 형식

호스팅된 API 추론 경로는 JSON 예측 배열을 포함한 객체입니다. 각 예측에는 다음 속성이 있습니다:

x = 감지된 객체의 가로 중심점
y = 감지된 객체의 세로 중심점
width = 경계 상자의 너비
height = 경계 상자의 높이
class = 감지된 객체의 클래스 레이블
confidence = 감지된 객체의 레이블과 위치 좌표가 올바르다는 모델의 신뢰도
키포인트 = 키포인트 예측 배열
- x = 키포인트의 가로 중심(이미지 왼쪽 상단 모서리를 기준으로)
- y = 키포인트의 세로 중심(이미지 왼쪽 상단 모서리를 기준으로)
- class_name = 키포인트 이름
- class_id = 키포인트의 ID, skeleton에 매핑됩니다 정점 version record에서 정점 색상과 skeleton edge를 매핑하기 위해, Project Version 보기
- confidence = 키포인트가 올바른 위치에 있고 보이는지(가려지거나 삭제되지 않았는지)에 대한 신뢰도

REST API에서 가져온 예시 응답 객체는 다음과 같습니다:

{
    "predictions": [
        {
            "x": 189.5,
            "y": 100,
            "width": 163,
            "height": 186,
            "class": "helmet",
            "confidence": 0.544,
            "keypoints": [
                {
                    "x": 189, 
                    "y": 20,
                    "class_name": "상단",
                    "class_id": 0,
                    "confidence": 0.91
                },
                {
                    "x": 188, 
                    "y": 180,
                    "class_name": "하단",
                    "class_id": 1,
                    "confidence": 0.93
                }
            ]
        }
    ],
    "image": {
        "width": 2048,
        "height": 1371
    }
}

해당 image 속성에는 추론에 사용하기 위해 전송된 이미지의 높이와 너비가 포함됩니다. 경계 상자 계산에 이러한 값을 사용해야 할 수도 있습니다.

Inference API 매개변수

Inference API 사용하기

POST https://serverless.roboflow.com/:datasetSlug/:versionNumber

base64 인코딩된 이미지를 모델 엔드포인트에 직접 POST할 수 있습니다. 또는 URL을 image 쿼리 문자열의 매개변수로 전달할 수 있습니다. 이미지가 이미 다른 곳에 호스팅되어 있다면.

경로 매개변수

이름

유형

설명

datasetSlug

string

데이터셋 이름의 URL 안전 버전입니다. 메인 프로젝트 보기의 URL을 보거나, 모델을 학습한 후 데이터셋 버전의 학습 결과 섹션에 있는 "Get curl command" 버튼을 클릭하면 웹 UI에서 찾을 수 있습니다.

버전

number

데이터셋 버전을 식별하는 버전 번호입니다

쿼리 매개변수

이름

유형

설명

image

string

추가할 이미지의 URL입니다. 이미지가 다른 곳에 호스팅되어 있는 경우 사용하세요. (요청 본문에 base64로 인코딩된 이미지를 POST하지 않는 경우 필수입니다.) 참고: URL 인코딩을 잊지 마세요.

클래스

string

예측을 특정 클래스의 예측으로만 제한합니다. 쉼표로 구분된 문자열로 제공하세요. 예시: dog,cat 기본값: 없음(모든 클래스 표시)

겹침

number

같은 클래스의 경계 상자 예측이 하나의 상자로 결합되기 전에 겹칠 수 있는 최대 비율(0-100 척도)입니다. 기본값: 30

confidence

number

반환되는 예측에 대한 임계값으로, 0-100 척도입니다. 숫자가 낮을수록 더 많은 예측이 반환됩니다. 숫자가 높을수록 더 적은 고신뢰 예측이 반환됩니다. 기본값: 40

스트로크

number

예측 주위에 표시되는 경계 상자의 너비(픽셀 단위)입니다(다음 경우에만 영향을 줍니다 형식 가 image). 기본값: 1

레이블

boolean

예측에 텍스트 레이블을 표시할지 여부입니다(다음 경우에만 영향을 줍니다 형식 가 image). 기본값: false

형식

string

json - JSON 예측 배열을 반환합니다. (response format 탭을 참조하세요). image - 주석이 달린 예측 결과가 포함된 이미지를 binary blob으로 반환하며, Content-Type 의 image/jpeg. image_and_json - base64의 visualization 필드를 포함한 JSON 예측 배열을 반환합니다. 기본값: json

api_key

string

워크스페이스 API 설정 페이지에서 얻은 API 키

요청 본문

이름

유형

설명

string

base64로 인코딩된 이미지입니다. (쿼리 매개변수에 이미지 URL을 전달하지 않는 경우 필수입니다.)

{
    "predictions": [{
        "x": 234.0,
        "y": 363.5,
        "width": 160,
        "height": 197,
        "class": "손",
        "confidence": 0.943
    }, {
        "x": 504.5,
        "y": 363.0,
        "width": 215,
        "height": 172,
        "class": "손",
        "confidence": 0.917
    }, {
        "x": 1112.5,
        "y": 691.0,
        "width": 139,
        "height": 52,
        "class": "손",
        "confidence": 0.87
    }, {
        "x": 78.5,
        "y": 700.0,
        "width": 139,
        "height": 34,
        "class": "손",
        "confidence": 0.404
    }]
}

마지막 업데이트 1개월 전

도움이 되었나요?