Requête de liste d'images cibles

Les bases de données Cloud Recognition (CRS) stockent généralement un très grand nombre d'images cibles. Pour aider les développeurs à localiser et gérer rapidement ces données, ce chapitre décrit l'affichage des images cibles, les requêtes paginées et les détails.

Gérer les collections d'images cibles avec EasyAR Web

Dans l'interface visuelle, le système affiche par défaut les images cibles sous forme de liste paginée et les trie en ordre inverse de dernière modification (les modifications les plus récentes en premier).

Collection d'images cibles

Chemin d'opération: connectez-vous à EasyAR Web [Developer Center] -> [Cloud Recognition Management] -> sélectionnez gallery -> cliquez sur [Manage].

Dans cette interface, vous pouvez effectuer les opérations suivantes:

Parcourir la liste: afficher la collection d'images cibles paginée.
Entrée des détails: cliquez sur [Manage] du bouton 1 dans l'image pour accéder à la page de détails de cette image cible.
Recherche précise: dans la zone de saisie 2, les deux méthodes de recherche suivantes sont prises en charge:
- Recherche par nom: si votre système nomme les images selon des règles, par exemple des IDs internes à l'application, vous pouvez les localiser rapidement par nom.
- Recherche par TargetId: par exemple, après avoir obtenu un targetId spécifique via l'API de requête d'images similaires, vous pouvez consulter ici sa configuration détaillée.

Détails de l'image cible

Après avoir accédé à la page de détails, vous pouvez consulter les propriétés complètes de l'image cible, notamment:

Image en niveaux de gris
Nom de l'image: identifiant personnalisé de l'image cible.
TargetId: ID unique généré par le système.
État: indique si l'image cible actuelle est active ou désactivée.
Score de qualité: score quantitatif des performances de reconnaissance et de tracking. Pour plus de détails, consultez évaluation de la difficulté de reconnaissance des images cibles.
Custom Meta: métadonnées associées à cette image cible, comme l'URL du modèle.

detail

Interroger les collections d'images cibles avec API

Pour les développeurs qui doivent intégrer leur propre backend, la gestion avec REST API est recommandée.

Document de référence: API de liste de collection d'images cibles

Liste de préparation

Avant d'envoyer une requête, assurez-vous que les informations suivantes sont prêtes. Pour plus de détails, consultez liste de préparation des appels API:

CRS AppId
API Key / API Secret ou Token
Server-end URL: adresse URL de gestion des images cibles, https utilise le port 443

Remplacez les espaces réservés par les paramètres réels, puis exécutez le script curl

Your-Server-side-URL → API Host réel
Your-Token → API Key Authorization Token réel
Your-CRS-AppId → votre appId

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

Téléchargez le code d'exemple Java

Java Samples Download

Importez le projet avec Maven

Step 1. Ouvrez le fichier de code associé ListTargets.java.

Step 2. Modifiez les variables globales et remplacez-les par les paramètres d'authentification de la liste que vous avez préparée.

CRS AppId
API Key / API Secret
TARGET_MGMT_URL → Server-end 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. Exécutez Main

Téléchargez le sample code NodeJS.

NodeJS Samples Download

Step 1. Configurez le fichier de clés 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. Exécutez en spécifiant le fichier de clés et le Server-end URL.

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

Si vous devez modifier la stratégie de pagination, transmettez les paramètres de pagination getTargets.

'pageSize': taille de page
'pageNum': numéro de page

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 appelle l'API du service cloud. Le sample code se trouve dans 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));
    });
}

Téléchargez le code d'exemple PHP.

PHP Samples Download

Step 1. Ouvrez le code d'entrée demo.php.

Step 2. Modifiez les variables globales et remplacez-les par les paramètres d'authentification de votre liste préparée.

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);
}

Step 3. Exécutez php demo.php.

Creez le fichier de code associe list_targets.py, modifiez les variables globales, puis executez

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()

Créez le fichier de code associé main.go, modifiez les variables globales, puis exécutez

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))
}

Ajoutez les dépendances reqwest, tokio, sha2 et hex dans Cargo.toml.

Exécutez 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(())
}

Créez un projet console .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();
    }
}

Environnement d'exécution
- Unity 2020 LTS ou version ultérieure
- Scripting Backend : Mono ou IL2CPP sont tous deux possibles
- API Compatibility Level : .NET Standard 2.1 (recommandé)

Step 1: Préparer le fichier image

Créez un répertoire dans le projet Unity :

Assets/
└── Scripts/
     └── 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);
        }
    }
}

Selon le nom du répertoire Assets
- Copiez le code d'exemple suivant ListImageTarget.cs
Dans Unity Editor :
- Créez un GameObject vide
- Nommez-le ListTarget
- Faites glisser le script sur cet objet

Step 3: Configurer les paramètres (Inspector)

Modifiez dans le panneau Inspector :
- Api Url
- Authorization Token
- Crs App Id
- page size
- page num
Il suffit de modifier ces éléments pour exécuter, en renseignant les paramètres préparés dans la checklist de préparation

Step 4: Exécuter

Cliquez sur Play
Consultez le résultat dans Console :
- Succès : retourne JSON (avec targetId)
- Échec : HTTP / informations d'erreur

Rubriques connexes:

Rubrique suivante: