Liste und Vorschau spärlicher Raumkarten

EasyAR Spatial Map speichert normalerweise große Mengen an Raumkartendaten. Dieses Kapitel beschreibt detailliert Methoden zum Abrufen von Spatial Map-Details und paginierten Listen.

Verwaltung spärlicher Karten über EasyAR Web

In der visuellen Oberfläche zeigt das System standardmäßig spärliche Karten in Form einer paginierten Liste an, sortiert in umgekehrter Reihenfolge nach dem letzten Änderungszeitpunkt (neueste Änderungen zuerst).

Spärliche Kartenliste

Pfad: Einloggen bei EasyAR Web [Entwicklerzentrum] -> [SpatialMap] -> Galerie auswählen -> Klicken auf [Verwalten].

Auf dieser Oberfläche können Sie folgende Aktionen durchführen:

Listenansicht: Anzeige der paginierten Spatial Map-Raumkartensammlung.
Detailzugang: Klicken Sie auf Schaltfläche 1 [Verwalten], um zur Kartendetailseite zu gelangen.
Präzise Suche: Im Eingabefeld 2 werden folgende Suchmethoden unterstützt:
- Suche nach Name: Wenn Ihr System Bilder nach Regeln benennt (z.B. interne App-ID), können Sie sie schnell über den Namen finden.
- Suche nach MapId
- Suche nach Label, GPS: Nur von der Such-API unterstützt

Spatial Map-Detailinformationen

Nach dem Aufruf der Detailseite sehen Sie die vollständigen Attribute der Spatial Map-Karte, darunter:

Vorschau: Preview-Bild.
Name: Spatial Map-Name.
MapId: Vom System generierte eindeutige ID.
Status: Aktiviert oder deaktiviert.
Label: Benutzerdefinierte Kennzeichnung zur einfacheren Suche, unterstützt die Search API-Schnittstelle
GPS: GPS-Position des Raums, benutzerdefiniertes Koordinatensystem, unterstützt die Search API-Schnittstelle
Benutzerdefinierte Meta: Metadaten, die dieser Spatial Map-Karte zugeordnet sind (z.B. Modell-URL)

detail

Verwenden der API zum Anzeigen der Spatial Map-Kartenliste

Für Entwickler, die in eigene Backends integrieren möchten, wird die Verwendung der REST API empfohlen.

Referenzdokumentation: Spatial Map-Kartenliste-API-Schnittstelle

Vorbereitungsliste

Stellen Sie vor der Anfrage sicher, dass Sie folgende Ressourcen haben (siehe API-Aufrufvorbereitungsliste):

SpatialMap AppId
API Key / Secret oder Token
Cloud-URL
- Nutzer in China und Südostasien: https://armap-api.easyar.com
- Andere Nutzer: https://armap-api-na1.easyar.com

Bitte ersetzen sie die platzhalter durch die tatsächlichen parameter und führen sie das curl-skript aus

Your-URL → Tatsächliche cloud-URL
Your-Token → Tatsächlicher API-schlüssel authorization token
Your-SpatialMap-AppId → Tatsächliche SpatialMap appId

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

Java-Beispielcode herunterladen

Java Samples Download

Projekt über Maven importieren

Schritt 1. Öffnen Sie das Codebeispiel ListMaps.java

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

SpatialMap AppId
API Key / API Secret
Cloud URL

ListMaps.java

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

public class ListMaps {

    private static final String CLOUD_URL       = "https://armap-api.easyar.com";
    private static final String APPID           = "--here is your SpatialMap AppId--";
    private static final String API_KEY         = "--here is your API Key--";
    private static final String API_SECRET      = "--here is your API Secret--";

    public String  toParam(JSONObject jso) {
        Set<String> keys = jso.keySet();
        StringBuffer sb   = new StringBuffer();
        for (String key : keys){
            sb.append(key);
            sb.append("=");
            sb.append(jso.getString(key));
            sb.append("&");
        }
        return sb.substring(0,sb.length()-1);
    }

    public String list(Auth auth) throws IOException {
        OkHttpClient client = new OkHttpClient.Builder().build();
        JSONObject params = new JSONObject();
        Auth.signParam(params, auth.getAppId(), auth.getApiKey(), auth.getApiSecret());
        okhttp3.Request request = new okhttp3.Request.Builder()
                .url(auth.getCloudURL() + "/maps?"+ toParam(params))
                .get()
                .build();
        Response response = client.newCall(request).execute();
        return response.body().string();
    }
    public static void main(String[] args) throws IOException{
        Auth accessInfo  =  new Auth(APPID, API_KEY, API_SECRET, CLOUD_URL);
        System.out.println(new ListMaps().list(accessInfo));
    }

}

Schritt 3. Führen Sie Main aus

Schritt 1. Kopieren Sie den Beispielcode in listmap.js, ändern Sie den Token, die appId und die Cloud-URL

Schritt 2. Führen Sie aus

npm install axios
node listmap.js

Um die Paging-Strategie zu ändern, übergeben Sie Paging-Parameter

pageSize: Seitengröße
pageNum: Seitennummer

const axios = require('axios');

class MapService {
    constructor(baseURL, token, appId) {
        this.baseURL = baseURL;
        this.token = token;
        this.appId = appId;
        this.client = axios.create({
            baseURL: baseURL,
            headers: {
                'Authorization': token,  
                'Content-Type': 'application/json'
            }
        });
    }

    async listMaps(params = {}) {
        try {
            const queryParams = {
                ...params,
                appId: this.appId 
            };

            const response = await this.client.get('/maps', { params: queryParams });
            
            console.log('=== API Response ===');
            console.log('Status Code:', response.status);
            console.log('Request URL:', response.config.url);
            console.log('Request Headers:', JSON.stringify(response.config.headers, null, 2));
            console.log('Request Params:', JSON.stringify(queryParams, null, 2));
            console.log('Response Data:', JSON.stringify(response.data, null, 2));
            console.log('Timestamp:', new Date().toISOString());
            
            return response.data;
        } catch (error) {
            console.error('=== API Error ===');
            if (error.response) {
                console.log('Status Code:', error.response.status);
                console.log('Error Data:', error.response.data);
            } else {
                console.log('Error Message:', error.message);
            }
            throw error;
        }
    }
}

async function main() {
    const config = {
        baseURL: 'https://armap-api-<cn1|na1>.easyar.com',
        token: 'your_token_here', 
        appId: 'your_app_id_here' 
    };

    const mapService = new MapService(config.baseURL, config.token, config.appId);
    
    const queryParams = {
        pageNum: 1,
        pageSize: 10
    };

    try {
        const result = await mapService.listMaps(queryParams);
        console.log('\n=== Success ===');
    } catch (error) {
        console.log('\n=== Failed ===');
    }
}

if (require.main === module) {
    main();
}

module.exports = MapService;

Schritt 1. Beispielcode in listmap.php kopieren, darin Token, appId und Cloud-URL anpassen

Schritt 2. Ausführen

php listmap.php

Falls Paginierung angepasst werden soll, Paginierungsparameter übergeben:

'pageSize': Seitengröße
'pageNum': Seitenzahl

<?php
class MapService {
    private $baseURL;
    private $token;
    private $appId;
    
    public function __construct($baseURL, $token, $appId) {
        $this->baseURL = $baseURL;
        $this->token = $token;
        $this->appId = $appId;
    }
    
    public function listMaps($params = []) {
        $queryParams = array_merge([
            'appId' => $this->appId
        ], $params);
        
        $queryString = http_build_query($queryParams);
        $url = $this->baseURL . '/maps?' . $queryString;
        
        $ch = curl_init();
        
        curl_setopt_array($ch, [
            CURLOPT_URL => $url,
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_HTTPHEADER => [
                'Authorization: ' . $this->token, 
                'Content-Type: application/json'
            ],
            CURLOPT_SSL_VERIFYPEER => false,
            CURLOPT_TIMEOUT => 30
        ]);
        
        $response = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        $error = curl_error($ch);
        
        echo "=== API Request ===" . PHP_EOL;
        echo "URL: " . $url . PHP_EOL;
        echo "Headers: Authorization: " . $this->token . PHP_EOL;
        echo "Query Params: " . json_encode($queryParams, JSON_PRETTY_PRINT) . PHP_EOL;
        
        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;
    }
}

// Configure your API Key Token and Your Spatial Map AppId
$config = [
    'baseURL' => 'https://armap-api-<cn1|na1>.easyar.com',
    'token' => 'your_token_here',   
    'appId' => 'your_app_id_here'   
];

$mapService = new MapService($config['baseURL'], $config['token'], $config['appId']);

$queryParams = [
    'pageNum' => 1,
    'pageSize' => 5
];

$result = $mapService->listMaps($queryParams);

if ($result) {
    echo PHP_EOL . "=== Erfolg ===" . PHP_EOL;
} else {
    echo PHP_EOL . "=== Fehlgeschlagen ===" . PHP_EOL;
}
?>

Erstelle eine neue zugehörige Codedatei list_map.py, ändere die globalen Variablen und führe dann aus

pip install requests
python list_map.py

import time
import hashlib
import requests

# --- Globale konfiguration ---
API_KEY = "YOUR_API_KEY"
API_SECRET = "YOUR_API_SECRET"
APP_ID = "YOUR_APP_ID"
HOST = "https://armap-api-<cn1|na1>.easyar.com"

def main():
    timestamp = str(int(time.time() * 1000))
    
    # 1. Prepare parameters
    params = {
        'apiKey': API_KEY,
        'appId': APP_ID,
        'timestamp': timestamp,
        'pageNum': '1',
        'pageSize': '10'
    }

    # 2. Signature Calculation
    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()

    # 3. Build Request
    url = f"{HOST}/maps"
    params['signature'] = signature

    print(f"Fetching Spatial Maps from {url}...")
    response = requests.get(url, params=params)
    print(f"Response: {response.text}")

if __name__ == "__main__":
    main()

Erstellen Sie die relevante Codedatei main.go, ändern Sie die globalen Variablen und führen 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"
)

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

  // 1. Sort keys
  keys := make([]string, 0, len(params))
  for k := range params { keys = append(keys, k) }
  sort.Strings(keys)

  // 2. Build string and sign
  builder := ""
  for _, k := range keys { builder += k + params[k] }
  builder += ApiSecret

  signature := fmt.Sprintf("%x", sha256.Sum256([]byte(builder)))

  // 3. Request
  url := fmt.Sprintf("%s/maps?apiKey=%s&appId=%s&timestamp=%s&pageNum=%s&pageSize=%s&signature=%s", 
    Host, ApiKey, AppId, ts, params["pageNum"], params["pageSize"], signature)
  
  resp, _ := http.Get(url)
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Printf("Response: %s\n", string(body))
}

Fügen Sie in der 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";

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

    // 1. Signatur-Komponenten in BTreeMap (nach Schlüssel sortiert)
    let mut params = BTreeMap::new();
    params.insert("apiKey", API_KEY);
    params.insert("appId", APP_ID);
    params.insert("timestamp", &ts);
    params.insert("pageNum", "1");
    params.insert("pageSize", "10");

    // 2. Verketten und Secret hinzufügen
    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. Anfrage
    let url = format!("{}/maps?apiKey={}&appId={}&timestamp={}&pageNum=1&pageSize=10&signature={}", 
                      HOST, API_KEY, APP_ID, ts, signature);
    
    let res = reqwest::get(url).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 async System.Threading.Tasks.Task Main() {
        string timestamp = DateTimeOffset.Now.ToUnixTimeMilliseconds().ToString();

        // 1. Sortierte Parameter aufbauen
        var dict = new SortedDictionary<string, string> {
            { "apiKey", API_KEY },
            { "appId", APP_ID },
            { "timestamp", timestamp },
            { "pageNum", "1" },
            { "pageSize", "10" }
        };

        // 2. Verketten und Secret anhängen
        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. GET-Anfrage ausführen
        using var client = new HttpClient();
        string query = string.Join("&", dict.Select(x => $"{x.Key}={x.Value}")) + $"&signature={signature}";
        string url = $"{HOST}/maps?{query}";
        
        var response = await client.GetAsync(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

Im Unity-Projekt ein Verzeichnis erstellen:

Assets/
└── Scripts/
     └── ListMap.cs

Gemäß dem Assets-Verzeichnisnamen
- Den folgenden Beispielcode ListMap.cs kopieren

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

public class ListMap : MonoBehaviour
{
    [Header("Config")]
    public string apiBaseUrl = "https://armap-api-<cn1|na1>.easyar.com";
    public string authorizationToken = "YOUR API KEY AUTH TOKEN";
    public string spatialMapAppId = "SpatialMap-AppId";
    public int pageSize = 5;
    public int pageNum  = 1;

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

    private IEnumerator ListMaps()
    {

        string url =
            $"{apiBaseUrl}/maps?appId={spatialMapAppId}&pageSize={pageSize}&pageNum={pageNum}";

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

Im Unity-Editor:
- Ein leeres GameObject erstellen
- Als ListMap benennen
- Das ListMap-Skript auf dieses Objekt ziehen

Schritt 3: parameter konfigurieren (Inspector)

Im Inspector-Panel anpassen:
- Api Url
- Authorization Token
- Spatial Map App Id
- page size
- page num
Nur diese Punkte müssen für die Ausführung angepasst werden, mit den vorbereiteten Parametern ausfüllen

Schritt 4: ausführen

Play drücken
Ergebnis in der Konsole prüfen:
- Erfolg: Gibt JSON zurück (enthält result)
- Fehler: HTTP-/Fehlermeldung

Nächstes Thema: