타겟 이미지 목록 조회

클라우드 인식(CRS) 데이터베이스에는 일반적으로 방대한 양의 타겟 이미지가 저장됩니다. 개발자가 이 데이터를 신속하게 찾고 관리할 수 있도록 이 장에서는 타겟 이미지 조회, 페이징 조회 및 상세 설명에 대해 자세히 소개합니다.

EasyAR Web을 통한 타겟 이미지 컬렉션 관리

시각적 인터페이스에서 시스템은 기본적으로 페이징 목록 형식으로 타겟 이미지를 표시하며, 마지막 수정 시간을 기준으로 역순으로 정렬됩니다(가장 최근에 수정된 항목이 맨 앞에 위치).

타겟 이미지 컬렉션

작업 경로: EasyAR Web [개발 센터] 로그인 -> [클라우드 인식 관리] -> 이미지 라이브러리 선택 -> [관리] 클릭.

이 인터페이스에서 다음 작업을 수행할 수 있습니다:

목록 탐색: 페이징으로 표시된 타겟 이미지 컬렉션 확인.
상세 정보 진입: 그림에서 버튼 1의 [관리] 를 클릭하면 해당 타겟 이미지의 상세 페이지로 이동.
정확한 검색: 입력 상자 2에서 다음 두 가지 검색 방법을 지원합니다:
- 이름으로 검색: 시스템이 규칙(예: 애플리케이션 내 ID)에 따라 이미지 이름을 지정한 경우 이름을 통해 빠르게 찾을 수 있음.
- TargetId로 검색: 예를 들어 유사 이미지 조회 API를 통해 특정 targetId를 획득한 후 여기에서 해당 상세 구성을 조회할 수 있음.

타겟 이미지 상세 설명

상세 페이지로 진입하면 타겟 이미지의 전체 속성을 확인할 수 있으며, 다음을 포함합니다:

그레이스케일 이미지
이미지 이름: 사용자 정의 타겟 이미지 식별자.
TargetId: 시스템에서 생성된 고유 ID.
상태: 현재 타겟 이미지가 활성화 또는 비활성화 상태인지 표시.
품질 점수: 인식 및 추적 성능에 대한 정량적 점수, 자세한 내용은 타겟 이미지 인식 난이도 등급 참조.
사용자 정의 메타: 이 타겟 이미지와 연결된 메타데이터(예: 모델 URL 등).

detail

API를 사용한 타겟 이미지 컬렉션 조회

자체 백엔드에 통합이 필요한 개발자의 경우 REST API를 사용하여 관리하는 것이 좋습니다.

참조 문서: 타겟 이미지 컬렉션 목록 API 인터페이스

준비 사항

요청을 시작하기 전에 다음 정보가 준비되었는지 확인하십시오(자세한 내용은 API 호출 준비 사항 참조):

CRS AppId
API Key / API Secret 또는 Token
Server-end URL: 타겟 이미지 관리 URL 주소, https는 443 포트 사용

대체할 자리 표시자를 실제 매개변수로 바꾸고 curl 스크립트를 실행하세요

Your-Server-side-URL → 실제 API Host
Your-Token → 실제 API Key Authorization Token
Your-CRS-AppId → 귀하의 appId

curl -X GET "https://<Your Server-side-URL>/targets/infos?appId=<Your-CRS-AppId>" \
  -H "Content-Type: application/json" \
  -H "Authorization: <Your-Token>"

Java 예제 코드 다운로드

Java Samples Download

Maven 방식으로 프로젝트 가져오기

Step 1. 관련 코드 파일 ListTargets.java 열기

Step 2. 전역 변수 수정, 준비한 목록의 인증 매개변수로 대체

CRS AppId
API Key / API Secret
TARGET_MGMT_URL → 서버 엔드 URL

public class ListTargets {

    private static final String TARGET_MGMT_URL = "http://cn1.crs.easyar.com:8888";
    private static final String CRS_APPID       = "--here is your CRS AppId--";
    private static final String API_KEY         = "--here is your API Key--";
    private static final String API_SECRET      = "--here is your API Secret--";

    public String list(Auth auth) throws IOException {
        OkHttpClient client = new OkHttpClient.Builder().build();
        JSONObject params = new JSONObject();
        Auth.signParam(params, auth.getAppId(), auth.getApiKey(), auth.getApiSecret());
        okhttp3.Request request = new okhttp3.Request.Builder()
                .url(auth.getCloudURL() + "/targets/infos?"+ Common.toParam(params))
                .get()
                .build();
        Response response = client.newCall(request).execute();
        return response.body().string();
    }
    public static void main(String[] args) throws IOException{
        Auth accessInfo  =  new Auth(CRS_APPID, API_KEY, API_SECRET, TARGET_MGMT_URL);
        System.out.println(new ListTargets().list(accessInfo));
    }

}

Step 3. Main 실행

NodeJS 샘플 코드 다운로드

NodeJS Samples Download

Step 1. 키 파일 keys.json 구성

CRS AppId
API Key / API Secret

{
  "appId": "--here is your appId for CRS App Instance for SDK 4--",
  "apiKey": "--here is your api key which is create from website and which has crs permission--",
  "apiSecret": "--here is your api secret which is create from website--"
}

Step 2. 실행 시 키 파일 및 서버 엔드 URL 지정

node bin/getTargets  -t <Server-end-URL> -c keys.json

페이지 정책 변경 시, getTargets 페이징 파라미터 전달

'pageSize': 페이지 크기
'pageNum': 페이지 번호

var argv = require('yargs')
    .usage('Usage: $0 [targetId] -t [host] -c [keys]')
    .demand(0)
    .default('t', 'http://localhost:8888').alias('t', 'host')
    .default('c', 'keys.json').alias('c', 'keys')
    .help('h').alias('h', 'help')
    .epilog('copyright 2015, sightp.com')
    .argv;

var fs = require('fs');
var host = argv.host;
var keys = JSON.parse(fs.readFileSync(argv.keys));
var farmer = require('../farmer')(host, keys.appKey, keys.appSecret);

farmer.getTargets({
  'pageSize': 5,
  'pageNum': 1,
})
.then(function(resp) {
    console.log(resp.result.targets);
})
.fail(function(err) {
    console.log(err);
});

getTargets는 클라우드 서비스 인터페이스 호출, 샘플 코드는 farmer.js에 있음

function getTargetsByPage(pageNum,pageSize) {
    return Q.promise(function(resolve, reject) {
        request.get(host + '/targets/infos?pageNum=' + pageNum + '&pageSize=' + pageSize)
        .query(auth.signParams(keypair, {
            "pageNum":pageNum,
            "pageSize":pageSize
        }))
        .end(done(resolve, reject));
    });
}

다운로드 Php 샘플 코드

PHP Samples Download

1단계. 입구 코드 demo.php 열기

2단계. 전역 변수 수정, 준비 목록의 인증 매개변수 대체

CRS AppId
API Key / API Secret
Server-end URL

<?php
include 'EasyARClientSdkCRS.php';
$apiKey = 'API Key';
$apiSecret = 'API Secret';
$crsAppId = 'CRS AppId'
$crsCloudUrl = 'https://cn1-crs.easyar.com';
$pageNum = 1;
$pageSize = 5;

$sdk = new EasyARClientSdkCRS($apiKey, $apiSecret, $crsAppId, $crsCloudUrl);

$rs = $sdk->targetsV3($pageNum, $pageSize);
if ($rs->statusCode == 0) {
    print_r($rs->result);
} else {
    print_r($rs);
}

3단계. 실행 php demo.php

새로운 관련 코드 파일 list_targets.py를 생성하고, 전역 변수를 수정한 다음 실행합니다

pip install requests
python list_targets.py

import time
import hashlib
import requests

# --- Global Configuration ---
API_KEY = "YOUR_API_KEY"
API_SECRET = "YOUR_API_SECRET"
APP_ID = "YOUR_APP_ID"
HOST = "https://crs-cn1.easyar.com"

def main():
    timestamp = str(int(time.time() * 1000))
    
    params = {
        'apiKey': API_KEY,
        'appId': APP_ID,
        'timestamp': timestamp
    }

    # Signature: Sort keys -> Concat -> Append Secret -> SHA256
    sorted_keys = sorted(params.keys())
    sign_str = "".join([f"{k}{params[k]}" for k in sorted_keys]) + API_SECRET
    signature = hashlib.sha256(sign_str.encode('utf-8')).hexdigest()

    url = f"{HOST}/targets/infos"
    params['signature'] = signature

    print(f"Requesting GET {url}...")
    response = requests.get(url, params=params)
    print(f"Response: {response.text}")

if __name__ == "__main__":
    main()

새 관련 코드 파일 생성 main.go, 전역 변수 수정 후 실행

go run main.go

main.go:

package main

import (
  "crypto/sha256"
  "fmt"
  "io"
  "net/http"
  "sort"
  "strconv"
  "time"
)

// --- Global Configuration ---
var (
  ApiKey    = "YOUR_API_KEY"
  ApiSecret = "YOUR_API_SECRET"
  AppId     = "YOUR_APP_ID"
  Host      = "https://crs-cn1.easyar.com"
)

func main() {
  ts := strconv.FormatInt(time.Now().UnixNano()/1e6, 10)
  params := map[string]string{
    "apiKey":    ApiKey,
    "appId":     AppId,
    "timestamp": ts,
  }

  keys := make([]string, 0, len(params))
  for k := range params { keys = append(keys, k) }
  sort.Strings(keys)

  builder := ""
  for _, k := range keys { builder += k + params[k] }
  builder += ApiSecret

  signature := fmt.Sprintf("%x", sha256.Sum256([]byte(builder)))

  url := fmt.Sprintf("%s/targets/infos?apiKey=%s&appId=%s&timestamp=%s&signature=%s", 
    Host, ApiKey, AppId, ts, signature)
  
  resp, _ := http.Get(url)
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Printf("Response: %s\n", string(body))
}

Cargo.toml에 reqwest, tokio, sha2, hex 의존성을 추가하세요.

cargo run을 실행하세요.

use sha2::{Sha256, Digest};
use std::collections::BTreeMap;
use std::time::{SystemTime, UNIX_EPOCH};

// --- Global Configuration ---
const API_KEY: &str = "YOUR_API_KEY";
const API_SECRET: &str = "YOUR_API_SECRET";
const APP_ID: &str = "YOUR_APP_ID";
const HOST: &str = "https://crs-cn1.easyar.com";

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let ts = SystemTime::now().duration_since(UNIX_EPOCH)?.as_millis().to_string();

    let mut params = BTreeMap::new();
    params.insert("apiKey", API_KEY);
    params.insert("appId", APP_ID);
    params.insert("timestamp", &ts);

    let mut sign_str = String::new();
    for (k, v) in &params {
        sign_str.push_str(k);
        sign_str.push_str(v);
    }
    sign_str.push_str(API_SECRET);
    
    let mut hasher = Sha256::new();
    hasher.update(sign_str.as_bytes());
    let signature = hex::encode(hasher.finalize());

    let url = format!("{}/targets/infos?apiKey={}&appId={}&timestamp={}&signature={}", 
                      HOST, API_KEY, APP_ID, ts, signature);
    
    let res = reqwest::get(url).await?;
    println!("Response: {}", res.text().await?);
    Ok(())
}

생성 .NET 콘솔 프로젝트

dotnet new console
dotnet run

using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Net.Http;

class Program {
    // --- Global Configuration ---
    static string API_KEY = "YOUR_API_KEY";
    static string API_SECRET = "YOUR_API_SECRET";
    static string APP_ID = "YOUR_APP_ID";
    static string HOST = "https://crs-cn1.easyar.com";

    static async System.Threading.Tasks.Task Main() {
        string timestamp = DateTimeOffset.Now.ToUnixTimeMilliseconds().ToString();

        var dict = new SortedDictionary<string, string> {
            { "apiKey", API_KEY },
            { "appId", APP_ID },
            { "timestamp", timestamp }
        };

        StringBuilder sb = new StringBuilder();
        foreach (var kv in dict) sb.Append(kv.Key).Append(kv.Value);
        sb.Append(API_SECRET);
        
        string signature = Sha256(sb.ToString());

        using var client = new HttpClient();
        string query = string.Join("&", dict.Select(x => $"{x.Key}={x.Value}")) + $"&signature={signature}";
        string url = $"{HOST}/targets/infos?{query}";
        
        var response = await client.GetAsync(url);
        Console.WriteLine($"Result: {await response.Content.ReadAsStringAsync()}");
    }

    static string Sha256(string str) {
        byte[] bytes = SHA256.HashData(Encoding.UTF8.GetBytes(str));
        return BitConverter.ToString(bytes).Replace("-", "").ToLower();
    }
}

실행 환경
- Unity 2020 LTS 이상 버전
- Scripting Backend: Mono 또는 IL2CPP 모두 가능
- API Compatibility Level: .NET Standard 2.1 (권장)

Step 1: 이미지 파일 준비

Unity 프로젝트에서 디렉토리 생성:

Assets/
└── Scripts/
     └── ListImageTarget.cs

Assets 디렉토리명에 따라
- 아래 예시 코드 ListImageTarget.cs 복사

using System.Collections;
using UnityEngine;
using UnityEngine.Networking;

public class ListImageTarget : MonoBehaviour
{
    [Header("Config")]
    public string apiBaseUrl = "https://Your-Server-end-URL";
    public string authorizationToken = "YOUR API KEY AUTH TOKEN"; 
    public string crsAppId = "CRS-AppId"; 
    public int pageSize = 5; 
    public int pageNum  = 1; 
    
    private void Start()
    {
        StartCoroutine(ListTarget());
    }

    private IEnumerator ListTarget()
    {
     
        string url =
            $"{apiBaseUrl}/targets/infos?appId={crsAppId}&pageSize={pageSize}&pageNum={pageNum}";

        UnityWebRequest request = UnityWebRequest.Get(url);
        request.downloadHandler = new DownloadHandlerBuffer();

        request.SetRequestHeader("Content-Type", "application/json");
        request.SetRequestHeader("Authorization", authorizationToken);

        yield return request.SendWebRequest();

        if (request.result == UnityWebRequest.Result.Success)
        {
            Debug.Log("List target success:");
            Debug.Log(request.downloadHandler.text);
        }
        else
        {
            Debug.LogError("List target failed:");
            Debug.LogError(request.error);
            Debug.LogError(request.downloadHandler.text);
        }
    }
}

Unity Editor에서:
- 빈 GameObject 생성
- 이름을 ListTarget으로 지정
- ListImageTarget 스크립트를 해당 객체에 드래그 앤 드롭

Step 3: 파라미터 설정 (Inspector)

Inspector 패널에서 수정:
- Api Url
- Authorization Token
- Crs App Id
- page size
- page num
이 항목들만 수정 후 실행 가능, 목록 준비 시 확보한 파라미터 입력

Step 4: 실행

Play 버튼 클릭
Console에서 결과 확인:
- 성공: JSON 반환 (targetId 포함)
- 실패: HTTP/오류 메시지

관련 주제:

다음 주제: