Iwan7 - Aufruf Urls

Alle Aufrufe erfolgen in der Form http://<host>:<port>/iwan/{ProjektName}/xx, wobei xx eine der unten aufgeführten Endpunkte darstellt. Der Standard-Port ist 8287

Der Projektname ist dabei optional, wird kein Projekt angegeben, wird das Projekt $default verwendet.

Ein Projekt dient der Trennung der Ebenen. Es sind keine Projektübergreifenden Zugriffe möglich. Der Name der Ebene ist pro Projekt eindeutig.

Wenn die Url mit /no_trace/ beginnt, wird der Aufruf nicht protokolliert.

Folgende Aktionen stehen zur Verfügung:

Zusatzinformationen können per Http-Header an den Server mit übermittelt werden:

  • x-iwan-project
  • x-iwan-username
  • x-iwan-groupnames

Wird ein Projektname per Http-Header übergeben, wird dieser bevorzugt verwendet.

Der Benutzername und die Gruppennamen (Komma-getrennt) werden dem Aufrufkontext zur Verfügung gestellt und können z.B. bei Datenbankabfragen mit verwendet werden.

Um Aktivitäten in Gruppen zusammenzufassen, die dann abbrechbar sind, kann der Header

  • x-iwan-activitygrouptoken

übergeben werden. Damit werden die Aktivitäten für die Dauer das Vorgangs in einer Gruppe zusammengefasst.


Rund um Ebenen

Laden von Ebenen

Endpunkt: /json/load

Encoding: POST (application/json)

Lädt eine oder mehrere Ebenen. Erwartet wird eine Array von Ebenendefinitionen im Json Format. Siehe dazu die Beschreibung zu den verfügbaren Datenquellen, bzw. den allgemeinen Hinweisen zu JSON Format der Ebenenbeschreibung.

Als Antwort wird eine Beschreibung der Ebenen geliefert.


Neuladen von Ebenen

Endpunkt: /json/reinitialize

Encoding: GET/POST (application/x-www-form-urlencoded)

Lädt die Ebene neu. Diese Funktion ist vor allem für die Nutzung im Zusammenhang mit den Ergebnissen aus json/layersreinitrequired sinnvoll.

Argumente:
  • layer: Name der Ebene

Als Antwort wird eine Beschreibung der Ebene mit dem zusätzlichem Attribut bool:wasReloaded geliefert.


Entladen von Ebenen

Endpunkt: /unload

Encoding: GET/POST (application/x-www-form-urlencoded)

Entlädt die Ebene aus dem Projekt, sofern vorhanden. Zurückgegeben wird ein Array von Zahlenwerten, die die Verwendung der Ebenen anzeigen (der Unload kann u.U. erst mit der letzten Referenz auf die Ebene erfolgen)

Argumente:
  • layer: Name der Ebene

oder

  • layers: Namen der Ebenen, kommagetrennt

Abrufen der Ebenen-Informationen

Endpunkt: /json/layers

Encoding: GET

Ruft Informationen über geladene Ebenen ab, gibt Array oder ein Einzelobjekt (bei Verwendung von layer) zurück.

Argumente:
  • embedDefaultCss (false): Css mit abrufen

  • layer (null): Name der Ebene, ist diese nicht vorhanden wird eine LayerNotFound Exception geliefert

... oder ...

  • layers (null): Komma getrennte Liste der Ebenen, nicht vorhandene Ebenen werden ignoriert

Wird weder layer oder layers angegeben, werden alle Ebenen zurückgegeben.

Beachte, dass bei layer ein Einzel-Objekt, bei den anderen Optionen immer ein Array zurückgeliefert wird.

Beispiel-Ausgabe:

[
  {
    "layerName": "STR",
    "primarySource": "D:\\TEMP\\STRAS.shp",
    "secondSource": "",
    "title": "",
    "description": "Shape-Datei",
    "featureCount": 13371,
    "subLayers": [],
    "primarySourceLastModified": "2015-02-15T15:11:42.331Z",
    "displayScaleRange": {
      "minimum": 0,
      "maximum": 0
    },
    "envelope": {
      "epsgCode": 31469,
      "minx": 5400673.414,
      "miny": 5649421.5315,
      "maxx": 5427367.4021,
      "maxy": 5671795.5065
    },
    "supportsCssStyling": true,
    "defaultCss": "",
    "supportedStyle": 1,
	"querySupport": 3,
    "type": "VectorLayer",
    "detailedType": "Shapefile",
    "attributs": [
      {
        "name": "ShapeRowId",
        "type": "Int32",
        "flags": "UniqueValues, HasIndex, IsNotNull, ComputedColumn, RowId",
        "length": -1,
        "ordinal": 0
      },
      {
        "name": "ShapeGeometry",
        "type": "Geom",
        "flags": "HasIndex",
        "length": -1,
        "ordinal": 1
      },
      {
        "name": "CLASS",
        "type": "Int32",
        "flags": "Default",
        "length": 8,
        "ordinal": 0
      }
    ],
    "loadedAt": "2017-06-03T07:49:38.137Z",
    "loadingDurationMs" : 80

  }
]

Suchen von Ebenen anhand der Quell-Datei

Endpunkt: /json/findlayers

Encoding: GET/POST (application/x-www-form-urlencoded)

Ermittelt die Ebenennamen, die als Datenquelle mind. eine mit filePattern übereinstimmende Datei verwenden.

Zurückgegeben wird ein Dictionary mit Projekt-Name als Schlüssel und der Liste der gefundenen Ebenennamen in diesem Projekt.

Argumente:
  • lookInAllProjects (false): wenn true, dann wird in allen Projekten gesucht, sonst nur im aktuellen

  • filePattern : Teil des gesuchten Dateinamen, kann * oder ? als Platzhalter enthalten. Intern sind die Dateinamen immer absolut. In dieser Methoden werden auch temp. erstellte Dateien mit gesucht (z.B. die Cache-Datenbank einer DXF Datei).

    Durch | können mehrere Muster übergeben werden.

Beispiel-Ausgabe:

{"REF":[
  "L1",
  "L2"
]}

Suchen von Ebenen, die neu geladen werden müssen

Endpunkt: /json/layersreinitrequired

Encoding: GET/POST (application/x-www-form-urlencoded)

Ermittelt die Ebenennamen, deren Quelle sich seit dem Laden geändert hat und die neu geladen werden müssen.

Zurückgegeben wird ein Dictionary mit Projekt-Name als Schlüssel und der Liste der gefundenen Ebenennamen in diesem Projekt.

Argumente:
  • lookInAllProjects (false): wenn true, dann wird in allen Projekten gesucht, sonst nur im aktuellen

Beispiel-Ausgabe:

{"REF":[
  "L1",
  "L2"
]}

Prüfen, ob Ebene(n) vorhanden ist/sind

Endpunkt: /json/layerExists

Encoding: GET/POST (application/x-www-form-urlencoded)

Gibt in einer Bitmaske für jeden angefragten Layer zurück, ob dieser aktuell im aktiven Projekt geladen ist (0=nicht vorhanden, 1 = vorhanden)

Argumente:
  • layers : Komma-getrennte Liste, der zu prüfenden Ebenen

Bsp.:

/iwan/{project}/json/layerExits?layers=A,B,C

Ausgabe:

010


Anrufen aller Quelldateien einer Ebene

Endpunkt: /json/layerSourceFiles

Encoding: GET/POST (application/x-www-form-urlencoded)

Gibt ein String-Array aller Dateinamen der Quelle zurück (absoluter Pfad).

Argumente:
  • layer : Name der Ebenen
  • includeTempFiles (false): auch temp. Dateien mit zurückliefern.

Anrufen der Zeichen-Statistik

Endpunkt: /json/renderstats

Encoding: GET/POST (application/x-www-form-urlencoded)

Gibt alle verfügbaren Ebenen Zeicheninformationen im aktuellen Projekt zurück, optional gefiltert auf die MapRenderId (siehe.

Antwort ist ein Array von Die Statistik pro Zeichenvorgang wird maximal nach 1 Minute lang vorgehalten.

Argumente:
  • ids (): Kommagetrennte Liste der MapRenderIds aus dem aktivem Projekt (wenn leer, werden alle aktuellen Einträge geliefert)
  • remove (false): die vom Abruf betroffenen Einträge löschen.

Rund um Snapshots

Erstellen / Aktualisieren

Endpunkt: /json/snapshot/create

Encoding: GET/POST (application/x-www-form-urlencoded)

Erstellt oder modifiziert die Daten eines Snapshots. Zurückgegeben wird die Beschreibung der erstellten, bzw. aktualisierten Snapshot-Ebene.

Argumente:
  • layer: Name der Quell-Ebene

  • snapshotid: Id des Snapshots, darf nicht mit dem Namen einer vorhandene Ebene kollidieren

  • filter: Filter, optional, als Json

  • mode: Einer der Werte Replace, Remove, Append

Löschen eines Snapshots

Endpunkt: /json/snapshot/snapshotDelete

Encoding: GET/POST (application/x-www-form-urlencoded)

Löscht einen Snapshot mitsamt der Daten. Die Methode hat keine Rückgabe.

Argumente:
  • layer: Name der Quell-Ebene

  • snapshotids: Ids der Snapshots, optional (Komma getrennte Liste)

  • byCaller: Bool, schließt sich mit snapshotids aus, wenn übergeben, dann alle Snapshots mit der callerId

Abrufen der Snapshots

Endpunkt: /json/snapshot/getid

Encoding: GET

Gibt die Snapshot-Ids für die aktuelle callerId zurück.


Karten und Symbolik

Abrufen von Kartenbildern.

Endpunkt: /render

Encoding: GET/POST (application/x-www-form-urlencoded)

Generiert ein Kartenbild durch Rendern der angegebenen Ebenen und sendet das Ergebnis als PNG Bild zurück. Im Antwort-Header werden zudem Informationen über den Zeichenvorgang zurückgegeben.

Argumente:
  • targetEpsg (0) : Zieltransformation

  • width: physische Breite in Pixeln

  • height: physische Höhe in Pixeln

  • scaleFactor (1.0): Auflösung

  • layers: Komma getrennte Liste der zu zeichnenden Ebenennamen

  • bbox: Komma getrennte in der Form "x,y,x,y,epsg", wenn nicht angegeben, dann wird die Ausdehnung der layers verwendet Die Bounding Box wird an das Höhen- und Breitenverhältnis der physischen Bildgröße angepasst.

  • RenderEngine (Agee): Gdiplus|Direct2d|Agee

IDU Intern:

In .Net gibt es eine Hilfsfunktion mit deren Hilfe sich die Kachelparameter (Anzahl, Größe, Position, BoundingBox) berechnen lassen.

Datei: Rendering\RendererUtils.h

Namespace: IduIT.GeoLib.Net.Rendering.RendererUtils

Klasse: MapParameterCalculator

Funktion:

  • ComputeTileSetParameter: Berechnet die Parameter aller Bildkacheln
Abruf rotierter Kartenbilder:

Es können auch rotierte Kartenbilder abgerufen werden. Dies ist hier im Detail beschrieben.

Layer-spezifische Argumente
  • scr:{layerName}: Überschreibt die Min/Max Maßstabsbereiche (Scale-Range). Die Angabe erfolgt in der Form "min,max", wobei die Werte auch fehlen dürfen.

  • flt:{layerName}: Ein Filter, der für diese Ebene beim Zeichenvorgang mit übergeben werden kann. Dieser wird mit dem BBox Filter mit UND kombiniert. Es kann dabei ein Filter-JSON übergeben werden, oder ein einfache Ausdruck in der Form "Spalte = Wert". Das Json wird als solches erkannt, wenn der Text mit "{" beginnt und mit "}" endet.

    Bsp. für Filter als JSON:

    {
      "filter": {
        "or": {
      	"whereGeom": {
      		"column": "shapegeometry",
      		"is": "DefaultRelateT8Stars",
      		"values": [
      			"SRID=25833;POLYGON((379765.36344379 5652930.59893910,379765.36344379 5663326.03478588,387714.81438545 5663326.03478588,387714.81438545 5652930.59893910,379765.36344379 5652930.59893910))"
      		]
      	},
      	"where": {
      		"column": "KREIS",
      		"behavior": "CompareStringsCaseInSensitiv",
      		"is": "Like",
      		"values": [
      			"%görlitz%"
      		]
      	}
      }
      }
    }
    
  • css:{layerName} | cssFile:{layerName}: optionaler Stile für diese Ebene, css wird gegenüber cssFile bevorzugt.

  • sublayers:{layerName} : Komma-getrennte Liste der darzustellenden Sublayer der Ebene

Antwort-Header

Folgende Http-Header werde im Ergebnis der Kartenanforderung mit zurückgegeben:

  • IwanImageInfo - Map
  • IwanImageType - Png24
  • IwanImageState - <UnknownDrawState|EmptyImage|Complete|Failed|SomeErrors>, ms
  • IwanImageSize - width,height,physicalWidth,0|1 (Scaled)
  • IwanImageBBox - xmin,ymin,xmax,ymax,epsgCode
  • IwanImageMapScale - scale
  • IwanImageTimeSinceReq - {nMilliseconds)
  • IwanImageRenderEngine - GdiPlus|Direct2D|Agge

Abrufen von Kartenbildern (Argumente als Json).

Endpunkt: /json/render

Encoding: POST (application/json)

Encoding: GET (mit Paramter json=..)

Generiert ein Kartenbild durch Rendern der angegebenen Ebenen und sendet das Ergebnis als PNG Bild zurück. Im Antwort-Header werden zudem Informationen über den Zeichenvorgang zurückgegeben.

Erwartet wird eine Anforderung als MapRenderRequest

Verhält sich sonst identisch mit render.

Abrufen von Legenden-Bildern

Endpunkt: /legend

Encoding: GET/POST (application/x-www-form-urlencoded)

Erstellt ein Legenden-Symbol aus dem übergeben Css und liefert dieses als PNG Bild zurück

Im http-Header "IwanLegImageInfo" wird leerzeichengetrennt Breite und Höhe in Pixel ausgegenen.

Argumente:

Css-Quelle, eines der Argumente

  • layer : Name der Ebene, dessen Default-Css verwendet werden soll

oder ...

  • cssFile : css - Dateiname (aus Serversicht)

oder ...

  • css: css als Text

  • boxWidth (35): Breite des Ausgabebild in Pixeln

  • boxHeight (25): Breite des Ausgabebild in Pixeln

  • mapScale (3000): Angenommener Maßstab

  • ignoreMapExcludeSetting (false): Ignoriere die Einstellung "exclude-from-map-legend" der betroffenen Blöcke.

  • format (Image): Ausgabeformat Image, Html oder JSON

Nur für Format "Image"

  • labelFontSize (14): Schriftgröße in Pixeln

  • labelFontName (Arial): Schriftart

Rahmen und Abstände:

  • verticalBorderInPixel (10)

  • verticalSpacingInPixel (5)

  • horizontalBorderInPixel (10)

  • horizontalSpacingInPixel (5)

Ausgabeformate:

  • Image: Ein Einzelbild mit allen Elementen und Labeln, immer im Format PNG

  • Html: Ein Html dem Template pro Eintrag:

      <figure>
        <img height="n" width="n" src="data:image/png;base64,...">
        <figcaption>Label</figcaption>
      </figure>
    
  • Json: Ein String-Array, 2 Array Einträge bilden jeweils einen Legendeneintrag, 1. Base64 Byte-Array mit dem PNG Bild, 2. Label

Css Validierung

Endpunkt: /json/validatecss

Encoding: GET/POST (application/x-www-form-urlencoded)

Beispiel-Ausgabe:

{
  "layername":"STR",
  "success":false,
  "error":"Fehler im....",
  "isCssError":true
}
Argumente:
  • css: Das Css, welches geprüft werden soll

  • layer: Name der Ebene die für die Validierung verwendet wird (ist erforderlich, da im css Spalten verwendet werden können etc.)


Abrufen installierter Schriftarten

Endpunkt: /json/installedFonts

Encoding: GET/POST (application/x-www-form-urlencoded)

Gibt die Namen der installierten True-Type-Fonts zurück als String-Array zurück.

Argumente:
  • charset (default): Zeichensatz (default, symbol)

  • family (""): Name der Schriftfamilie (bspw. Helvetica)


Vorschaubilder für True-Type-Marker

Endpunkt: /json/markerPreview

Encoding: GET/POST (application/x-www-form-urlencoded)

Generiert ein Bild oder ein HTML oder Json mit den Vorschaubildern für Punkte mit TrueType-Markern.

Argumente:
  • fontName : Name der Schriftart

  • startCharCode : Wert des Start-Zeichencode

  • endCharCode : Wert des End-Zeichencode

Weitere Parameter siehe: legend

Bsp. (mit sinnvollen/typischen Werten):

 /json/markerpreview?fontName=webdings&startCharCode=33&endCharCode=255&format=html&boxheight=50&boxWidth=50

Datenabruf

Datenabruf GeoSQL

Endpunkt: /bin/query

Encoding: POST (plain/text)

Ruft einen Data-Reader als Ergebnis einer GeoSQL Abfrage ab. Der Transport erfolgt über ein sehr effizientes proprietäres Binärformat.

Beim Start der Abfrage wird unmittelbar der Http-Header x-iwan-activity-id übermittelt. Mit diesem kann der Aufrufer den Vorgang parallel zum laufendem Datenabruf abbrechen.

In der IduIT.GeoLib.Net steht über die Klasse DataSerializer eine Implementierung eines System.Data.IDataReader für Zugriff auf diese Abfragen zur Verfügung.

Argumente (POST):
  • sql: Abfrage als gültiges GeoSQL
Argumente (Http-Header):
  • x-iwan-timeout-ms (30000): Timeout in Millisekunden

  • x-iwan-allowdirectsql (false): Abfrage direkt in der Datenquelle absetzen, wenn möglich.


Beispiel in Kombination mit IduIT.GeoLib.Net / c#
System.Data.IDataReader QueryIwan(string sql)
{
 var resp = new IDU.Web.Http.HttpRawPostFormRequestContent("tex/plain;charset=utf-8")
            {
               Url = new Uri(_baseUri, "bin/query"),
               RawBody = sql
            }
  ).GetResponse();

  return IduIT.GeoLib.Net.Data.DataSerializer.CreateFromStream(
           resp.GetResponseStream(), 
           true));	
}

Datenabruf (direkt)

Endpunkt: /bin/layerreader

Ruft einen Data-Reader ab. Der Transport erfolgt über ein sehr effizientes proprietäres Binärformat.

In der IduIT.GeoLib.Net steht über die Klasse DataSerializer eine Implementierung eines System.Data.IDataReader für Zugriff auf diese Abfragen zur Verfügung.

Argumente (Form/Get):
  • layer: Der Name der Ebene
Argumente (Http-Header):
  • x-iwan-timeout-ms (30000): Timeout in Millisekunden

Status/Konfiguration

Aktivitäts-Informationen

Endpunkt: /stat

Encoding: GET

Gibt Informationen zur Aktivität zurück (Anzahl Requests gesamt und aktuell)

{
 "current":1,
 "total":42,
 "globalInfo":"Läuft seit %i Minuten.\r\n22ms avg...",
 "totalPerEndPoint":{
	"/layer/load":12,
	"/stat": 10
 }
}

Wobei ... current : Aktuelle Anzahl aktiver Aufrufe total : Requests gesamt totalPerEndPoint: Map mit der relativem Endpunkt-Url als Schlüssel und der Anzahl der jeweiligen Aufrufe

Argumente:

- Keine -


Laufzeit-Konfiguration

Endpunkt: /config

Encoding: GET/POST (application/x-www-form-urlencoded)

Gibt die Laufzeitkonfiguration zurück oder legt diese fest.

{
 "traceLevel":"TraceError",
 "renderMode":"NoParallel",
 "renderEngine":"GdiPlus"
}
Argumente:
  • traceLevel: Einer der Werte: TraceNone, TraceWarning, TraceError, TraceInfo, TraceDebug, TraceDetail,TraceDetailEx

  • renderMode: Eine Kombination der Werte: NoParallel, RenderLayersParallel, UseVectorQueue,DebugRenderSkipVRendering

  • renderEngine: GdiPlus, Direct2d oder Agge

Bsp.:

meinServer:8287/iwan/config?traceLevel=TraceError


Projekt-Konfiguration

Endpunkt: /json/writeConfig

Encoding: POST (application/json)

Erstellt oder aktualisiert die Konfigurationsdateien im aktuellen Projekt-Kontext.

{
 "workingDir":"c:\\projectFolder",
 "tempDir":"c:\\tempFolder",
 "allowAccessToUndefinedProjects":false
}

Abruf des Trace-Files als HTML

Endpunkt: /trace

Encoding: GET

Ruft das Trace-File als HTML Tabelle ab.

Argumente:
  • rows (100): Anzahl der Zeilen

Abruf des Trace-Files als JSON

Endpunkt: json/trace

Encoding: GET

Ruft das Trace-File als JSON Array ab. 0 = Timestamp 1 = Error-Level 2 = ThreadId 3 = Message

Argumente:
  • rows (100): Anzahl der Zeilen

Abruf des Größe Trace-Files

Endpunkt: /traceSize

Encoding: GET

Ruft die Dateigröße des Trace-File ab. Ist kein Tracefile vorhanden, wird ein leerer String zurückgegeben.

Argumente:
  • raw (false): Als Zahlenwert ausgeben, sonst als Dateigröße formatiert (1MB)

Leeren des Trace-Files

Endpunkt: /traceTruncate

Encoding: GET

Gibt true oder eine Exception zurück. Ist kein Tracefile vorhanden, wird ein leerer String zurückgegeben.


Trace Info/Änderungen

Endpunkt: json/tracemodify

Encoding: GET

Gibt ein JSON Objekt mit ...

{
    traceFileSize:number;
    traceLevel:TraceNone|TraceWarning|TraceError|TraceInfo| TraceDebug|TraceDetail|TraceDetailEx;
}

zurück. Optional kann übergeben werden truncate=true|false und TraceLevel=neuerLevel


Abbruch von Einzel Aktivitäten

Endpunkt: /activities/cancel

Encoding: GET/POST (application/x-www-form-urlencoded)

Sendet ein Abbruch-Signal an die Aktivität mit der angegebenen cancelId (muss ein INT64 sein). Gibt true oder false als Text zurück.

Argumente:
  • cancelId: Id-der Aktivität

Abbruch von Gruppen Aktivitäten

Endpunkt: /activities/cancelgroup

Encoding: GET/POST (application/x-www-form-urlencoded)

Sendet ein Abbruch-Signal an alle Aktivitäten-Gruppen mit der angegebenen cancelGroupToken. Gibt die Anzahl der abgebrochenen Vorgänge zurück.

Argumente:
  • cancelGroupToken: Id der Aktivitätengruppe (entsprechend den im Http-Header x-iwan-activitygrouptoken übergebenem Wert bei der Anforderung)

Interaktive Formulare

Für Debug-Zwecke stehen einige einfache HTML Formulare zur Verfügung:

  • /ui/query : Ermöglicht das Ausführen von GeoSQL-Abfragen.

  • /ui/state : Auflistung der aktuellen Aktivitäten mit Möglichkeit zum Abbrechen.

  • /ui/load : Einfaches Formular zum Laden von Ebenen per JSON.

  • /ui/layers : Ausgaben einer HTML Tabelle der aktuell geladenen Ebenen mit Möglichkeit zum Entladen (mgl. Argumente: dropLayer=, clearWfsCache=1}).

  • /ui/dashboard : Übersicht und Einstellungen.

  • /ui/enc : Verschlüsselung

Formate

MapRenderRequest

struct MapRenderRequest
{
public:
/// <summary>
/// Bildbreite in Pixeln
/// </summary>
uint16_t width;

/// <summary>
/// Bildhöhe in Pixeln
/// </summary>
uint16_t height;

/// <summary>
/// Skalierung (default ist 1.0)
/// </summary>
Core::Optional<double>scaleFactor;

/// <summary>
/// Vorgabe-Maßstäbe, wenn außerhalb des Bereichs (kann eigentlich nur nach "oben" passieren), dann der ermitteltet Maßstab (unter Berücksichtigung von MapScaleMultipleOf, wenn angegeben)
/// </summary>
std::unique_ptr<std::vector<double>>targetMapScales;

/// <summary>
/// Kann mit TargetMapScales kombiniert werden, oder alleine Verwendung finden, sichert zu, dass der Kartenmaßstab ein vielfaches von N ist (z.B. 1000).
/// Berücksichtigt auch MapScaleFarToNearBalance
/// </summary>
Core::Optional<uint32_t>mapScaleMultipleOf;

/// <summary>
/// Für TargetMapScales, Standardwert ist 1
/// Bei farToNearBalance=1 ist sichergestellt, dass der übergebene Extent garantiert im Kartenbild zu sehen ist
/// Bei Absenkung des Wertes, wird dann mehr und mehr ein Beschneiden zugelassen und der mehr hereingezoomte Level verwendet
/// Der Wert 0 bedeutet, dass immer der nächstniedrige Maßstab - sofern es noch einen gibt - verwendet wird.
/// </summary>
Core::Optional<double>mapScaleFarToNearBalance;

/// <summary>
/// Ziel-Epsg der Karte, wenn nicht angegeben wird die aus der BBox verwendet
/// </summary>
Core::Optional<int>targetEpsgCode;

/// <summary>
/// 
/// </summary>
Core::Optional<Core::Renderer::RenderEngine>renderEngine;

/// <summary>
/// Die BBox, wenn nicht angegeben, wird diese aus der Liste der zu zeichnenden Elemente ermittelt.
/// </summary>
std::unique_ptr<Core::Geometry::BBox> bbox;

/// <summary>
/// Liste der Ebenen
/// </summary>
std::vector<MapRenderLayer>layers;

/// <summary>
/// Hintergrundfarbe, kann auch TRANSPARENT sein
/// </summary>
std::unique_ptr<Core::String> backgroundColor;

};

MapRenderLayer

struct MapRenderLayer
{
/// <summary>
/// Der Name der Ebene - schließt sich mit Features aus 
/// </summary>
std::unique_ptr<Core::String> name;

/// <summary>
/// Features - schließt sich mit Name aus 
/// </summary>
std::unique_ptr<std::vector<AdHocRenderLayerFeature>>features;

/// <summary>
/// Css, optional, sonst das der Ebene oder CssFile
/// </summary>
std::unique_ptr<Core::String> css;

/// <summary>
/// CssFile (nur, wenn CSS nicht definiert ist)
/// </summary>
std::unique_ptr<Core::String> cssFile;

/// <summary>
/// Scale-Range-Override min,max, wobei min/ max auch leer sein kann
/// </summary>
std::unique_ptr<Core::String> scr;

/// <summary>
/// Der Filter als JSON String
/// </summary>
std::unique_ptr<Core::String> flt;

/// <summary>
/// Name der Sublayer, optional
/// </summary>
std::unique_ptr<std::vector<Core::String>> subLayer;
};

AdHocRenderLayerFeature

struct AdHocRenderLayerFeature
{

/// <summary>
/// Die Geometrie (wird reprojeziert, wenn erforderlich)
/// </summary>
std::unique_ptr<IduIT::GeoLib::Core::Geometry::IGeometry>geom;

/// <summary>
/// Die Sachdaten (Dictionary String/Variant), kann im CSS referenziert werden
/// </summary>

std::unique_ptr<VariantMap>data;
}

Zuletzt geändert: 06.03.2024 07:32:01 (erstmals erstellt 03.06.2017)