O EasyAR oferece duas maneiras de lidar com imagens de reconhecimento não mais necessárias: exclusão permanente e desativação temporária. Para garantir a estabilidade do ambiente de produção, recomendamos a leitura cuidadosa das instruções abaixo.
Na maioria dos cenários comerciais, se não tiver certeza sobre o uso futuro de uma imagem, recomendamos usar desativação em vez de exclusão.
A API REST permite limpeza automatizada de imagens de reconhecimento.
Por favor, substitua os espaços reservados pelos parâmetros reais e execute o script curl
- Your-Server-side-URL → Host da API real
- Your-Token → Token de autorização da API Key real
- Your-CRS-AppId → Seu appId
- Your-todo-TargetId → targetId do alvo a ser excluído
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>"
Baixar o código de exemplo Java
Importar o projeto via Maven
Step 1. Abrir o arquivo de código relevante RemoveTarget.java
Step 2. Modificar as variáveis globais, substituindo os parâmetros de autenticação da sua lista de preparação
- CRS AppId
- API Key / API Secret
- TARGET_MGMT_URL → URL do servidor
- TARGET_ID → targetId do alvo a ser excluído
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 lists all the targetIds to be removed
* must be separated by ","
*/
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. Executar o Main
Descarregar código de exemplo NodeJS
Step 1. Configurar o ficheiro de chaves 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--"
}
Step 2. Executar, especificando o ficheiro de chaves e o URL do servidor
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 chama a interface do serviço de nuvem, o código de exemplo está em farmer.js
function deleteTarget(targetId) {
return Q.promise(function(resolve, reject) {
request.del(host + '/target/' + targetId)
.query(signParams())
.end(done(resolve, reject));
});
}
Baixar código de exemplo Php
Passo 1. Abrir o código de entrada demo.php
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
- 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. Executar php demo.php
Crie o arquivo de código relevante delete_target.py, modifique as variáveis globais e execute
pip install requests
python delete_target.py
import time
import hashlib
import requests
# --- Configuração de variáveis globais ---
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()
Crie o arquivo de código relevante main.go, modifique as variáveis globais e execute
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×tamp=%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))
}
Adicione as dependências reqwest, tokio, sha2, hex em Cargo.toml.
Execute 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 ¶ms {
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={}×tamp={}&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(())
}
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 {
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 de execução
- Unity 2020 LTS ou superior
- Scripting Backend: Mono ou IL2CPP
- Nível de compatibilidade da API: .NET Standard 2.1 (recomendado)
Passo 1: preparar os arquivos de imagem
- Criar diretório no projeto Unity:
Assets/
└── Scripts/
└── DeleteImageTarget.cs
- Seguir o nome do diretório Assets
- Copiar o código de exemplo DeleteImageTarget.cs abaixo
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);
}
}
}
- No Unity Editor:
- Criar um GameObject vazio
- Nomeá-lo como DeleteTarget
- Arrastar o script DeleteImageTarget para este objeto
Passo 3: configurar parâmetros (Inspector)
Modificar no painel Inspector:
- Api Url
- Token de autorização
- Crs App Id
- Target Id: targetId do alvo de imagem a ser excluído
Basta modificar estes itens para executar, inserindo os parâmetros preparados anteriormente
Passo 4: executar
- Clicar em Play
- Verificar o resultado no Console:
- Sucesso: retorna JSON (contendo targetId)
- Falha: informações de erro HTTP
