Suppression de la cible

EasyAR propose deux méthodes pour gérer les images de reconnaissance qui ne sont plus nécessaires : suppression permanente et désactivation temporaire. Pour garantir la stabilité de l'environnement de production, il est recommandé de lire attentivement les instructions suivantes.

Opération via le centre de gestion web EasyAR

Étapes d'opération : Connectez-vous au centre de développement EasyAR -> Gestion de la reconnaissance cloud -> Sélectionnez la bibliothèque d'images correspondante -> Cliquez sur Gérer pour accéder à l'interface de gestion de la bibliothèque d'images.
Méthodes de suppression :
- Suppression par lot : Cochez les images cibles dans la liste, cliquez sur Supprimer et confirmez.
- Suppression individuelle : Cliquez pour entrer dans la page de détails de l'image cible, puis cliquez sur le bouton Supprimer dans la page.

Guide de suppression

Avertissement

La suppression est irréversible. Une fois confirmée, toutes les données caractéristiques et les informations associées de cette image seront perdues définitivement. Il est recommandé de d'abord valider le processus dans une bibliothèque d'images de test. Il est strictement interdit d'effectuer des tests destructifs directement en environnement de production.

Bonne pratique : Désactivation de la cible

Dans la plupart des scénarios métier, si vous n'êtes pas sûr de réutiliser une image à l'avenir, il est recommandé d'utiliser désactivation au lieu de suppression.

Caractéristiques : Les images cibles désactivées restent dans la liste de la base de données, mais ne participent pas au processus de recherche de reconnaissance cloud. Cependant, elles occupent un quota de reconnaissance.
Méthode de désactivation : Dans l'interface de gestion, cochez les images de reconnaissance, puis cliquez sur Désactiver.

Guide de désactivation

Désactivation par API : En appelant l'API de mise à jour de la cible, définissez l'attribut active sur 0.

Utilisation de l'API pour supprimer une cible

Le nettoyage automatisé des images de reconnaissance peut être réalisé via l'API REST.

Préparation

Avant de commencer, lisez la documentation de l'API de suppression de cible et préparez les ressources suivantes :

CRS AppId
API Key / Secret ou Token
Server-end URL (port 443)
TargetId : L'identifiant unique de l'image cible à supprimer. Si le TargetId n'existe pas, l'API renverra statusCode: 404 (Target not found).

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

Your-Server-side-URL → Hôte d'API réel
Your-Token → Jeton d'autorisation de clé API réel
Your-CRS-AppId → Votre appId
Your-todo-TargetId → Cible à supprimer targetId

curl -X DELETE "https://<Your Server-side-URL>/target/<Your-todo-TargetId>?appId=<Your-CRS-AppId>" \
  -H "Content-Type: application/json" \
  -H "Authorization: <Your-Token>"

Télécharger l'exemple de code java

Java Samples Download

Importer le projet via Maven

Étape 1. Ouvrir le fichier de code concerné RemoveTarget.java

Étape 2. Modifier les variables globales, remplacer les paramètres d'authentification de votre manifeste

CRS AppId
API Key / API Secret
TARGET_MGMT_URL → URL du serveur
TARGET_ID → targetId de la cible à supprimer

public class RemoveTarget {

    private static final String TARGET_MGMT_URL = "https://cn1.crs.easyar.com";
    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 TARGET_ID       = "my_targetid";
    /* TO_DEL_IDs liste tous les targetId à supprimer
     * doivent être séparés par ","
     */
    private static final String TO_DEL_IDs = "targetId1,targetId2,targetId3";

    public String remove(Auth auth, String targetId) throws IOException {
        okhttp3.Request request = new okhttp3.Request.Builder()
                .url(auth.getCloudURL()+"/target/"+targetId+"?"+ Common.toParam(
                        Auth.signParam(new JSONObject(), auth.getAppId(), auth.getApiKey(), auth.getApiSecret())
                ))
                .delete()
                .build();
        return new OkHttpClient.Builder().build().newCall(request).execute().body().string();
    }

    public String removeMultiTargets(Auth auth, String targetIds) throws IOException {
        JSONObject params = new JSONObject().put("targetId", targetIds);
        Auth.signParam(params, auth.getAppId(), auth.getApiKey(), auth.getApiSecret());
        RequestBody requestBody = FormBody.create(MediaType.parse("application/json; charset=utf-8")
                , params.toString());
        okhttp3.Request request = new okhttp3.Request.Builder()
                .url(auth.getCloudURL() + "/targets")
                .delete(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(new RemoveTarget().remove(accessInfo, TARGET_ID));
        System.out.println(new RemoveTarget().removeMultiTargets(accessInfo, TO_DEL_IDs));
    }
}

Étape 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
Clé API / Secret API
to-delete-targetId

{
  "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, en spécifiant le fichier de clés et l'URL du serveur

node bin/deleteTarget <to-delete-targetId> -t <Server-end-URL> -c keys.json

var argv = require('yargs')
    .usage('Usage: $0 [targetId] -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 targetId = argv._[0];
var host = argv.host;
var keys = JSON.parse(fs.readFileSync(argv.keys));

var farmer = require('../farmer')(host, keys.appKey, keys.appSecret);

farmer.deleteTarget(targetId)
.then(function(resp) {
    console.log(resp.result.targetId);
})
.fail(function(err) {
    console.log(err);
});

deleteTarget appelle l'interface du service cloud, l'exemple de code est dans farmer.js

function deleteTarget(targetId) {
    return Q.promise(function(resolve, reject) {
        request.del(host + '/target/' + targetId)
        .query(signParams())
        .end(done(resolve, reject));
    });
}

Télécharger l'exemple de code Php

PHP Samples Download

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

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

CRS AppId
API Key / API Secret
Server-end URL
toDeleteTargetId

<?php
include 'EasyARClientSdkCRS.php';
$apiKey = 'API Key';
$apiSecret = 'API Secret';
$crsAppId = 'CRS AppId'
$crsCloudUrl = 'https://cn1-crs.easyar.com';
$toDeleteTargetId = 'to-delete-targetId';

$sdk = new EasyARClientSdkCRS($apiKey, $apiSecret, $crsAppId, $crsCloudUrl);

$rs = $sdk->delete($toDeleteTargetId);
if ($rs->statusCode == 0) {
  print_r($rs->result);
} else {
  print_r($rs);
}

Étape 3. Exécuter php demo.php

Créer le fichier de code correspondant delete_target.py, modifier les variables globales, puis exécuter

pip install requests
python delete_target.py

import time
import hashlib
import requests

# --- Configuration des variables globales ---
API_KEY = "YOUR_API_KEY"
API_SECRET = "YOUR_API_SECRET"
APP_ID = "YOUR_APP_ID"
HOST = "https://crs-cn1.easyar.com" 
TARGET_ID = "TARGET_ID"

def main():
    timestamp = str(int(time.time() * 1000))
    
    params = {
        'apiKey': API_KEY,
        'appId': APP_ID,
        'timestamp': timestamp
    }

    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}/target/{TARGET_ID}"
    final_params = {**params, 'signature': signature}

    print(f"Requête DELETE {url}...")
    response = requests.delete(url, params=final_params)
    print(f"Réponse: {response.text}")

if __name__ == "__main__":
    main()

Créer un fichier de code associé main.go, modifier les variables globales, puis exécuter

go run main.go

main.go:

package main

import (
  "crypto/sha256"
  "fmt"
  "io"
  "net/http"
  "sort"
  "strconv"
  "time"
)

var (
  ApiKey    = "YOUR_API_KEY"
  ApiSecret = "YOUR_API_SECRET"
  AppId     = "YOUR_APP_ID"
  Host      = "https://crs-cn1.easyar.com"
  TargetId  = "TARGET_ID"
)

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/target/%s?apiKey=%s&appId=%s&timestamp=%s&signature=%s", 
    Host, TargetId, ApiKey, AppId, ts, signature)
  
  req, _ := http.NewRequest("DELETE", url, nil)
  resp, _ := http.DefaultClient.Do(req)
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Printf("Response: %s\n", string(body))
}

Ajouter des dépendances reqwest, tokio, sha2, hex dans Cargo.toml.

Exécuter cargo run.

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

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 TARGET_ID: &str = "YOUR_TARGET_ID";

#[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!("{}/target/{}?apiKey={}&appId={}&timestamp={}&signature={}", 
                      HOST, TARGET_ID, API_KEY, APP_ID, ts, signature);
    
    let res = reqwest::Client::new().delete(url).send().await?;
    println!("Response: {}", res.text().await?);
    Ok(())
}

Créer un projet 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 {
    static string API_KEY = "API_KEY";
    static string API_SECRET = "API_SECRET";
    static string APP_ID = "APP_ID";
    static string HOST = "https://crs-cn1.easyar.com";
    static string TARGET_ID = "TARGET_ID";

    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}/target/{TARGET_ID}?{query}";
        
        var response = await client.DeleteAsync(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é
- Niveau de compatibilité des API : .NET Standard 2.1 (recommandé)

Étape 1 : Préparer les fichiers image

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

Assets/
└── Scripts/
     └── DeleteImageTarget.cs

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

using System.Collections;
using UnityEngine;
using UnityEngine.Networking;

public class DeleteImageTarget : MonoBehaviour
{
    [Header("Config")]
    public string targetId = "Your targetId";
    public string apiBaseUrl = "https://Your-Server-end-URL";
    public string authorizationToken = "YOUR API KEY AUTH TOKEN"; 
    public string crsAppId = "CRS-AppId"; 

    private void Start()
    {
        StartCoroutine(DeleteTarget());
    }

    private IEnumerator DeleteTarget()
    {
     
        string url =
            $"{apiBaseUrl}/target/{targetId}?appId={crsAppId}";

        UnityWebRequest request = UnityWebRequest.Delete(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("Delete target success:");
            Debug.Log(request.downloadHandler.text);
        }
        else
        {
            Debug.LogError("Delete target failed:");
            Debug.LogError(request.error);
            Debug.LogError(request.downloadHandler.text);
        }
    }
}

Dans l'éditeur Unity :
- Créer un GameObject vide
- Le nommer DeleteTarget
- Glisser le script DeleteImageTarget sur cet objet

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

Modifier dans le panneau Inspector :
- Api Url
- Authorization Token
- Crs App Id
- Target Id : targetId de l'image cible à supprimer
Seules ces modifications sont nécessaires avant exécution, utiliser les paramètres préparés

Étape 4 : Exécution

Cliquer sur Play
Vérifier le résultat dans la Console :
- Succès : JSON retourné (incluant targetId)
- Échec : Informations d'erreur HTTP