Consulta de lista de imágenes objetivo

Las bases de datos de Cloud Recognition (CRS) suelen almacenar grandes cantidades de imágenes objetivo. Para facilitar que los desarrolladores localicen y gestionen estos datos rápidamente, este capítulo describe la visualización de imágenes objetivo, la consulta paginada y los detalles.

Gestionar colecciones de imágenes objetivo mediante EasyAR Web

En la interfaz visual, el sistema muestra las imágenes objetivo en forma de lista paginada de manera predeterminada y las ordena en orden inverso por hora de última modificación (los cambios más recientes aparecen primero).

Colección de imágenes objetivo

Ruta de operación: inicie sesión en EasyAR Web [Developer Center] -> [Cloud Recognition Management] -> seleccione gallery -> haga clic en [Manage].

En esta interfaz puede realizar las siguientes operaciones:

Exploración de lista: ver la colección de imágenes objetivo mostrada por páginas.
Entrada de detalles: haga clic en [Manage] del botón 1 en la imagen para entrar en la página de detalles de esa imagen objetivo.
Búsqueda precisa: en el cuadro de entrada 2 se admiten los dos métodos de búsqueda siguientes:
- Buscar por nombre: si su sistema nombra las imágenes según reglas, como IDs internos de la aplicación, puede localizarlas rápidamente por nombre.
- Buscar por TargetId: por ejemplo, después de obtener un targetId específico mediante la API de consulta de imágenes similares, puede consultar aquí su configuración detallada.

Detalles de la imagen objetivo

Después de entrar en la página de detalles, puede ver las propiedades completas de la imagen objetivo, incluidas:

Imagen en escala de grises
Nombre de imagen: identificador personalizado de la imagen objetivo.
TargetId: ID único generado por el sistema.
Estado: muestra si la imagen objetivo actual está activa o deshabilitada.
Puntuación de calidad: puntuación cuantitativa del rendimiento de reconocimiento y seguimiento. Para más detalles, consulte clasificación de dificultad de reconocimiento de imágenes objetivo.
Custom Meta: metadatos asociados con esta imagen objetivo, como URL de modelo.

detail

Consultar colecciones de imágenes objetivo usando API

Para desarrolladores que necesitan integración con su propio backend, se recomienda gestionar mediante REST API.

Documento de referencia: API de lista de colección de imágenes objetivo

Lista de preparación

Antes de iniciar la solicitud, asegúrese de tener preparada la siguiente información. Para más detalles, consulte lista de preparación para llamadas API:

CRS AppId
API Key / API Secret o Token
Server-end URL: dirección URL de gestión de imágenes objetivo, https usa el puerto 443

Reemplace los marcadores de posición por los parámetros reales y ejecute el script curl

Your-Server-side-URL → API Host real
Your-Token → API Key Authorization Token real
Your-CRS-AppId → su appId

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

Descargue el código de ejemplo Java

Java Samples Download

Importe el proyecto con Maven

Step 1. Abra el archivo de código relacionado ListTargets.java.

Step 2. Modifique las variables globales y sustitúyalas por los parámetros de autenticación de la lista que preparó.

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. Ejecute Main

Descargue el sample code de NodeJS.

NodeJS Samples Download

Step 1. Configure el archivo de claves 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. Ejecute especificando el archivo de claves y el Server-end URL.

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

Si necesita cambiar la estrategia de pagination, pase los parámetros de pagination de getTargets.

'pageSize': tamaño de página
'pageNum': número de página

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 llama a la API del servicio cloud. El sample code está en 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));
    });
}

Descargue el código de ejemplo PHP.

PHP Samples Download

Step 1. Abra el código de entrada demo.php.

Step 2. Modifique las variables globales y sustitúyalas por los parámetros de autenticación de su lista preparada.

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. Ejecute php demo.php.

Cree el archivo de codigo relacionado list_targets.py, modifique las variables globales y luego ejecute

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

Cree el archivo de código relacionado main.go, modifique las variables globales y luego ejecute

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

Añada las dependencias reqwest, tokio, sha2 y hex en Cargo.toml.

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

Cree un proyecto de consola .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();
    }
}

Entorno de ejecución
- Unity 2020 LTS o posterior
- Scripting Backend: se admiten Mono e IL2CPP
- API Compatibility Level: .NET Standard 2.1 (recomendado)

Step 1: Prepare el archivo de imagen

Cree un directorio en el proyecto 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);
        }
    }
}

Según el nombre del directorio Assets
- Copie el siguiente código de ejemplo ListImageTarget.cs
En Unity Editor:
- Cree un GameObject vacío
- Nómbrelo ListTarget
- Arrastre el script a este objeto

Step 3: Configure los parámetros (Inspector)

Modifique en el panel Inspector:
- Api Url
- Authorization Token
- Crs App Id
- page size
- page num
Solo necesita modificar estos elementos para ejecutar, rellenando los parámetros preparados en la checklist de preparación

Step 4: Ejecutar

Haga clic en Play
Consulte el resultado en Console:
- Correcto: devuelve JSON (incluye targetId)
- Fallo: HTTP / información de error

Temas relacionados:

Tema siguiente: