Eliminazione immagini target

EasyAR offre due metodi per gestire immagini di riconoscimento non più necessarie: Eliminazione permanente e Disattivazione temporanea. Per garantire la stabilità dell'ambiente di produzione, si consiglia di leggere attentamente le seguenti istruzioni operative.

Operazioni tramite la web console di EasyAR

Procedura: Accedi all'EasyAR Developer Center -> Gestione riconoscimento cloud -> Seleziona la galleria corrispondente -> Clicca Gestisci per accedere all'interfaccia di gestione della galleria.
Metodi di eliminazione:
- Eliminazione multipla: Seleziona le immagini target nell'elenco, clicca Elimina e conferma.
- Eliminazione singola: Accedi alla pagina dei dettagli dell'immagine target e clicca il pulsante Elimina.

Guida operativa di eliminazione

Avvertenza

L'operazione di eliminazione è irreversibile. Una volta confermata, tutti i dati caratteristici e le informazioni associate verranno persi permanentemente. Si consiglia di testare la procedura su gallerie di test; è vietato eseguire test distruttivi direttamente in produzione.

Best practice: Disattivazione immagini target

Nella maggior parte degli scenari operativi, se non si è certi del futuro utilizzo di un'immagine, si raccomanda di utilizzare la disattivazione invece dell'eliminazione.

Funzionalità: Le immagini disattivate rimangono nell'elenco del database ma non partecipano alla ricerca di riconoscimento cloud. Tuttavia, occupano quote di riconoscimento.
Metodo di disattivazione: Nell'interfaccia di gestione, seleziona le immagini e clicca Disattiva.

Guida operativa di disattivazione

Disattivazione via API: Chiama l'API Aggiornamento immagine target impostando l'attributo active a 0.

Eliminazione immagini target tramite API

L'API REST consente una pulizia automatizzata delle immagini di riconoscimento.

Preparazione

Prima di iniziare, leggi la documentazione dell'API di eliminazione immagini target e prepara:

CRS AppId
API Key / Secret o Token
URL lato server (porta 443)
TargetId: ID univoco dell'immagine target da eliminare. Se TargetId non esiste, l'API restituirà statusCode: 404 (Target not found).

Per favore sostituisci i segnaposto con i parametri effettivi ed esegui lo script curl

Your-Server-side-URL → Host API effettivo
Your-Token → Token di autorizzazione API Key effettivo
Your-CRS-AppId → Il tuo appId
Your-todo-TargetId → ID target da eliminare

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>"

Scarica codice di esempio Java

Java Samples Download

Importa il progetto tramite Maven

Step 1. Apri il file di codice relativo RemoveTarget.java

Step 2. Modifica le variabili globali, sostituisci i parametri di autenticazione dalla tua lista preparatoria

CRS AppId
API Key / API Secret
TARGET_MGMT_URL → URL server-end
TARGET_ID → targetId dell'obiettivo da eliminare

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 elenca tutti i targetId da rimuovere
     * devono essere separati da ","
     */
    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));
    }
}

Step 3. Esegui Main

Scarica il codice di esempio NodeJS

NodeJS Samples Download

Passaggio 1. Configurare il file delle chiavi keys.json

CRS AppId
API Key / API Secret
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--"
}

Passaggio 2. Eseguire, specificando il file delle chiavi e l'URL del server-end

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 chiama l'interfaccia del servizio cloud, il codice di esempio è in farmer.js

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

Scarica il codice di esempio Php

PHP Samples Download

Passo 1. Aprire il codice di ingresso demo.php

Passo 2. Modificare le variabili globali, sostituire i parametri di autenticazione nella tua lista di preparazione

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

Passo 3. Eseguire php demo.php

Crea un nuovo file di codice correlato delete_target.py, modifica le variabili globali, quindi esegui

pip install requests
python delete_target.py

import time
import hashlib
import requests

# --- Configurazione variabili globali ---
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"Requesting DELETE {url}...")
    response = requests.delete(url, params=final_params)
    print(f"Response: {response.text}")

if __name__ == "__main__":
    main()

Crea il file di codice correlato main.go, modifica le variabili globali, quindi esegui

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

Aggiungi dipendenze reqwest, tokio, sha2, hex in Cargo.toml.

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

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

Ambiente di esecuzione
- Unity 2020 LTS o versioni successive
- Scripting Backend: Mono o IL2CPP
- API Compatibility Level: .NET Standard 2.1 (consigliato)

Passo 1: prepara i file immagine

Crea una directory nel progetto Unity:

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

Segui il nome della directory Assets
- Copia il codice di esempio DeleteImageTarget.cs qui sotto

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

Nell'Editor di Unity:
- Crea un GameObject vuoto
- Assegnagli il nome DeleteTarget
- Trascina lo script DeleteImageTarget su questo oggetto

Passo 3: configura i parametri (Inspector)

Modifica nel pannello Inspector:
- Api Url
- Authorization Token
- Crs App Id
- Target Id : il targetId dell'immagine target da eliminare
Modifica solo questi elementi per eseguire, inserendo i parametri preparati nella lista

Passo 4: esegui

Clicca Play
Controlla il risultato nella Console:
- Successo: restituisce JSON (con targetId)
- Fallimento: HTTP / messaggio di errore