Auf dieser Seite

KI-Agent bauen: Geländeanalyse in MilX entwerfen

Tutorial 15 von 17 · Experten · 60 min

Geben Sie einem KI-Agenten ein Gebiet und einen Auftrag und erhalten Sie eine .milxlyz-Datei zurück, in der Hindernisse, Annäherungswege, Schlüsselgelände und Beobachtung bereits gezeichnet sind – ein erster Entwurf, den Sie in map.army prüfen und fertigstellen.

Der Agent tut genau das, was die manuelle Geländeanalyse tut, in derselben OAKOC-Reihenfolge. Arbeiten Sie zuerst jenes Tutorial durch: Sie können den Entwurf des Agenten nur beurteilen, wenn Sie wissen, wie ein guter aussieht.

Was Sie brauchen

• Einen KI-Agenten, der Werkzeuge ausführen und Dateien schreiben kann – zum Beispiel Claude Code oder einen Agenten, den Sie auf einer KI-API aufbauen.
• Python 3 für den Dateischreiber unten und Zugang zu Geländedaten für Ihr Gebiet (siehe Schritt 3).
• Das Beispiel terrain-analysis-example.milxlyz als Vorlage für den Agenten.
• Einen KI-Dienst, den Ihre Organisation für die betroffenen Daten freigegeben hat.

Wie der Agent arbeitet

Ein Sprachmodell kann das Gelände nicht sehen. Bittet man es, eine Geländeanalyse aus dem Gedächtnis zu erstellen, erfindet es plausible Flüsse und Kämme. Ein zutreffender Entwurf braucht deshalb drei Teile:

1. Datenwerkzeuge, die echte Geländefakten für das Gebiet liefern: Höhe (um steile Hänge zu finden), Flüsse, Wälder, bebaute Gebiete, Strassen und Brücken.
2. Das Modell, das die OAKOC-Regeln auf diese Fakten anwendet und entscheidet, was zu zeichnen ist.
3. Einen Schreiber, der die Entscheidungen in eine gültige MilX^®-Datei umsetzt – von Code geschrieben, nicht vom Modell getippt, damit das Format immer stimmt.

map.army kommt erst am Ende ins Spiel: Sie laden die fertige Datei und prüfen sie dort.

Schritt 1: Dem Agenten das Format beibringen

Ein MilX-Layer ist XML, als Layer.milxly in eine .milxlyz gezippt. Jede Grafik ist ein MIL-STD-2525C-Symbolcode mit ihren Textmodifikatoren, dazu eine Punktliste. Geben Sie dem Agenten die Beispieldatei und diese Regeln in seinen Anweisungen mit:

• Jeder Symbolcode hat genau 15 Zeichen. Das 2. Zeichen ist die Gesinnung (F Freund, H Feind), das 4. der Status (P vorhanden, A erwartet).
• Punkte sind WGS84: X ist die Länge, Y die Breite.
• Mehrpunkt-Grafiken haben eine Punktreihenfolge: Eine Angriffsachse nimmt zuerst die Spitze, dann den Anfang, dann einen Punkt hinter der Spitze, der die Breite der Pfeilspitze festlegt.
• Attributwerte werden vom MSS^® geprüft. Ein falscher Wert – 60, wo drei Ziffern verlangt sind – lässt das Symbol verschwinden. Lassen Sie den Agenten nur den Textmodifikator T verwenden, solange Sie andere nicht geprüft haben.

Den vollständigen Hintergrund finden Sie unter KI mit map.army: MilX-Dateien erzeugen und auswerten und MilX-Dateiformat — Austauschformat von map.army.

Schritt 2: Ein festes Symbolvokabular vorgeben

Lassen Sie das Modell Symbole nicht frei wählen. Geben Sie ihm diese Tabelle und weisen Sie es an, nichts anderes zu verwenden:

Jeder Code stammt aus der Liste der MIL-STD-2525C-Symbole. Der Text T nennt den Grund: NO-GO Hänge über 45 %, K1 Brücke La Punt.

Schritt 3: Mit echten Geländedaten versorgen

Geben Sie dem Agenten Werkzeuge, die Fakten liefern, keine Karten. Gängige offene Quellen:

• Höhe – ein digitales Höhenmodell wie Copernicus DEM oder das Modell Ihrer nationalen Landestopografie. Das Werkzeug berechnet Neigungsklassen für das Gebiet: zum Beispiel GO unter 30 %, SLOW-GO 30–45 %, NO-GO über 45 % für Kettenfahrzeuge. Legen Sie die Schwellenwerte für Ihre Fahrzeuge fest.
• Gewässer, Wald, bebaute Gebiete, Strassen, Brücken – OpenStreetMap über die Overpass-API oder Ihre nationalen topografischen Daten.

Weisen Sie den Agenten dann in einfachen Worten an:

Einsatzgebiet: West 9.84, Süd 46.54, Ost 10.03, Nord 46.66 (WGS84).
Auftrag: Das Tal gegen einen Gegner verteidigen, der aus Nordosten vorrückt.
1. Rufe das Höhenwerkzeug und das Kartendatenwerkzeug für das Gebiet auf.
2. Markiere NO-GO-Hangflächen und lineare Hindernisse (Flüsse) anhand der Daten.
3. Leite die gegnerischen Annäherungswege zwischen den Hindernissen ab,
   breit genug für eine mechanisierte Kompanie.
4. Markiere Schlüsselgelände (Brücken, Kreuzungen, beherrschende Höhen) und
   einen Beobachtungsposten pro Annäherungsweg; ein NAI dort, wo sich
   jeder Annäherungsweg verengt.
5. Gib die Grafiken als Liste für den Schreiber zurück. Verwende nur die
   Symboltabelle, die du erhalten hast. Gib für jede Grafik einen Grund in T an.

Schritt 4: Die Datei mit Code schreiben

Der Agent übergibt seine Liste an einen kleinen Schreiber, der jede Grafik prüft, bevor er irgendetwas schreibt. Dieser Schreiber hat die Beispieldatei erzeugt:

import io, re, zipfile
from xml.sax.saxutils import escape

SIDC = re.compile(r"^[SG][FHNU][A-Z][PA][A-Z-]{11}$")

def check(sidc, points, bbox):
    if not SIDC.match(sidc):
        raise ValueError(f"not a 15-character 2525C code: {sidc}")
    need = 2 if sidc[4:7] == "OGL" else 3 if sidc[4:6] in ("OL", "OG", "SA") else 1
    if len(points) < need:
        raise ValueError(f"{sidc}: needs at least {need} points")
    west, south, east, north = bbox
    for lon, lat in points:
        if not (west <= lon <= east and south <= lat <= north):
            raise ValueError(f"{sidc}: {lon},{lat} is outside the area")

def graphic(sidc, points, attributes):
    symbol = f'<Symbol ID="{sidc}">' + "".join(
        f'<Attribute ID="{k}">{escape(v)}</Attribute>' for k, v in attributes.items()
    ) + "</Symbol>"
    pts = "".join(f"<Point><X>{x:.6f}</X><Y>{y:.6f}</Y></Point>" for x, y in points)
    return (f"<MilXGraphic><MssStringXML>{escape(symbol)}</MssStringXML>"
            f"<PointList>{pts}</PointList></MilXGraphic>")

def write_layer(path, name, graphics, bbox):
    for g in graphics:
        check(g[0], g[1], bbox)
    xml = ('<?xml version="1.0" encoding="UTF-8" standalone="no"?>'
           '<MilXDocument_Layer xmlns="http://gs-soft.com/MilX/V3.1" '
           'xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">'
           "<MssLibraryVersionTag>2025.02.20</MssLibraryVersionTag>"
           f"<MilXLayer><Name>{escape(name)}</Name><LayerType>Normal</LayerType>"
           "<GraphicList>" + "".join(graphic(*g) for g in graphics) + "</GraphicList>"
           "<CoordSystemType>WGS84</CoordSystemType><ViewScale>0.1</ViewScale>"
           "<SymbolSize>1</SymbolSize></MilXLayer></MilXDocument_Layer>")
    buffer = io.BytesIO()
    with zipfile.ZipFile(buffer, "w", zipfile.ZIP_DEFLATED) as z:
        z.writestr("Layer.milxly", xml)
    with open(path, "wb") as f:
        f.write(buffer.getvalue())

write_layer("terrain-analysis.milxlyz", "Terrain analysis (AI draft)", [
    ("GFMPOGL--------", [(9.885, 46.552), (9.925, 46.578), (10.0, 46.625)], {"T": "Inn"}),
    ("GHGPOLAG-------", [(9.89, 46.562), (10.01, 46.64), (9.90, 46.574)], {"T": "AA 1"}),
    ("GFGPGPRI-------", [(9.928, 46.582)], {"T": "K1 bridge La Punt"}),
], bbox=(9.84, 46.54, 10.03, 46.66))

Laden Sie das Ergebnis mit MilX Layer laden im Layer-Manager oder veröffentlichen Sie es auf einem Webserver und öffnen Sie es mit einem ?layer=-Link.

Schritt 5: Den Entwurf prüfen, bevor Sie ihm vertrauen

Die Datei lässt sich auch dann laden, wenn die Analyse falsch ist. Prüfen Sie sie auf der Karte, am besten in der 3D-Ansicht:

• Liegt jedes NO-GO-Gebiet wirklich auf steilem Gelände oder Wasser, und fehlt keine Lücke dazwischen?
• Verläuft jeder Annäherungsweg zwischen den Hindernissen, in der richtigen Richtung, mit der Spitze am Ziel?
• Liegt jeder Schlüsselgelände-Punkt auf der Brücke, der Kreuzung oder der Höhe, die sein Text nennt?
• Korrigieren Sie in map.army, was falsch ist, ergänzen Sie, was die Daten nicht wissen können – das Wetter, die Ausrüstung des Gegners – und speichern Sie den Layer als Ihren eigenen.

Der Agent erspart Ihnen das Zeichnen, nicht das Urteil. Die Analyse ist fertig, wenn ein Mensch sie geprüft hat.

Nächstes Tutorial

Weiter mit NVG-Austausch mit C2, um die fertige Analyse an andere Systeme zu übergeben. Referenz: KI mit map.army: MilX-Dateien erzeugen und auswerten, Layer importieren: MilX, Vektor- und Bildgrafiken, MilX-Layer per URL-Parameter in map.army laden.