Bevor Bilder offiziell zur Cloud Recognition Service (CRS)-Galerie hinzugefügt werden, ist es bewährte Praxis, ihre Qualität vorab zu bewerten.
Wenn das Zielbild zu wenig erkennbare Bereiche aufweist (z. B. weiße Wand, einfarbige Flächen) oder die Textur zu einfach ist, sinkt die Erkennungsrate erheblich. Dieses Kapitel erläutert detailliert das Bewertungssystem von CRS, um Ihnen bei der Auswahl hochwertiger AR-Erkennungsmaterialien zu helfen.
Wir konzentrieren uns hauptsächlich auf die folgenden zwei Kernindikatoren, die über separate API-Schnittstellen verfügen und eine Gesamtbewertung liefern:
Diese Indikatoren bewerten aus algorithmischer Sicht, wobei jeder Indikator eine Schwierigkeitsbewertung von 0 bis 4 liefert.
Die Detailbewertung jedes Zielbildes befindet sich in dessen Detailansicht in der Datenbank. Sie kann über die API abgerufen werden, um die Eigenschaften des Zielbildes anzuzeigen. Alternativ kann sie auch über die EasyAR Cloud Recognition-Verwaltung eingesehen werden.
Wie dargestellt, zeigt die Detailseite die beiden Kernindikatoren sowie ein Fünfeck, das fünf Detailindikatoren darstellt.
Beim Aufbau eines automatisierten Upload-Backends wird empfohlen, die Bewertungsschnittstelle vor dem offiziellen Upload aufzurufen.
- Zunächst das lokale Zielbild in Base64 konvertieren (macOS/Linux), Ergebnis in image_base64.txt speichern
base64 -i ./target.jpg | tr -d '\n' > image_base64.txt
- Bitte Platzhalter durch tatsächliche Parameter ersetzen und das curl-Skript ausführen
- Your-Server-side-URL → Tatsächliche API-Host-URL
- Your-Token → Tatsächlicher API-Schlüssel (Authorization Token)
- Your-CRS-AppId → Ihre appId
curl -X POST "https://<Your-Server-side-URL>/grade/detail" \
-H "Content-Type: application/json" \
-H "Authorization: <YOUR-TOKEN>" \
-d '{
"appId": "<Your-CRS-AppId>",
"image": "'"$(cat image_base64.txt)"'"
}'
Beispielcode für Java herunterladen
Projekt über Maven importieren
Step 1. Öffnen Sie die relevante Codedatei Grade.java
Step 2. Ändern Sie die globalen Variablen und ersetzen Sie die Authentifizierungsparameter aus Ihrer Vorbereitungsliste
- CRS AppId
- API Key / API Secret
- Server-end URL
- IMAGE_PATH : Zu hochladende Zieldatei
import okhttp3.*;
import org.json.JSONObject;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Base64;
import java.util.HashMap;
import java.util.Map;
public class Grade {
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--";
private static final String IMAGE_PATH = "test_target_image.jpg";
enum GradeType {
DETAIL,
DETECTION,
TRACKING
}
private static final Map<GradeType, String> GRADE_URL = new HashMap<GradeType, String>(){
{
put(GradeType.DETAIL, "/grade/detail") ;
put(GradeType.DETECTION, "/grade/detection") ;
put(GradeType.TRACKING, "/grade/tracking") ;
}
};
public String grade(Auth auth, String imgPath, GradeType gradeType) throws IOException {
final Path mImagePath = Paths.get(imgPath);
JSONObject params = new JSONObject().put("image", Base64.getEncoder().encodeToString(
Files.readAllBytes(mImagePath)
));
Auth.signParam(params, auth.getAppId(), auth.getApiKey(), auth.getApiSecret());
RequestBody requestBody = FormBody.create(MediaType.parse("application/json; charset=utf-8")
, params.toString());
Request request = new Request.Builder()
.url(auth.getCloudURL() + GRADE_URL.get(gradeType))
.post(requestBody)
.build();
return new OkHttpClient.Builder().build().newCall(request).execute().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("================== grade details ==================");
System.out.println(new Grade().grade(accessInfo, IMAGE_PATH, GradeType.DETAIL));
System.out.println("================== grade for detection ==================");
JSONObject gradeResp = new JSONObject(new Grade().grade(accessInfo, IMAGE_PATH, GradeType.DETECTION));
System.out.println("Detection grade: " + gradeResp.getJSONObject(Common.KEY_RESULT).get(Common.KEY_GRADE));
System.out.println("================== grade for tracking =================== ");
gradeResp = new JSONObject(new Grade().grade(accessInfo, IMAGE_PATH, GradeType.TRACKING));
System.out.println("Tracking grade: " + gradeResp.getJSONObject(Common.KEY_RESULT).get(Common.KEY_GRADE));
}
}
Step 3. Main ausführen
Laden Sie NodeJS-Beispielcode herunter
Schritt 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--"
}
Schritt 2. Ausführen, geben Sie das Testbild, die Schlüsseldatei und die Server-end-URL an
node bin/grade test.jpeg -t <Server-end-URL> -c keys.json
var argv = require('yargs')
.usage('Usage: $0 [image] -t [host] -c [keys]')
.demand(1)
.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 imageFn = argv._[0];
var host = argv.host;
var keys = JSON.parse(fs.readFileSync(argv.keys));
var farmer = require('../farmer')(host, keys);
farmer.getTrackingGrade({
'image': fs.readFileSync(imageFn).toString('base64')
})
.then(function(resp) {
console.log(resp);
})
.fail(function(err) {
console.log(err);
});
Beispielcode für Php herunterladen
Schritt 1. Öffnen Sie den Einstiegscode demo.php
Schritt 2. Ändern Sie die globalen Variablen und ersetzen Sie die Authentifizierungsparameter aus Ihrer Vorbereitungsliste
- CRS AppId
- API Key / API Secret
- Server-end URL
- imageFilePath : Pfad zur hochzuladenden Zielbilddatei
<?php
include 'EasyARClientSdkCRS.php';
$apiKey = 'API Key';
$apiSecret = 'API Secret';
$crsAppId = 'CRS AppId'
$crsCloudUrl = 'https://cn1-crs.easyar.com';
$imageFilePath = '1.jpg'
$sdk = new EasyARClientSdkCRS($apiKey, $apiSecret, $crsAppId, $crsCloudUrl);
$image = base64_encode(file_get_contents($imageFilePath));
$rs = $sdk->detection($image);
if ($rs->statusCode == 0) {
print_r($rs->result->grade);
} else {
print_r($rs);
}
Schritt 3. Führen Sie php demo.php aus
Neue zugehörige code-datei grade.py, global variablen ändern und dann ausführen
pip install requests
python grade.py
import time
import hashlib
import requests
import base64
# --- Global Configuration ---
API_KEY = "YOUR_API_KEY"
API_SECRET = "YOUR_API_SECRET"
APP_ID = "YOUR_APP_ID"
HOST = "https://crs-cn1.easyar.com"
IMAGE_PATH = "test.jpg"
def main():
# 1. Bild lesen und kodieren
with open(IMAGE_PATH, "rb") as f:
image_base64 = base64.b64encode(f.read()).decode('utf-8')
timestamp = str(int(time.time() * 1000))
# 2. Parameter-dictionary erstellen (enthält bild)
params = {
'apiKey': API_KEY,
'appId': APP_ID,
'timestamp': timestamp,
'image': image_base64
}
# 3. Nach schlüssel sortieren und verketten
sorted_keys = sorted(params.keys())
builder = "".join([f"{k}{params[k]}" for k in sorted_keys])
builder += API_SECRET
# 4. SHA256-signatur generieren
signature = hashlib.sha256(builder.encode('utf-8')).hexdigest()
# 5. POST-anfrage senden
payload = {**params, "signature": signature, "timestamp": int(timestamp)}
response = requests.post(f"{HOST}/grade/detection", json=payload)
print(f"Status: {response.status_code}")
print(f"Response: {response.text}")
if __name__ == "__main__":
main()
Erstellen Sie die relevante Codedatei main.go, ändern Sie die globalen Variablen und führen Sie sie dann aus
go run main.go
main.go:
package main
import (
"bytes"
"crypto/sha256"
"encoding/base64"
"encoding/json"
"fmt"
"io"
"net/http"
"os"
"sort"
"strconv"
"time"
)
var (
ApiKey = "YOUR_API_KEY"
ApiSecret = "YOUR_API_SECRET"
AppId = "YOUR_APP_ID"
Host = "https://crs-cn1.easyar.com"
ImagePath = "test.jpg"
)
func main() {
fileData, _ := os.ReadFile(ImagePath)
imgBase64 := base64.StdEncoding.EncodeToString(fileData)
tsInt := time.Now().UnixNano() / 1e6
tsStr := strconv.FormatInt(tsInt, 10)
params := map[string]string{
"apiKey": ApiKey,
"appId": AppId,
"timestamp": tsStr,
"image": imgBase64,
}
keys := make([]string, 0, len(params))
for k := range params { keys = append(keys, k) }
sort.Strings(keys)
var builder bytes.Buffer
for _, k := range keys {
builder.WriteString(k)
builder.WriteString(params[k])
}
builder.WriteString(ApiSecret)
signature := fmt.Sprintf("%x", sha256.Sum256(builder.Bytes()))
payload := map[string]interface{}{
"image": imgBase64,
"apiKey": ApiKey,
"appId": AppId,
"timestamp": tsInt,
"signature": signature,
}
jsonBytes, _ := json.Marshal(payload)
resp, _ := http.Post(Host+"/grade/detection", "application/json", bytes.NewBuffer(jsonBytes))
defer resp.Body.Close()
body, _ := io.ReadAll(resp.Body)
fmt.Printf("Antwort: %s\n", string(body))
}
Fügen Sie in Cargo.toml die Abhängigkeiten reqwest, tokio, sha2, hex hinzu.
Führen Sie cargo run aus.
use sha2::{Sha256, Digest};
use std::collections::BTreeMap;
use std::time::{SystemTime, UNIX_EPOCH};
use base64::{Engine as _, engine::general_purpose};
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";
const IMAGE_PATH: &str = "test.jpg";
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let img_bytes = std::fs::read(IMAGE_PATH)?;
let img_b64 = general_purpose::STANDARD.encode(img_bytes);
let ts_raw = SystemTime::now().duration_since(UNIX_EPOCH)?.as_millis();
let ts_str = ts_raw.to_string();
// 1. Parameter in BTreeMap sammeln für automatische Sortierung
let mut params = BTreeMap::new();
params.insert("apiKey", API_KEY);
params.insert("appId", APP_ID);
params.insert("timestamp", &ts_str);
params.insert("image", &img_b64);
// 2. Signaturzeichenkette erstellen
let mut builder = String::new();
for (k, v) in ¶ms {
builder.push_str(k);
builder.push_str(v);
}
builder.push_str(API_SECRET);
// 3. Hashen
let mut hasher = Sha256::new();
hasher.update(builder.as_bytes());
let signature = hex::encode(hasher.finalize());
let mut body = serde_json::Map::new();
body.insert("image".into(), img_b64.into());
body.insert("apiKey".into(), API_KEY.into());
body.insert("appId".into(), APP_ID.into());
body.insert("timestamp".into(), ts_raw.into());
body.insert("signature".into(), signature.into());
let client = reqwest::Client::new();
let res = client.post(format!("{}/grade/detection", HOST))
.json(&body)
.send()
.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.IO;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Net.Http;
using System.Text.Json;
class Program {
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 string IMAGE_PATH = "test.jpg";
static async System.Threading.Tasks.Task Main() {
string timestamp = DateTimeOffset.Now.ToUnixTimeMilliseconds().ToString();
string imageBase64 = Convert.ToBase64String(File.ReadAllBytes(IMAGE_PATH));
// 1. Daten für die Signatur vorbereiten
var data = new SortedDictionary<string, string> {
{ "apiKey", API_KEY },
{ "appId", APP_ID },
{ "timestamp", timestamp },
{ "image", imageBase64 }
};
// 2. Schlüssel und Werte verketten
StringBuilder sb = new StringBuilder();
foreach (var pair in data) sb.Append(pair.Key).Append(pair.Value);
sb.Append(API_SECRET);
string signature = Sha256(sb.ToString());
// 3. JSON-Body erstellen
var body = new {
image = imageBase64,
apiKey = API_KEY,
appId = APP_ID,
timestamp = long.Parse(timestamp),
signature = signature
};
using var client = new HttpClient();
var content = new StringContent(JsonSerializer.Serialize(body), Encoding.UTF8, "application/json");
var response = await client.PostAsync($"{HOST}/grade/detection", content);
Console.WriteLine($"Antwort: {await response.Content.ReadAsStringAsync()}");
}
static string Sha256(string str) {
byte[] bytes = SHA256.HashData(Encoding.UTF8.GetBytes(str));
return BitConverter.ToString(bytes).Replace("-", "").ToLower();
}
}
- Laufende Umgebung
- Unity 2020 LTS oder höher
- Scripting Backend: Mono oder IL2CPP, beides ist möglich
- API Compatibility Level: .NET Standard 2.1 (empfohlen)
Schritt 1: Bilddateien vorbereiten
- Im Unity-Projekt Verzeichnisse erstellen:
Assets/
└── StreamingAssets/
| └── target.jpg
└── Scripts/
└── GrageImage.cs
- Gemäß dem Assets-Verzeichnisnamen
- Erstellen Sie das Skript GrageImage.cs, kopieren Sie den Beispielcode unten
- Bereiten Sie ein Testbild als Ziel vor
using System;
using System.IO;
using System.Text;
using UnityEngine;
using UnityEngine.Networking;
using System.Collections;
public class GrageImage : MonoBehaviour
{
[Header("Config")]
public string apiUrl = "https://Your-Server-end-URL" + "/grade/detection";
public string authorizationToken = "YOUR API KEY AUTH TOKEN";
public string imageFilePath = "target.jpg"; // StreamingAssets
public string crsAppId = "<Your-CRS-AppId>";
private void Start()
{
StartCoroutine(Grade());
}
private IEnumerator Grade()
{
// Read image file（Unity StreamingAssets）
string fullPath = Path.Combine(Application.streamingAssetsPath, imageFilePath);
if (!File.Exists(fullPath))
{
Debug.LogError($"Image file not found: {fullPath}");
yield break;
}
byte[] imageBytes = File.ReadAllBytes(fullPath);
string imageBase64 = Convert.ToBase64String(imageBytes);
TargetRequestBody body = new TargetRequestBody
{
appId = crsAppId,
image = imageBase64,
};
string json = JsonUtility.ToJson(body);
// UnityWebRequest
UnityWebRequest request = new UnityWebRequest(apiUrl, "POST");
byte[] jsonBytes = Encoding.UTF8.GetBytes(json);
request.uploadHandler = new UploadHandlerRaw(jsonBytes);
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("Grade detail success:");
Debug.Log(request.downloadHandler.text);
}
else
{
Debug.LogError("Grade detail failed:");
Debug.LogError(request.error);
Debug.LogError(request.downloadHandler.text);
}
}
[Serializable]
private class TargetRequestBody
{
public string appId;
public string image;
}
}
- Im Unity-Editor:
- Erstellen Sie ein leeres GameObject
- Nennen Sie es GradeImage
- Ziehen Sie das GrageImage-Skript auf dieses Objekt
Schritt 3: Parameter konfigurieren (Inspector)
Ändern Sie im Inspector-Panel. Ändern Sie die Daten gemäß der vorbereiteten Checkliste.
- Api Url
- Authorization Token
- Image File Path : Standardmäßig target.jpg
- CRS AppId
Sie müssen nur diese vier Punkte ändern, um es auszuführen. Tragen Sie die vorbereiteten Parameter aus der Checkliste ein
Schritt 4: Ausführen
- Klicken Sie auf Play
- Sehen Sie das Ergebnis in der Konsole:
- Erfolg: Gibt JSON zurück (result enthält Objekte)
- Fehler: HTTP-/Fehlermeldungen
