Eliminazione mappe spaziali sparse

EasyAR offre due metodi per gestire dati di mappe spaziali non più necessari: eliminazione permanente e disattivazione temporanea. Per garantire stabilità in ambienti di produzione, si consiglia di leggere attentamente le seguenti istruzioni.

Tramite EasyAR Web

Accedi al centro di sviluppo EasyAR -> SpatialMap -> Seleziona la libreria di mappe corrispondente -> Clicca Gestisci per accedere all'interfaccia di gestione libreria.
Accedi alla pagina dei dettagli della mappa spaziale, clicca il pulsante Elimina nella pagina.

Guida operativa eliminazione permanente

Migliori pratiche: disattivazione temporanea

Nella maggior parte degli scenari operativi, se non sei sicuro di utilizzare nuovamente una mappa in futuro, si consiglia di usare disattiva invece di elimina.

Caratteristiche: Le mappe spaziali disattivate rimangono nell'elenco del database ma non partecipano al processo di riconoscimento e localizzazione. Tuttavia, occupano quota di riconoscimento.
Metodo di disattivazione: Nell'interfaccia di gestione, seleziona la mappa, clicca Disattiva.

Guida operativa disattivazione

Disattivazione tramite API: Chiamando l'API Aggiorna Spatial Map, imposta l'attributo status su inactive.

Utilizzo API per eliminazione

L'API REST consente la pulizia automatizzata delle mappe spaziali sparse.

Preparazione

Prima di iniziare, leggi la documentazione Elimina Spatial Map API e prepara:

Spatial Map AppId
API Key / Secret o Token
Cloud URL
- Utenti Cina e Sud-est asiatico: https://armap-api.easyar.com
- Altri utenti: https://armap-api-na1.easyar.com
MapId: ID univoco della mappa da eliminare. Se MapId non esiste, l'API restituirà Http Status 404.

Sostituire i segnaposto con parametri reali ed eseguire lo script curl

Your-Cloud-URL → URL API effettivi
Your-Token → Token di autorizzazione API Key effettivo
Your-SpatialMap-AppId → Il tuo appId
Your-todo-MapId → MapId da eliminare

curl -X DELETE "https://armap-api-<cn1|na1>.easyar.com/map/<Your-todo-MapId>?appId=<Your-SpatialMap-AppId>" \
  -H "Content-Type: application/json" \
  -H "Authorization: <Your-Token>"

Scarica esempio codice java

Java Samples Download

Importa il progetto tramite Maven

Step 1. Apri il codice di esempio RemoveMap.java

Step 2. Modifica le variabili globali, sostituisci con i parametri di autenticazione della tua manifattura

SpatialMap AppId
Chiave API / Segreto API
Cloud URL

RemoveMap.java

import okhttp3.*;
import org.json.JSONObject;
import java.io.IOException;
import java.util.Set;

public class RemoveMap {

    private static final String CLOUD_URL       = "https://armap-api-<cn1|na1>.easyar.com";
    private static final String SPATIALMAP_APPID= "--qui il tuo SpatialMap AppId--";
    private static final String API_KEY         = "--qui la tua chiave API--";
    private static final String API_SECRET      = "--qui il tuo segreto API--";
    private static final String MAPID           = "my_mapId";

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

    public static void main(String[] args) throws IOException{
        Auth accessInfo  =  new Auth(SPATIALMAP_APPID, API_KEY, API_SECRET, CLOUD_URL);
        System.out.println(new RemoveMap().remove(accessInfo, MAPID));
    }
}

Step 3. Esegui Main

Passo 1. Copia il codice di esempio in removemap.php

Modifica i parametri di autenticazione con le tue risorse effettive: Token, appId e Cloud URL
Mappa MapId da eliminare

<?php
class MapDeleteService {
    private $baseURL;
    private $token;
    private $appId;
    
    public function __construct($baseURL, $token, $appId) {
        $this->baseURL = $baseURL;
        $this->token = $token;
        $this->appId = $appId;
    }
    
    public function deleteMap($mapId) {
        // Costruisci i parametri di query
        $queryParams = [
            'appId' => $this->appId
        ];
        
        $queryString = http_build_query($queryParams);
        $url = $this->baseURL . '/map/' . urlencode($mapId) . '?' . $queryString;
        
        $ch = curl_init();
        curl_setopt_array($ch, [
            CURLOPT_URL => $url,
            CURLOPT_CUSTOMREQUEST => 'DELETE',
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_HTTPHEADER => [
                'Authorization: ' . $this->token,
                'Content-Type: application/json'
            ],
            CURLOPT_SSL_VERIFYPEER => false,
            CURLOPT_TIMEOUT => 30
        ]);
        
        echo "=== API Request ===" . PHP_EOL;
        echo "URL: " . $url . PHP_EOL;
        echo "Method: DELETE" . PHP_EOL;
        echo "Headers: Authorization: " . $this->token . PHP_EOL;
        echo "Query Params: " . json_encode($queryParams, JSON_PRETTY_PRINT) . PHP_EOL;
        
        $response = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        $error = curl_error($ch);
        
        curl_close($ch);
        
        echo "=== API Response ===" . PHP_EOL;
        echo "Status Code: " . $httpCode . PHP_EOL;
        echo "Timestamp: " . date('c') . PHP_EOL;
        
        if ($error) {
            echo "cURL Error: " . $error . PHP_EOL;
            return null;
        }
        
        $responseData = json_decode($response, true);
        echo "Response Data: " . json_encode($responseData, JSON_PRETTY_PRINT) . PHP_EOL;
        
        return $responseData;
    }
}


$mapId = 'your_map_id_here';
$config = [
    'baseURL' => 'https://armap-api-cn1.easyar.com',
    'token' => 'your_token_here',
    'appId' => 'your_app_id_here'
];

$mapDeleteService = new MapDeleteService($config['baseURL'], $config['token'], $config['appId']);

$result = $mapDeleteService->deleteMap($mapId);

if ($result) {
    echo PHP_EOL . "=== Richiesta di eliminazione riuscita ===" . PHP_EOL;
    if (isset($result['statusCode']) && $result['statusCode'] == 200) {
        echo "Result: " . json_encode($result['result'], JSON_PRETTY_PRINT) . PHP_EOL;
    }
} else {
    echo PHP_EOL . "=== Fallito ===" . PHP_EOL;
}
?>

Passo 2. Esegui

php removemap.php

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://armap-api-<cn1|na1>.easyar.com"
  MapId     = "YOUR_MAP_ID"
)

func main() {
  ts := strconv.FormatInt(time.Now().UnixNano()/1e6, 10)
  params := map[string]string{
    "apiKey":    ApiKey,
    "appId":     AppId,
    "timestamp": ts,
  }

  keys := []string{"apiKey", "appId", "timestamp"}
  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/map/%s?apiKey=%s&appId=%s&timestamp=%s&signature=%s", 
    Host, MapId, 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 reqwest, tokio, sha2, hex come dipendenze 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://armap-api-<cn1|na1>.easyar.com";
const MAP_ID: &str = "YOUR_MAP_ID";

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let ts = SystemTime::now().duration_since(UNIX_EPOCH)?.as_millis().to_string();

    // 1. Componenti della firma
    let mut params = BTreeMap::new();
    params.insert("apiKey", API_KEY);
    params.insert("appId", APP_ID);
    params.insert("timestamp", &ts);

    // 2. Concatenare chiavi e valori, quindi aggiungere il segreto
    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());

    // 3. Costruire l'URL e inviare DELETE
    let url = format!("{}/map/{}?apiKey={}&appId={}&timestamp={}&signature={}", 
                      HOST, MAP_ID, API_KEY, APP_ID, ts, signature);
    
    let res = reqwest::Client::new().delete(url).send().await?;
    println!("Response: {}", res.text().await?);
    Ok(())
}

Creazione 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 = "YOUR_API_KEY";
    static string API_SECRET = "YOUR_API_SECRET";
    static string APP_ID = "YOUR_APP_ID";
    static string HOST = "https://armap-api-<cn1|na1>.easyar.com";
    static string MAP_ID = "YOUR_MAP_ID";

    static async System.Threading.Tasks.Task Main() {
        string timestamp = DateTimeOffset.Now.ToUnixTimeMilliseconds().ToString();

        // 1. Ordina i parametri
        var dict = new SortedDictionary<string, string> {
            { "apiKey", API_KEY },
            { "appId", APP_ID },
            { "timestamp", timestamp }
        };

        // 2. Concatena e aggiungi il Secret
        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());

        // 3. Esegui la richiesta DELETE
        using var client = new HttpClient();
        string query = string.Join("&", dict.Select(x => $"{x.Key}={x.Value}")) + $"&signature={signature}";
        string url = $"{HOST}/map/{MAP_ID}?{query}";
        
        var response = await client.DeleteAsync(url);
        Console.WriteLine($"Risultato: {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: Preparare i file immagine

Creare una directory nel progetto Unity:

Assets/
└── Scripts/
     └── DeleteMap.cs

Secondo il nome della directory Assets
- Copiare il codice di esempio DeleteMap.cs qui sotto

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

public class DeleteMap : MonoBehaviour
{
    [Header("Config")]
    public string mapId = "Your mapId";
    public string apiBaseUrl = "https://armap-api-<cn1|na1>.easyar.com";
    public string authorizationToken = "YOUR API KEY AUTH TOKEN"; 
    public string spatialMapAppId = "Your Spatial Map appId"; 
    
    private void Start()
    {
        StartCoroutine(DeleteAMap());
    }

    private IEnumerator DeleteAMap()
    {
     
        string url =
            $"{apiBaseUrl}/map/{mapId}?appId={spatialMapAppId}";

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

In Unity Editor:
- Creare un GameObject vuoto
- Denominarlo DeleteMap
- Trascinare lo script DeleteMap sull'oggetto

Passo 3: Configurare i parametri (Inspector)

Modificare nel pannello Inspector:
- Api Url
- Authorization Token
- Spatial Map App Id
- Map Id: mapId della mappa da eliminare
Modificare solo questi campi per eseguire, inserendo i parametri preparati

Passo 4: Eseguire

Fare clic su Play
Controllare il risultato nella Console:
- Successo: Restituisce JSON (contenente result)
- Fallimento: HTTP / Messaggio di errore

Argomenti correlati:

Table of Contents

Eliminazione mappe spaziali sparse

Tramite EasyAR Web

Migliori pratiche: disattivazione temporanea

Utilizzo API per eliminazione

Preparazione