Abfrage der Zielbildliste

In Cloud Recognition (CRS)-Datenbanken werden normalerweise sehr viele Zielbilder gespeichert. Damit Entwickler diese Daten schnell finden und verwalten können, beschreibt dieses Kapitel die Anzeige von Zielbildern, die paginierte Abfrage und die Detailinformationen.

Zielbildsammlungen über EasyAR Web verwalten

In der visuellen Oberfläche zeigt das System Zielbilder standardmäßig als paginierte Liste an und sortiert sie absteigend nach letzter Änderungszeit (die neuesten Änderungen stehen vorne).

Zielbildsammlung

Bedienpfad: Melden Sie sich bei EasyAR Web [Developer Center] an -> [Cloud Recognition Management] -> gallery auswählen -> auf [Manage] klicken.

In dieser Oberfläche können Sie folgende Aktionen ausführen:

Liste durchsuchen: die paginiert angezeigte Zielbildsammlung anzeigen.
Detaileinstieg: Klicken Sie im Bild bei Schaltfläche 1 auf [Manage], um die Detailseite dieses Zielbilds zu öffnen.
Präzise Suche: Eingabefeld 2 unterstützt die folgenden zwei Suchmethoden:
- Nach Name suchen: Wenn Ihr System Bilder nach Regeln benennt, zum Beispiel nach In-App-IDs, können Sie sie schnell per Name finden.
- Nach TargetId suchen: Nachdem Sie zum Beispiel über die API für ähnliche Bildabfragen eine konkrete targetId erhalten haben, können Sie hier deren detaillierte Konfiguration abfragen.

Zielbilddetails

Nach dem Öffnen der Detailseite können Sie die vollständigen Eigenschaften des Zielbilds anzeigen, darunter:

Graustufenbild
Bildname: benutzerdefinierte Kennung des Zielbilds.
TargetId: eindeutige vom System generierte ID.
Status: zeigt an, ob das aktuelle Zielbild aktiv oder deaktiviert ist.
Qualitätsbewertung: quantitative Bewertung der Erkennungs- und Tracking-Leistung. Details siehe Schwierigkeitsbewertung der Zielbilderkennung.
Custom Meta: Metadaten, die diesem Zielbild zugeordnet sind, zum Beispiel Modell-URL.

detail

Zielbildsammlungen mit API abfragen

Für Entwickler, die eine Integration in ein eigenes Backend benötigen, wird die Verwaltung über REST API empfohlen.

Referenzdokument: API für Zielbildsammlungsliste

Vorbereitungsliste

Stellen Sie vor dem Senden einer Anfrage sicher, dass die folgenden Informationen bereitstehen. Details siehe Vorbereitungsliste für API-Aufrufe:

CRS AppId
API Key / API Secret oder Token
Server-end URL: URL-Adresse der Zielbildverwaltung, https verwendet Port 443

Ersetzen Sie die Platzhalter durch die tatsächlichen Parameter und führen Sie das curl-Skript aus

Your-Server-side-URL → tatsächlicher API Host
Your-Token → tatsächlicher API Key Authorization Token
Your-CRS-AppId → Ihre 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-Beispielcode herunterladen

Java Samples Download

Projekt mit Maven importieren

Step 1. Öffnen Sie die zugehörige Codedatei ListTargets.java.

Step 2. Ändern Sie die globalen Variablen und ersetzen Sie sie durch die Authentifizierungsparameter aus Ihrer vorbereiteten Liste.

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. Main ausführen

Laden Sie den NodeJS sample code herunter.

NodeJS Samples Download

Step 1. Konfigurieren Sie die Schlüsseldatei 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. Führen Sie es aus und geben Sie Schlüsseldatei und Server-end URL an.

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

Wenn Sie die pagination-Strategie ändern müssen, übergeben Sie getTargets-pagination-Parameter.

'pageSize': Seitengröße
'pageNum': Seitennummer

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 ruft die API des Cloud-Dienstes auf. Der sample code befindet sich in 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));
    });
}

Laden Sie den PHP-Beispielcode herunter.

PHP Samples Download

Step 1. Öffnen Sie den Einstiegscode demo.php.

Step 2. Ändern Sie die globalen Variablen und ersetzen Sie sie durch die Authentifizierungsparameter aus Ihrer vorbereiteten Liste.

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. Führen Sie php demo.php aus.

Erstellen Sie die zugehorige Codedatei list_targets.py, andern Sie die globalen Variablen und fuhren Sie sie dann aus

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

Erstellen Sie die zugehörige Codedatei main.go, ändern Sie die globalen Variablen und führen Sie dann aus

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

Fügen Sie in Cargo.toml die Abhängigkeiten reqwest, tokio, sha2 und hex hinzu.

Führen Sie cargo run aus.

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

Erstellen Sie ein .NET-Konsolenprojekt.

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

Laufzeitumgebung
- Unity 2020 LTS oder höher
- Scripting Backend: Mono oder IL2CPP sind beide möglich
- API Compatibility Level: .NET Standard 2.1 (empfohlen)

Step 1: Bilddatei vorbereiten

Erstellen Sie im Unity-Projekt ein Verzeichnis:

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

Entsprechend dem Assets-Verzeichnisnamen
- Kopieren Sie den folgenden Beispielcode ListImageTarget.cs
Im Unity Editor:
- Erstellen Sie ein leeres GameObject
- Nennen Sie es ListTarget
- Ziehen Sie das Skript auf dieses Objekt

Step 3: Parameter konfigurieren (Inspector)

Ändern Sie im Inspector-Bedienfeld:
- Api Url
- Authorization Token
- Crs App Id
- page size
- page num
Um es auszuführen, müssen nur diese Elemente geändert und die in der Vorbereitungsliste vorbereiteten Parameter eingetragen werden

Step 4: Ausführen

Klicken Sie auf Play
Prüfen Sie das Ergebnis in Console:
- Erfolg: gibt JSON zurück (einschließlich targetId)
- Fehler: HTTP / Fehlerinformationen

Verwandte Themen:

Nächstes Thema: