Löschen von spärlichen raumkarten

EasyAR bietet zwei Methoden zum Umgang mit nicht mehr benötigten Raumkartendaten: dauerhaftes Löschen und vorübergehendes Deaktivieren. Um die Stabilität der Produktionsumgebung zu gewährleisten, empfehlen wir Ihnen, die folgenden Anweisungen sorgfältig zu lesen.

Löschen über EasyAR Web

Melden Sie sich im EasyAR-Entwicklungszentrum an -> SpatialMap -> Wählen Sie die entsprechende Map-Bibliothek -> Klicken Sie auf Verwalten, um zur Map-Bibliotheksverwaltung zu gelangen.
Klicken Sie auf die Raumkartendetailseite und dann auf die Schaltfläche Löschen.

Anleitung zum dauerhaften Löschen

Best Practice: Vorübergehendes Deaktivieren

In den meisten Geschäftsszenarien empfehlen wir, Deaktivieren anstelle von Löschen zu verwenden, wenn Sie unsicher sind, ob eine Karte in Zukunft noch benötigt wird.

Funktionsmerkmale: Deaktivierte Raumkarten verbleiben in der Datenbankliste, nehmen aber nicht am Erkennungs- und Lokalisierungsprozess teil. Sie belegen jedoch Erkennungskontingente.
Deaktivierungsmethode: Aktivieren Sie im Verwaltungsinterface das Kontrollkästchen der Raumkarte und klicken Sie auf Deaktivieren.

Anleitung zum Deaktivieren

API-Deaktivierung: Rufen Sie die Spatial Map Update API auf und setzen Sie das Attribut status auf inactive.

Löschen mit der API

Über die REST-API können spärliche Raumkarten automatisch bereinigt werden.

Vorbereitungen

Lesen Sie vor Beginn die Dokumentation zur Lösch-API für Spatial Map und bereiten Sie folgende Ressourcen vor:

Spatial Map AppId
API Key / Secret oder Token
Cloud-URL
- Benutzer aus China und Südostasien wählen: https://armap-api.easyar.com
- Andere Benutzer wählen: https://armap-api-na1.easyar.com
MapId: Die eindeutige ID der zu löschenden Karte. Wenn die MapId nicht existiert, gibt die API Http Status 404 zurück.

Bitte ersetzen sie platzhalter durch tatsächliche parameter, und führen sie curl skript aus

Your-Cloud-URL → Tatsächliche API-URLs
Your-Token → Tatsächlicher API-Schlüssel-Autorisierungs-Token
Your-SpatialMap-AppId → Ihre appId
Your-todo-MapId → Zu löschende MapId

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

Herunterladen der Java-Beispielcode

Java Samples Download

Importieren des Projekts über Maven

Step 1. Öffnen Sie das Codebeispiel RemoveMap.java

Step 2. Ändern Sie die globalen Variablen und ersetzen Sie die Authentifizierungsparameter aus Ihrer Vorbereitungsliste

SpatialMap AppId
API Key / API Secret
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= "--hier ist Ihre SpatialMap AppId--";
    private static final String API_KEY         = "--hier ist Ihr API Key--";
    private static final String API_SECRET      = "--hier ist Ihr API Secret--";
    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. Führen Sie Main aus

Schritt 1. Beispielcode in removemap.php kopieren

Ändern Sie die Authentifizierungsparameter auf Ihre tatsächlichen Ressourcen: Token, appId und Cloud-URL
Zu löschende Karten-ID (MapId)

<?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) {
        // Abfrageparameter erstellen
        $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 . "=== Löschanfrage erfolgreich ===" . PHP_EOL;
    if (isset($result['statusCode']) && $result['statusCode'] == 200) {
        echo "Result: " . json_encode($result['result'], JSON_PRETTY_PRINT) . PHP_EOL;
    }
} else {
    echo PHP_EOL . "=== Failed ===" . PHP_EOL;
}
?>

Schritt 2. Ausführen

php removemap.php

Erstellen Sie die entsprechende Code-Datei main.go, ändern Sie die globalen Variablen und führen Sie sie dann aus

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("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};

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. Signaturkomponenten
    let mut params = BTreeMap::new();
    params.insert("apiKey", API_KEY);
    params.insert("appId", APP_ID);
    params.insert("timestamp", &ts);

    // 2. Verkette Schlüssel und Werte, dann füge Geheimnis an
    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. Konstruiere URL und sende 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(())
}

Erstellen eines .NET-konsolenprojekts.

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. Parameter sortieren
        var dict = new SortedDictionary<string, string> {
            { "apiKey", API_KEY },
            { "appId", APP_ID },
            { "timestamp", timestamp }
        };

        // 2. Verkettung und anhängen des geheimen schlüssels
        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. DELETE-anfrage ausführen
        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($"Result: {await response.Content.ReadAsStringAsync()}");
    }

    static string Sha256(string str) {
        byte[] bytes = SHA256.HashData(Encoding.UTF8.GetBytes(str));
        return BitConverter.ToString(bytes).Replace("-", "").ToLower();
    }
}

Laufumgebung
- Unity 2020 LTS oder höher
- Scripting Backend: Mono oder IL2CPP
- API-Kompatibilitätsstufe: .NET Standard 2.1 (empfohlen)

Schritt 1: Bilddateien vorbereiten

Verzeichnis im Unity-Projekt erstellen:

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

Gemäß Assets-Verzeichnisnamen
- Beispielcode DeleteMap.cs unten kopieren

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

Im Unity-Editor:
- Ein leeres GameObject erstellen
- Benenne es DeleteMap
- Füge das DeleteMap-Skript an dieses Objekt an

Schritt 3: Parameter konfigurieren (Inspektor)

Im Inspektor-Bereich anpassen:
- Api-Url
- Autorisierungs-Token
- Spatial Map App-Id
- Map-Id: Zu löschende Map-ID (mapId)
Nur diese Werte müssen zum Ausführen geändert werden, verwende die vorbereiteten Parameter

Schritt 4: Ausführen

Auf Play klicken
Ergebnis in der Konsole prüfen:
- Erfolg: Gibt JSON zurück (mit result)
- Fehler: HTTP-/Fehlermeldung

Verwandte Themen:

Table of Contents

Löschen von spärlichen raumkarten

Löschen über EasyAR Web

Best Practice: Vorübergehendes Deaktivieren

Löschen mit der API

Vorbereitungen