Consulta de lista de imagens alvo

O banco de dados de reconhecimento em nuvem (CRS) normalmente armazena um grande número de imagens alvo. Para ajudar os desenvolvedores a localizar e gerenciar esses dados rapidamente, este capítulo detalha a visualização, consulta paginada e detalhes das imagens alvo.

Gerenciar coleções de imagens alvo via EasyAR Web

Na interface visual, o sistema adota por padrão uma forma de lista paginada para exibir as imagens alvo, ordenadas inversamente pelo tempo da última modificação (as mais recentes aparecem primeiro).

Coleção de imagens alvo

Caminho de operação: Faça login no [Centro de Desenvolvimento] do EasyAR Web -> [Gerenciamento de Reconhecimento em Nuvem] -> Selecione uma galeria -> Clique em [Gerenciar].

Nesta interface, você pode realizar as seguintes operações:

Navegação na lista: Visualizar a coleção de imagens alvo exibida de forma paginada.
Entrada de detalhes: Clique no botão 1 na imagem [Gerenciar] para acessar a página de detalhes dessa imagem alvo.
Busca precisa: Na caixa de entrada 2, são suportados dois métodos de busca:
- Buscar por nome: Se o seu sistema nomeia as imagens por regras (como ID interno do aplicativo), você pode localizá-las rapidamente pelo nome.
- Buscar por TargetId: Por exemplo, quando você obtém um targetId específico através da interface de consulta de imagem similar, pode pesquisar suas configurações detalhadas aqui.

Detalhes da imagem alvo

Ao clicar e entrar na página de detalhes, você pode visualizar todos os atributos da imagem alvo, incluindo:

Imagem em escala de cinza
Nome da imagem: Identificador personalizado da imagem alvo.
TargetId: ID único gerado pelo sistema.
Status: Indica se a imagem alvo está ativa ou desativada.
Pontuação de qualidade: Pontuação quantitativa sobre o desempenho de reconhecimento e rastreamento. Consulte Classificação de dificuldade de reconhecimento de imagem alvo para detalhes.
Meta personalizada: Metadados associados a esta imagem alvo (como URL do modelo, etc.)

detail

Usar API para consultar coleções de imagem alvo

Para desenvolvedores que precisam integrar em seu próprio backend, é recomendado usar a API REST para gerenciamento.

Documentação de referência: Interface da API de lista de coleções de imagem alvo

Lista de preparação

Antes de enviar a solicitação, certifique-se de ter as seguintes informações prontas (consulte Lista de preparação para chamadas de API para detalhes):

CRS AppId
API Key / API Secret ou Token
URL do endpoint: Endereço URL de gerenciamento da imagem alvo, porta 443 para https

Substitua os espaços reservados pelos parâmetros reais e execute o script curl

Your-Server-side-URL → Host real da API
Your-Token → Token de autorização real da chave API
Your-CRS-AppId → Seu appId

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

Descarregar código de exemplo Java

Java Samples Download

Importar projeto via Maven

Passo 1. Abrir o ficheiro de código relevante ListTargets.java

Passo 2. Modificar variáveis globais, substituir os parâmetros de autenticação da sua lista de preparação

CRS AppId
API Key / API Secret
TARGET_MGMT_URL → URL do lado do servidor

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

}

Passo 3. Executar Main

Baixar o código de exemplo do NodeJS

NodeJS Samples Download

Passo 1. Configurar o arquivo de chaves 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--"
}

Passo 2. Executar, especificando o arquivo de chaves e o URL do server-end

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

Se precisar alterar a estratégia de paginação, passe os parâmetros de paginação para getTargets

'pageSize': tamanho da página
'pageNum': número da 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 chama a interface do serviço em nuvem, o código de exemplo está em 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));
    });
}

Descarregar código de exemplo Php

PHP Samples Download

Passo 1. Abrir o código de entrada demo.php

Passo 2. Modificar variáveis globais, substituir os parâmetros de autenticação da tua lista de preparação

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

Passo 3. Executar php demo.php

Criar o arquivo de código relevante list_targets.py, modificar as variáveis globais e então executar

pip install requests
python list_targets.py

import time
import hashlib
import requests

# --- Configuração global ---
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
    }

    # Assinatura: Ordenar chaves -> Concatenar -> Adicionar 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()

Crie o arquivo de código relevante main.go, modifique as variáveis globais e então execute.

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

Adicione as dependências reqwest, tokio, sha2, hex no Cargo.toml.

Execute cargo run.

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

// --- Configuração global ---
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(())
}

Criar um projeto 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 {
    // --- Configuração global ---
    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();
    }
}

Ambiente de execução
- Unity 2020 LTS ou superior
- Scripting Backend: Mono ou IL2CPP
- API Compatibility Level: .NET Standard 2.1 (recomendado)

Step 1: Preparar arquivos de imagem

Criar diretório no projeto Unity:

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

Copiar o código de exemplo ListImageTarget.cs abaixo:

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

No Unity Editor:
- Criar um GameObject vazio
- Nomear como ListTarget
- Arrastar o script ListImageTarget para este objeto

Step 3: Configurar parâmetros (Inspector)

Modificar no painel Inspector:
- Api Url
- Authorization Token
- Crs App Id
- page size
- page num
Basta modificar estes itens para executar, inserindo os parâmetros preparados

Step 4: Executar

Clicar em Play
Verificar resultado no Console:
- Sucesso: Retorna JSON (contém targetId)
- Falha: HTTP / mensagem de erro

Tópicos relacionados:

Próximo tópico: