Liste de cibles

La base de données de reconnaissance cloud (CRS) stocke généralement un grand nombre d'images cibles. Pour aider les développeurs à localiser et gérer rapidement ces données, ce chapitre détaille la consultation, la recherche paginée et les informations détaillées des images cibles.

Gestion des collections d'images cibles via EasyAR Web

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

Collection d'images cibles

Chemin d'accès : Connectez-vous à EasyAR Web [Centre de développement] -> [Gestion de la reconnaissance cloud] -> Sélectionnez une galerie -> Cliquez sur [Gérer].

Dans cette interface, vous pouvez effectuer les actions suivantes :

Parcourir la liste : Consultez la collection d'images cibles affichée par pages.
Accès aux détails : Cliquez sur le bouton [Gérer] (bouton 1 sur l'image) pour accéder à la page de détails de cette image cible.
Recherche précise : Dans la zone de saisie 2, deux méthodes de recherche sont prises en charge :
- Recherche par nom : Si votre système nomme les images selon des règles (comme un ID d'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 recherche d'images similaires, vous pouvez ici consulter sa configuration détaillée.

Détails de l'image cible

En accédant à la page de détails, vous pouvez consulter toutes les propriétés 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.
Statut : Indique si l'image cible est activée ou désactivée.
Score de qualité : Évaluation quantitative des performances de reconnaissance et de suivi. Pour plus de détails, consultez Évaluation de la difficulté de reconnaissance des images cibles.
Meta personnalisée : Métadonnées associées à cette image cible (comme une URL de modèle, etc.)

detail

Consultation des collections d'images cibles via l'API

Pour les développeurs nécessitant une intégration dans leur propre backend, il est recommandé d'utiliser l'API REST pour la gestion.

Documentation de référence : API de liste des collections d'images cibles

Liste de préparation

Avant d'envoyer une requête, assurez-vous d'avoir les informations suivantes (détails dans Liste de préparation pour l'appel d'API) :

CRS AppId
Clé API / Secret API ou Token
URL du serveur : Adresse URL de gestion des images cibles, port 443 pour https

Veuillez remplacer les espaces réservés par les paramètres réels, et exécuter le script curl

Your-Server-side-URL → Hôte API réel
Your-Token → Jeton d'autorisation API 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écharger les exemples de code Java

Java Samples Download

Importer le projet avec maven

Step 1. Ouvrir le fichier de code concerné ListTargets.java

Step 2. Modifier les variables globales, remplacer les paramètres d'authentification de votre liste de préparation

CRS AppId
API Key / API Secret
TARGET_MGMT_URL → URL côté serveur

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écuter Main

Télécharger l'exemple de code NodeJS

NodeJS Samples Download

Étape 1. Configurer 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--"
}

Étape 2. Exécuter, spécifier le fichier de clés et l'URL côté serveur

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

Pour modifier la stratégie de pagination, passer les paramètres de pagination à getTargets

'pageSize': taille de la 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'interface du service cloud, l'exemple de code est 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écharger les exemples de code Php

PHP Samples Download

Étape 1. Ouvrir le code d'entrée demo.php

Étape 2. Modifier les variables globales et remplacer les paramètres d'authentification dans votre liste de préparation

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

Étape 3. Exécuter php demo.php

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

pip install requests
python list_targets.py

import time
import hashlib
import requests

# --- Configuration globale ---
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 : Trier les clés -> Concaténer -> Ajouter le 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"Requête GET {url}...")
    response = requests.get(url, params=params)
    print(f"Réponse : {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, 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éer un projet de 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 acceptés
- Niveau de compatibilité API : .NET Standard 2.1 (recommandé)

Étape 1： Préparer les fichiers image

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

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

Selon le nom du répertoire Assets
- Copier l'exemple de code ListImageTarget.cs ci-dessous

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

Dans l'éditeur Unity :
- Créer un GameObject vide
- Le nommer ListTarget
- Glisser-déposer le script ListImageTarget sur cet objet

Étape 3： Configurer les paramètres (Inspector)

Modifier dans le panneau Inspector :
- Api Url
- Authorization Token
- Crs App Id
- page size
- page num
Modifier uniquement ces champs pour exécuter, en renseignant les paramètres préparés dans la liste de préparation

Étape 4： Exécuter

Cliquer sur Play
Vérifier le résultat dans la Console :
- Succès : retourne un JSON (contenant targetId)
- Échec : informations HTTP / erreur

Sujets connexes :

Prochain sujet :