이미지 관리

REST API와 Python SDK를 통해 개별 이미지를 업로드, 주석 처리, 검사, 태그 지정, 삭제하세요.

소개

Roboflow를 사용하면 REST API와 Python SDK를 통해 프로젝트 내 개별 이미지를 업로드, 주석 추가, 검사, 태그 지정 및 삭제할 수 있습니다. 이 대량 데이터세트 업로드 흐름이 제공하는 것보다 더 세밀한 제어가 필요할 때 이러한 작업을 사용하세요. 예를 들어, 스트림에서 한 번에 한 이미지씩 업로드하거나, 나중에 주석을 추가하거나, 이미지 메타데이터와 태그를 업데이트할 수 있습니다. 한 번에 전체 라벨링된 데이터세트를 대량으로 가져오려면 다음을 참조하세요 데이터세트 업로드.

HTTP API

REST API는 이미지와 주석 업로드, 이미지 세부 정보 가져오기, 이미지 삭제, 이미지 태그 및 메타데이터 관리에 대한 이미지별 작업을 제공합니다.

이미지 업로드

REST API를 사용해 로컬 파일이나 URL에서 이미지를 업로드합니다.

매개변수

API에서 허용하는 쿼리 문자열 매개변수:

api_key: https://app.roboflow.com/account/api에서 확인하세요 image: [선택 사항] 추가할 이미지의 URL입니다. 이미지가 다른 곳에 호스팅되어 있는 경우 사용하세요(요청 본문에 base64로 인코딩된 이미지를 POST하지 않는 경우 필요). name: [선택 사항] 이미지의 파일 이름입니다(설정하지 않으면 추론을 시도합니다). batch: [선택 사항] 이 이름으로 이미지를 배치로 묶습니다 tag: [선택 사항] 여러 번 지정할 수 있습니다. 업로드된 이미지에 태그를 추가합니다. split: [선택 사항] 다음 중 하나: train, valid, test(기본값은 train). sequence_number: [선택 사항] 데이터세트에서 이미지 순서를 유지하고 싶다면, 업로드하는 이미지에 증가하는 시퀀스 번호를 부여할 수 있습니다. sequence_size: [선택 사항] 시퀀스 내 전체 이미지 수입니다. 설정하지 않으면 기본값은 100,000입니다. inference_id: [선택 사항] roboflow 추론 감지에서 반환된 추론 ID입니다. 이 inference_id를 사용하면 Model Monitoring(엔터프라이즈 기능)에서 이미지와 roboflow 감지를 연관시킬 수 있습니다.

Linux 또는 macOS

다음 이름의 로컬 파일 업로드 YOUR_IMAGE.jpg multipart/form-data를 사용하여(권장):

curl -F name=YOUR_IMAGE.jpg -F split=train \
-F file=@YOUR_IMAGE.jpg \
"https://api.roboflow.com/dataset/YOUR_DATASET_NAME/upload?\
api_key=$ROBOFLOW_API_KEY"

또는, base64로 인코딩된 이미지를 업로드:

base64 -i YOUR_IMAGE.jpg | curl -d @- \
"https://api.roboflow.com/dataset/your-dataset/upload?\
api_key=$ROBOFLOW_API_KEY&\
name=YOUR_IMAGE.jpg&\
split=train&\
batch=BATCH_NAME_FOR_UPLOAD"

웹에 호스팅된 이미지를 URL을 통해 업로드할 때는(다음을 잊지 마세요 URL 인코딩하세요):

curl -X POST "https://api.roboflow.com/dataset/your-dataset/upload?\
api_key=$ROBOFLOW_API_KEY&\
image=https%3A%2F%2Fi.imgur.com%2FPEEvqPN.png&\
name=201-956-1246.png&\
split=train"

Windows

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

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

Node.js

이 예제에서는 axios 와 form-data 이 POST 요청을 수행하기 위해 사용하므로 먼저 다음을 실행하세요 npm install axios form-data 의존성을 설치하려면.

multipart/form-data를 사용하여 업로드(권장):

const axios = require("axios");
const fs = require("fs");
const FormData = require('form-data');

const formData = new FormData();
formData.append("name", "YOUR_IMAGE.jpg");
formData.append("file", fs.createReadStream("YOUR_IMAGE.jpg"));
formData.append("split", "train");

axios({
    method: "POST",
    url: "https://api.roboflow.com/dataset/YOUR_DATASET_NAME/upload",
    params: {
        api_key: "YOUR_API_KEY"
    },
    data: formData,
    headers: formData.getHeaders()
})
.then(function(response) {
    console.log(response.data);
})
.catch(function(error) {
    console.log(error.message);
});

base64로 인코딩된 이미지를 사용하여 업로드(권장하지 않음):

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

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

axios({
    method: "POST",
    url: "https://api.roboflow.com/dataset/YOUR_DATASET_NAME/upload",
    params: {
        api_key: "YOUR_API_KEY",
        name: "YOUR_IMAGE.jpg",
        split: "train",
        batch: "YOUR_BATCH_NAME"
    },
    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://api.roboflow.com/dataset/YOUR_DATASET_NAME/upload",
    params: {
        api_key: "YOUR_API_KEY",
        image: "https://i.imgur.com/PEEvqPN.png",
        name: "201-956-1246.png",
        split: "train"
    }
})
.then(function(response) {
    console.log(response.data);
})
.catch(function(error) {
    console.log(error.message);
});

웹

현재 베타 테스트 중입니다 roboflow.js, 브라우저 기반 JavaScript 라이브러리로, 그중에는 비밀 API 키를 웹에 노출하지 않고 안전하게 클라이언트 측 업로드를 수행하는 기능도 포함됩니다. 조기 액세스를 원하시면 문의하세요.

Swift

iOS 개발을 위한 Swift를 사용한 업로드 예제 스니펫입니다.

// 제공된 프로젝트에 이미지를 업로드
public func uploadImage(image: UIImage, project: String, completion: @escaping (UploadResult)->()) {
    let encodedImage = convertImageToBase64String(img: image)
    let uuid = UUID().uuidString
    
    var request = URLRequest(url: URL(string: "https://api.roboflow.com/dataset/\(project)/upload?api_key=\(apiKey!)&name=\(uuid)&split=train")!,timeoutInterval: Double.infinity)

    request.addValue("application/x-www-form-urlencoded", forHTTPHeaderField: "Content-Type")
    request.httpMethod = "POST"
    request.httpBody = encodedImage.toData()
    
    URLSession.shared.dataTask(with: request) { data, response, error in
        // 응답을 문자열로 파싱
        guard let data = data else {
            completion(UploadResult.Error)
            return
        }

        do {
            let dict = try JSONSerialization.jsonObject(with: data, options: []) as? [String: Any]
            let duplicate = dict!["duplicate"] as? Bool
            
            if duplicate ==  true {
                completion(UploadResult.Duplicate)
            } else {
                let success = dict!["success"] as! Bool
                if success == true {
                    completion(UploadResult.Success)
                } else {
                    completion(UploadResult.Error)
                }
            }

        } catch {
            print(error.localizedDescription)
            completion(UploadResult.Error)
        }
    }.resume()
}

func convertImageToBase64String (img: UIImage) -> String {
    return img.jpegData(compressionQuality: 1)?.base64EncodedString() ?? ""
}

}

Kotlin

base64로 인코딩된 이미지를 사용하여 업로드:

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)

    // Base64 인코딩
    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 키
    val DATASET_NAME = "your-dataset" // 데이터세트 이름 설정(데이터세트 URL에서 찾을 수 있음)

    // URL 구성
    val uploadURL = "https://api.roboflow.com/dataset/" +
            DATASET_NAME + "/upload" +
            "?api_key=" + API_KEY +
            "&name=YOUR_IMAGE.jpg" +
            "&split=train"

    // 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
import java.nio.charset.StandardCharsets

fun main() {
    val imageURL = "https://i.imgur.com/PEEvqPN.png" // 이미지 URL로 바꾸세요
    val API_KEY = "" // API 키
    val DATASET_NAME = "your-dataset" // 데이터세트 이름 설정(데이터세트 URL에서 찾을 수 있음)

    // 업로드 URL
    val uploadURL = ("https://api.roboflow.com/dataset/" + DATASET_NAME + "/upload" + "?api_key=" + API_KEY
            + "&name=YOUR_IMAGE.jpg" + "&split=train" + "&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 = 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()

Android(자바)

base64로 인코딩된 이미지를 사용하여 업로드:

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

public class UploadLocal {
    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);

        // Base64 인코딩
        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 키
        String DATASET_NAME = "your-dataset"; // 데이터세트 이름 설정(데이터세트 URL에서 찾을 수 있음)

        // URL 구성
        String uploadURL =
                "https://api.roboflow.com/dataset/"+
                        DATASET_NAME + "/upload" +
                        "?api_key=" + API_KEY +
                        "&name=YOUR_IMAGE.jpg" +
                        "&split=train";

        // 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 UploadHosted {
    public static void main(String[] args) {
        String imageURL = "https://i.imgur.com/PEEvqPN.png"; // 이미지 URL로 바꾸세요
        String API_KEY = ""; // API 키
        String DATASET_NAME = "your-dataset"; // 데이터세트 이름 설정(데이터세트 URL에서 찾을 수 있음)

        // 업로드 URL
        String uploadURL = "https://api.roboflow.com/dataset/" + DATASET_NAME + "/upload" + "?api_key=" + API_KEY
                + "&name=YOUR_IMAGE.jpg" + "&split=train" + "&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 = 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();
            }
        }
    }
}

Ruby

Gemfile

source "https://rubygems.org"

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

Gemfile.lock

GEM
  원격: https://rubygems.org/
  사양:
    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)

플랫폼
  x64-mingw32
  x86_64-linux

의존성
  base64 (~> 0.1.0)
  cgi (~> 0.2.1)
  httparty (~> 0.18.1)

다음 버전과 함께 번들됨
   2.2.15

base64로 인코딩된 이미지를 사용하여 업로드:

require 'base64'
require 'httparty'

encoded = Base64.encode64(File.open("YOUR_IMAGE.jpg", "rb").read)
dataset_name = "your-dataset" # 데이터세트 이름 설정(데이터세트 URL에서 찾을 수 있음)
api_key = "" # 여기에 API 키

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

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

  puts response

URL을 통해 다른 곳에 호스팅된 이미지 추가:

require 'httparty'
require 'cgi'

dataset_name = "your-dataset" # 데이터세트 이름 설정(데이터세트 URL에서 찾을 수 있음)
api_key = "" # 여기에 API 키
img_url = "https://i.imgur.com/PEEvqPN.png" # URL 구성

img_url = CGI::escape(img_url)

params = "?api_key=" + api_key + 
"&name=YOUR_IMAGE.jpg" + 
"&split=train" +
"&image=" + img_url

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

puts response

PHP

base64로 인코딩된 이미지를 사용하여 업로드:

<?php

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

$api_key = ""; // API 키 설정
$dataset_name = "your-dataset"; // 데이터셋 이름 설정 (데이터셋 URL에서 확인)

// HTTP 요청용 URL
$url = "https://api.roboflow.com/dataset/" 
. $dataset_name .  "/upload" 
.  "?api_key="  .  $api_key  
.  "&name=YOUR_IMAGE.jpg" 
. "&split=train";

// 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 키 설정
$dataset_name = "your-dataset"; // 데이터셋 이름 설정 (데이터셋 URL에서 확인)
$img_url = "https://i.imgur.com/PEEvqPN.png";

// HTTP 요청용 URL
$url = "https://api.roboflow.com/dataset/" 
. $dataset_name .  "/upload" 
.  "?api_key="  .  $api_key  
.  "&name=YOUR_IMAGE.jpg" 
. "&split=train" 
. "&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;
?>

Go

base64로 인코딩된 이미지를 사용하여 업로드:

package main

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

func main() {
	api_key := ""  // API 키
	dataset_name := "Your-Dataset" // 데이터셋 이름 설정 (데이터셋 URL에서 확인)

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

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

    // Base64로 인코딩.
    data := base64.StdEncoding.EncodeToString(content)
	uploadURL := "https://api.roboflow.com/dataset/"+ dataset_name + "/upload"+
    "?api_key=" + api_key +
    "&name=YOUR_IMAGE.jpg" +
    "&split=train"

	res, _ := http.Post(uploadURL, "application/x-www-form-urlencoded", strings.NewReader(data))
    body, _ := ioutil.ReadAll(res.Body)
	fmt.Println(string(body))

}

URL을 통해 다른 곳에 호스팅된 이미지 추가:

package main

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

)

func main() {
	api_key := ""  // API 키
	dataset_name := "Your-Dataset" // 데이터셋 이름 설정 (데이터셋 URL에서 확인)
	img_url := "https://i.imgur.com/PEEvqPN.png"


	uploadURL := "https://api.roboflow.com/dataset/"+ dataset_name + "/upload"+
    "?api_key=" + api_key +
    "&name=YOUR_IMAGE.jpg" +
    "&split=train" + "&image=" + url.QueryEscape(img_url)

	res, _ := http.Post(uploadURL, "application/x-www-form-urlencoded", nil)
	body, _ := ioutil.ReadAll(res.Body)
    fmt.Println(string(body))


}

.NET

base64로 인코딩된 이미지를 사용하여 업로드:

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

namespace UploadLocal
{
    class UploadLocal
    {

        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 DATASET_NAME = "your-dataset"; // 데이터셋 이름 설정 (데이터셋 URL에서 확인)

            // URL 구성
            string uploadURL =
                    "https://api.roboflow.com/dataset/" +
                            DATASET_NAME + "/upload" +
                            "?api_key=" + API_KEY +
                            "&name=YOUR_IMAGE.jpg" +
                            "&split=train";

            // 서비스 요청 구성
            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 UploadHosted
{
    class UploadHosted
    {
        static void Main(string[] args)
        {
            string API_KEY = ""; // API 키
            string DATASET_NAME = "your-dataset"; // 데이터셋 이름 설정 (데이터셋 URL에서 확인)
            string imageURL = "https://i.imgur.com/PEEvqPN.png";
            imageURL = HttpUtility.UrlEncode(imageURL);

            // URL 구성
            string uploadURL =
                    "https://api.roboflow.com/dataset/" +
                            DATASET_NAME + "/upload" +
                            "?api_key=" + API_KEY +
                            "&name=YOUR_IMAGE.jpg" +
                            "&split=train" +
                            "&image=" + 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);

        }
    }
}

Roboflow에서 업로드된 이미지 보기

API를 통해 업로드된 이미지는 Annotate 탭의 unassigned 열에서 uploaded via API.

로 표시되어 있는 batch upload 매개변수를 지정하면 이미지가 여전히 Annotate 탭에서 찾을 수 있지만, uploaded via API batch로 이동하는 대신 지정한 batch에서 찾을 수 있습니다.

주석 업로드

이미지와 함께 기존 주석이 이미 있다면 Roboflow에 업로드할 수 있습니다.

이는 다음 중 어떤 것과도 작동합니다. 지원되는 주석 형식 업로드된 이미지의 파일 이름을 참조하는 주석 파일을 사용하는 형식입니다.

알고 계셨나요? API를 사용하지 않고도 앱의 업로드 페이지에서 이미지와 함께 주석 파일을 드래그 앤 드롭(또는 선택)할 수 있습니다.

추가 prediction=true 를 사용하면 주석을 정답이 아닌 모델 예측으로 저장할 수 있습니다. 이미지가 아직 업로드 배치에 있고 주석 작업에는 아직 없으면 Roboflow가 해당 배치를 Review 작업으로 이동합니다.

추가 predictionRouting=unassigned 를 사용하면 그 이동을 건너뜁니다. 주석은 여전히 저장되고 이미지는 여전히 주석 처리됨으로 표시되지만, 해당 배치에 그대로 남아 unassigned 상태로 유지됩니다. 사용 predictionRouting=review 를 사용하면 기본 라우팅을 요청할 수 있습니다. 두 값 모두 prediction=true가 필요하며, 다음과 함께 사용할 수 없습니다. jobName.

예시

이미지에 VOC XML 주석 을 첨부하기 abc123 을 your-dataset 라는 데이터셋에서 YOUR_ANNOTATION.xml:

cat YOUR_ANNOTATION.xml | curl -d @- \
"https://api.roboflow.com/dataset/your-dataset/annotate/abc123?\
api_key=YOUR_KEY&\
name=YOUR_ANNOTATION.xml"

이미지에 Darknet TXT 주석 을 첨부하기 abc123 을 your-dataset 라는 데이터셋에서 YOUR_ANNOTATION.txt json labelmap을 사용하는 경우입니다. 이 경우에는 주석 파일의 내용을 단순히 본문으로 보내는 대신 json에 담아 보내야 합니다.

#!/bin/bash
# 주석을 json 호환 문자열로 저장
txt_content=$(cat YOUR_ANNOTATION.txt | sed 's/\\/\\\\/g; s/"/\\"/g; s/$/\\n/' | tr -d '\n')
# 주석 파일과 label map [0=flower, 1=leaf]으로 json 문자열 생성
json_payload="{ \"annotationFile\": \"$txt_content\", \"labelmap\":{\"0\":\"flower\", \"1\":\"leaf\"} }"

# 주석 + labelmap 업로드
echo $json_payload | curl -H "Content-Type: application/json" -d @- \
"https://api.roboflow.com/dataset/cultura-pepino-dark/annotate/abc123?\
api_key=YOUR_KEY&\
name=YOUR_ANNOTATION.txt"

이 예제에서는 axios 이 POST 요청을 수행하기 위해 사용하므로 먼저 다음을 실행하세요 npm install axios 의존성을 설치하려면.

로컬 이미지 업로드하기

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

const filename = "YOUR_ANNOTATION.xml";
const annotation = fs.readFileSync(filename, "utf-8");

axios({
    method: "POST",
    url: "https://api.roboflow.com/dataset/your-dataset/annotate/abc123",
    params: {
        api_key: "YOUR_KEY",
        name: filename
    },
    data: annotation,
    headers: {
        "Content-Type": "text/plain"
    }
})
.then(function(response) {
    console.log(response.data);
})
.catch(function(error) {
    console.log(error.message);
});

Kotlin

base64로 인코딩된 이미지를 사용하여 업로드:

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)

    // Base64 인코딩
    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 키
    val DATASET_NAME = "your-dataset" // 데이터세트 이름 설정(데이터세트 URL에서 찾을 수 있음)

    // URL 구성
    val uploadURL = "https://api.roboflow.com/dataset/" +
            DATASET_NAME + "/upload" +
            "?api_key=" + API_KEY +
            "&name=YOUR_IMAGE.jpg" +
            "&split=train"

    // 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
import java.nio.charset.StandardCharsets

fun main() {
    val imageURL = "https://i.imgur.com/PEEvqPN.png" // 이미지 URL로 바꾸세요
    val API_KEY = "" // API 키
    val DATASET_NAME = "your-dataset" // 데이터세트 이름 설정(데이터세트 URL에서 찾을 수 있음)

    // 업로드 URL
    val uploadURL = ("https://api.roboflow.com/dataset/" + DATASET_NAME + "/upload" + "?api_key=" + API_KEY
            + "&name=YOUR_IMAGE.jpg" + "&split=train" + "&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 = 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()

Android(자바)

base64로 인코딩된 이미지를 사용하여 업로드:

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

public class UploadLocal {
    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);

        // Base64 인코딩
        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 키
        String DATASET_NAME = "your-dataset"; // 데이터세트 이름 설정(데이터세트 URL에서 찾을 수 있음)

        // URL 구성
        String uploadURL =
                "https://api.roboflow.com/dataset/"+
                        DATASET_NAME + "/upload" +
                        "?api_key=" + API_KEY +
                        "&name=YOUR_IMAGE.jpg" +
                        "&split=train";

        // 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 UploadHosted {
    public static void main(String[] args) {
        String imageURL = "https://i.imgur.com/PEEvqPN.png"; // 이미지 URL로 바꾸세요
        String API_KEY = ""; // API 키
        String DATASET_NAME = "your-dataset"; // 데이터세트 이름 설정(데이터세트 URL에서 찾을 수 있음)

        // 업로드 URL
        String uploadURL = "https://api.roboflow.com/dataset/" + DATASET_NAME + "/upload" + "?api_key=" + API_KEY
                + "&name=YOUR_IMAGE.jpg" + "&split=train" + "&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 = 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();
            }
        }
    }
}

이미지에 대한 세부 정보 가져오기

REST API를 사용하여 특정 이미지의 세부 정보를 가져올 수 있습니다.

특정 이미지의 세부 정보를 가져오려면 다음 API 엔드포인트로 GET 요청을 보내세요.

https://api.roboflow.com/:workspace/:project/images/:image_id

다음은 이미지의 세부 정보를 가져오기 위한 API 요청 예시입니다.

curl -X GET "https://api.roboflow.com/my-workspace/my-project-name/images/image-id?api_key=$ROBOFLOW_API_KEY" \
-H 'Content-Type: application/json'

이 엔드포인트는 이미지에 대한 다음 정보를 포함하는 JSON 객체를 반환합니다:

{
    "image":
        "id": string,
        "name": string,
        "annotation": {
            "key": string,
            "width": number,
            "height": number,
            "boxes": Array<{
                "label": string,
                "x": number,
                "y": number,
                "width": number,
                "height": number
            }>
        },
        "labels": string[],
        "split": string,
        "tags": string[],
        "created": number,
        "urls": {
            "original": string,
            "thumb": string,
            "annotation": string
        },
        "embedding": number[]
    }
}

데이터셋에서 이미지 삭제하기

REST API를 사용하여 데이터셋에서 이미지를 제거할 수 있습니다.

데이터셋에서 이미지를 제거하려면 다음 API 엔드포인트로 DELETE 요청을 보내고, 엔드포인트에 이미지 ID를 전달하세요.

https://api.roboflow.com/:workspace/:project/images

다음은 이미지를 제거하기 위한 API 요청 예시입니다.

curl "https://api.roboflow.com/my-workspace/my-project/images?api_key=$ROBOFLOW_API_KEY" \
  -X DELETE \
  -H "Content-Type: application/json" \
  -d '{"images": ["1", "2"]}'

이 엔드포인트는 작업이 성공하면 204 상태를 반환합니다.

이미지 태그 나열, 추가, 제거

REST API를 사용하여 Roboflow의 특정 이미지에 태그를 지정할 수 있습니다.

Roboflow에 호스팅된 이미지의 태그를 추가, 제거, 설정하려면 다음 API 엔드포인트로 POST 요청을 보내세요. 이미지 이름과 연결된 이미지 ID를 검색하려면 Search API를 사용하세요:

https://api.roboflow.com/:workspace/:project/images/:image_id/tags

다음은 API 요청 예시입니다(태그를 "add", "remove", 또는 "set"할 수 있음):

curl -X POST "https://api.roboflow.com/my-workspace/my-project-name/images/image-id/tags?api_key=$ROBOFLOW_API_KEY" \
-H 'Content-Type: application/json' \
--data \
'{
    "operation": "add",
    "tags": "image_tag_test"
}'

이 엔드포인트는 POST 본문에서 다음 값을 स्वीकार합니다:

{
     // // 옵션은 ["add", "remove", "set"]
     "operation": string,
     
     // 태그 문자열 배열
     "tags": string[],
     
}

API는 Roboflow에서 지정한 이미지에 태그를 추가합니다(POST 요청에 이미지 이름이 아니라 이미지 ID를 전달해야 한다는 점을 기억하세요).

이미지 메타데이터 및 태그 업데이트

REST API를 사용하여 워크스페이스의 이미지에 사용자 정의 메타데이터와 태그를 쓸 수 있습니다. 두 개의 엔드포인트가 있습니다. 하나는 단일 이미지를 동기적으로 업데이트하는 용도이고, 다른 하나는 최대 1,000개의 이미지를 배치로 업데이트하는 용도입니다.

두 엔드포인트 모두 image:tag 범위가 있는 API 키가 필요합니다.

요청 본문

두 엔드포인트는 동일한 필드를 받습니다(배치 엔드포인트는 이를 updates 배열에 담음):

- imageId (string) - 본문의 배치 업데이트에 필요하며, 단일 업데이트에서는 경로에서 추론됨
- metadata (object) - 이미지의 사용자 메타데이터에 설정할 키-값 쌍.
- removeMetadata (string[]) - 이미지에서 삭제할 메타데이터 키.
- addTags (string[]) - 이미지에 추가할 태그.
- removeTags (string[]) - 이미지에서 제거할 태그.

이 필드들 중 적어도 하나는 포함해야 합니다. 같은 요청에서 동일한 메타데이터 키나 태그를 설정하고 제거할 수는 없습니다. 다음으로 시작하는 메타데이터 키는 _rf_internal_ 는 Roboflow 전용으로 예약되어 있으며 거부됩니다.

단일 이미지

단일 이미지의 메타데이터와 태그를 업데이트합니다.

POST https://api.roboflow.com/:workspace/images/:image/metadata?api_key=YOUR_API_KEY

예시

curl -X POST "https://api.roboflow.com/my-workspace/images/abc123/metadata?api_key=$ROBOFLOW_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "metadata": { "camera": "front", "blur_score": 0.8 },
    "addTags": ["reviewed"]
  }'

응답

{
    "success": true
}

배치 업데이트

여러 이미지의 메타데이터와 태그를 비동기적으로 업데이트합니다. 요청당 최대 1,000개의 이미지를 허용합니다.

POST https://api.roboflow.com/:workspace/images/metadata?api_key=YOUR_API_KEY

예시

curl -X POST "https://api.roboflow.com/my-workspace/images/metadata?api_key=$ROBOFLOW_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "updates": [
      {
        "imageId": "abc123",
        "metadata": { "camera": "front" },
        "addTags": ["reviewed"]
      },
      {
        "imageId": "def456",
        "removeTags": ["needs-review"]
      }
    ]
  }'

응답

반환 202 작업 ID와 함께 반환됩니다. 진행 상황을 확인하려면 작업 URL을 폴링하세요.

{
    "taskId": "task-id-here",
    "url": "https://api.roboflow.com/my-workspace/asynctasks/task-id-here"
}

참조 Async Tasks 에서 작업 상태를 폴링하는 방법을 확인하세요.

오류

- 400 - 빈 본문, 잘못된 필드 유형, 또는 충돌하는 필드(예: metadata와 removeMetadata에 같은 키가 있는 경우).
- 404 - 워크스페이스에서 이미지를 찾을 수 없음(단일 이미지 엔드포인트만 해당).

Python SDK

프로젝트 는 대량 upload_dataset 흐름을 보완하는 이미지별 작업을 제공합니다. 단일 이미지 업로드를 더 세밀하게 제어해야 하거나, 나중에 주석을 첨부하고 싶거나, 스트림에서 이미지를 하나씩 수집할 때 이 기능을 사용하세요.

이미지 업로드(선택적 주석 포함)

Project.upload() 는 고수준의 "알아서 잘 처리하는" 도우미입니다. 단일 이미지와 일치하는 선택적 주석 파일 하나를 받아, 한 번의 호출로 둘 다 프로젝트에 전송합니다.

import roboflow

rf = roboflow.Roboflow(api_key="YOUR_API_KEY")
project = rf.workspace().project("my-detector")

result = project.upload(
    image_path="./photo.jpg",
    annotation_path="./photo.xml",   # 선택 사항; 일치하는 VOC / COCO / 등 주석
    split="train",                    # train | valid | test
    batch_name="ingest-2026-05",     # 선택 사항; 웹 UI에서 업로드를 그룹화
    tag_names=["camera-A", "indoor"], # 선택 사항; 태그 적용
    is_prediction=False,              # 검토를 기다리는 모델 생성 주석이면 True로 설정
    num_retry_uploads=2,              # 일시적인 업로드 실패 시 재시도
)
print(result)

single_upload() 는 동일한 인수를 받는 더 낮은 수준의 변형으로, 이미지와 (제공된 경우) 주석에 대한 원시 API 응답을 반환합니다.

이미지만 업로드

project.upload_image(
    image_path="./photo.jpg",
    split="train",
    batch_name="ingest-2026-05",
    tag_names=["camera-A"],
)

주석이 아직 없고 이미지가 바로 라벨러로 넘어갈 때 유용합니다.

업로드 전에 이미지 검증

check_valid_image() 는 API를 호출하지 않고 Roboflow의 로컬 크기 / 형식 검사를 실행합니다:

if project.check_valid_image("./photo.jpg"):
    project.upload_image("./photo.jpg")

기존 이미지에 주석 첨부

save_annotation() 이미지에 대해 이미 프로젝트에 있는 주석을 게시합니다. 다른 곳에서 생성한 레이블을 추가하거나 모델 예측을 정답으로 승격할 때 유용합니다.

project.save_annotation(
    image_id="<image-id>",
    annotation_path="./photo.xml",
    is_prediction=False,
    annotation_overwrite=True,    # 기존 주석을 모두 대체
)

전달하세요 annotation_labelmap="./labelmap.yaml" 주석 형식에 필요하다면 클래스 인덱스를 클래스 이름으로 매핑하기 위해.

다음을 사용해 저장하면 is_prediction=True 이미지를 검토 작업으로 이동할 수 있습니다. 참조: 예측이 저장되는 위치.

이미지의 메타데이터 가져오기

info = project.image("<image-id>")
print(info["name"], info["split"], info["annotations"])

이미지 메타데이터, 현재 분할, 주석 상태를 반환합니다.

이미지 삭제

프로젝트 수준(이 프로젝트에 속한 이미지만 삭제):

project.delete_images(["<image-id-1>", "<image-id-2>"])

워크스페이스 수준(참조하는 프로젝트와 상관없이 이미지를 삭제합니다 - 주의해서 사용하세요):

workspace.delete_images(["<image-id-1>", "<image-id-2>"])

v1.3.6+ 업로드에 대한 참고

현재 roboflow 1.3.6, SDK는 Pillow를 통해 다시 인코딩하는 대신 원본 이미지 바이트를 업로드합니다. 이렇게 하면 웹 업로더와의 일관성이 복원되고 Roboflow 서버가 SHA-256으로 업로드를 중복 제거할 수 있습니다. 같은 이미지를 두 번 업로드하는 자동화(예: 여러 배치에 추가하기 위해)가 있다면, 두 번째 업로드는 추가 저장소 크레딧을 소모하지 않고 성공하는 것을 보게 될 것입니다.

CLI

CLI를 사용해 이미지 한 장과 선택적 주석, 태그 또는 메타데이터를 업로드합니다.

roboflow image upload photo.jpg -p PROJECT_ID

옵션

플래그

설명

-p, --project

프로젝트 ID(필수)

-a, --annotation

주석 파일 경로

-m, --labelmap

레이블 맵 파일 경로

-s, --split

데이터셋 분할: 학습, 검증, 또는 테스트. 기본값은 학습.

-t, --tag

쉼표로 구분된 태그 이름

-M, --metadata

JSON 문자열 형식의 메타데이터

--is-prediction

업로드를 예측으로 표시합니다

-b, --batch

배치 이름

예시

주석이 포함된 이미지를 업로드합니다:

roboflow image upload photo.jpg -p my-project -a annotation.xml -s valid

태그와 메타데이터가 포함된 이미지를 업로드합니다:

roboflow image upload photo.jpg -p my-project -t "outdoor,daytime" -M '{"camera_id":"cam001"}'

디렉터리 또는 .zip 아카이브를 업로드하려면 참조하세요 데이터세트 업로드.

이전데이터세트 클래스 설정 다음프로젝트 폴더

마지막 업데이트 2일 전

도움이 되었나요?