==Bevezetés==

NASA World Wind SDK egy ingyenes, nyílt-forráskódú virtuális földgömb weboldalakhoz és web applikációkhoz.
'''Alapvetően három API-t biztosít:'''
* Java
* Android
* Webes
Ezen wiki oldal témája a webes felhasználás.

Web World Wind-et JavaScriptben írták és egy JavaScript API-t biztosít ahhoz, hogy egy virtuális földgömb összes aspektusát kezelhessük. A Web World Wind lehetővé teszi, hogy a fejlesztők gyorsan és könnyen interaktív vizualizációt készíthessenek különböző földrajzi adatoknak egy 2 dimenziós térképen vagy 3 dimenziós földgömbön.

A világon sok szervezet használja a Web World Wind-et arra, hogy monitorozzanak időjárás mintákat, városokat vizualizáljanak, járművek mozgását kövessék, földrajzi adatokat elemezzenek vagy oktassák az embereket a Földről.

'''Néhány lehetőség:'''
* Sok előre beépített, magas felbontású képpel rendelkezik
* Sok beépített alakzat megvalósítható
* Beépített navigációs lehetőségek
* Több földgömb is megjeleníthető egy oldalon
* ShapeFile támogatás

'''Függőségek''' (opcionális)
* Bootstrap
* JQuery
* RequireJS

Demo: http://people.inf.elte.hu/hagtabi/web_world_wind/demo.html
<br>
"Keretrendszer" letöltése zipben: [[Fájl:hb0mt7_web_world_wind.zip]]

==Koncepció==

A Web World Wind egy komponens amely beágyazódik a weboldalba. Ezt a komponenst hívjuk World Windownak.

=== World Window ===

A World Window objektum a funkcionalitást egy HTML canvas köré építi. A canvas általában egy "div" és az attribútumként megadott id-val paraméterezzük a World Window objektumot. Egy oldal több World Widow objektumot tartalmazhat, mindegyik canvashoz tartozik egy.

A World Window tartalmaz egy Globe-ot, egy Navigator-t és egy Layer List-et. Ezek automtiusan jönnek létre amikor a World Window konstruálódik. A Globe és Navigator lecserélhető. Ezeken felül a World Window felel még az eseménykezelésért.

Az World Window felépítése:

<span class="plainlinks">[https://webworldwind.files.wordpress.com/2015/05/architecture1.jpg]</span>

<syntaxhighlight lang="javascript" line='line'>

<div style="position:relative">
<canvas id="canvasOne" width="1000" height="1000" style="width: 100%; height: auto">
</canvas>
</div>

</syntaxhighlight>

=== Rétegek ===

A World Wind mellett a rétegek a legfontosabb objektumok. Ezen rétegek tárolják a World Winden megjelenő összes információt. A képek, alakzatok, dekorációs elemek stb. mind-mind különálló rétegekben tárolódnak.

Minden World Wind objektum tartalmaz egy listát amely a rétegeket tartalmazza. Ezt nevezik Layer List-nek. Ez a lista tartalmazza az összes definiált réteget, és alapesetben üres. Amikor a World Wind rajzol, akkor bejárja ezt a listát és sorrendben megrajzolja a benne lévő rétegeket.

Fontosabb réteg attribútumok:

*displayName : Szöveg, a réteg nevét adhatjuk meg, és később ez megjeleníthető.
*enabled : Logikai, lehetővé teszi, hogy a réteget kikapcsoljuk, de közben a listában benne marad.
*pickEnabled : Logikai, megmondja, hogy a réteg és a tartalma "pickelhető-e".
*opacity : 0-1 közötti szám a réteg átlátszóságát szabályozza.

Két fontosabb rétegtípus van.

* Kép réteg (Image Layer) : olyan képet tartalmaz amelyet a felszínre vetítünk ki. Ez tipikusan az egész földgömbre kiterjed de ez nem kötelező.
* Renderelhető réteg (Renderable Layer): akkor használjuk ha alakzatokat szeretnénk megjeleníteni.

<syntaxhighlight lang="javascript" line='line'>

// Létrehozzuk a World Window-t
var wwd = new WorldWind.WorldWindow("canvasOne");

// Létrehozzuk és hozzáadjuk a layereket
wwd.addLayer(new WorldWind.BMNGLayer());
wwd.addLayer(new WorldWind.BingAerialWithLabelsLayer(null));
wwd.addLayer(new WorldWind.CompassLayer());
wwd.addLayer(new WorldWind.CoordinatesDisplayLayer(wwd));
wwd.addLayer(new WorldWind.ViewControlsLayer(wwd));

</syntaxhighlight >

=== Alakzatok ===

Alakzatok reprezentálják azokat az információkat amit meg szeretnénk jeleníteni és a földgömbhöz kapcsolódik. Egy ilyen objektum sokféle lehet, az egyszerű helyzet-jelölőtől kezdve a komplex rajzolt alakzatokig. Minden alakzat egy rétegben tárolódik és ez a réteg pedig megtalálható a World Wind Layer List-jében.
Minden World Wind alakzathoz sokféle attribútum kapcsolható, ezzel vezérelve pl: a színt vagy láthatóságot.
A legtöbb alakzathoz ez egy ShapeAttributes osztály, de például a helyjelzőnél a szöveget lehet formázni.

Ha egy ilyen attribútum osztály konstruktorának null értéket adunk paraméterül, akkor automatikusan úgy veszi, hogy mindenből a default értéket szeretnénk használni. Ide megadható egy már korábban vagy frissen létrehozott objektum. Fontos, hogy ha egy alakzathoz hozzárendelünk egy attribútumot az nem másolódik le, így minden változás adott esetben több alakzatot is érinthet. Ezt elkerülendő érdemes minden alakzathoz saját attribútumokat definiálni. (Viszont ez kihasználható, hogy ha több alakzatnak szeretnénk ugyanazokat az attribútumokat beállítani, akkor maradhat egy és azt állítjuk be az alakzatokhoz.)

Az alakzatok kétféle attribútumhalmazt tárolnak. Egyet saját magának, egyet pedig az alakzat kiemelésének. Minden alakzatnak egy egy logikai értéke amely megmondja, hogy az kiemelhető-e (highlighted). Ha ez igaz, akkor érvényesek a kiemelés attribútumai.
Kezdetben a kiemelés attribútumai null-ok és amennyiben nem adunk meg ilyet, de kiválasztjuk, hogy az alakzat kiemelhető, akkor az alakzat saját attribútumait veszi figyelembe.

==== Út típus ====

Némely alakzatnak van olyan attribútuma amely meghatározza, hogy milyen módon kerül megrajzolásra.

*WorldWind.GREAT_CIRCLE : Az alakzat útjai/élei egy nagy körutat követnek a definiáló pozíciók között. A földgömb görbületét figyelembe veszi.
*WorldWind.RHUMB_LINE : Az alakzat útjai/élei egy loxodroma-t (egy gömb felületére írt csavarvonal) követnek a definiáló pontok között. A földgömb görbületét figyelembe veszi.
*WorldWind.LINEAR : Az alakzat útjai vagy élei egy szimla egyenes vonalat követnek a definiáló pozíciók között. A földgömb görbületét nem figyelembe veszi.

Minden alakzatra az alapértelmezett érték WorldWind.GREAT_CIRCLE.

==== Magasság típus ====

Minden alakzat amely a geológiai pozíciójával van megadva, létezik egy attribútum amely megmondja az alakzatát magasságának kapcsolatát a tereppel.

*WorldWind.ABSOLUTE : A magasságot relatív távolságként kezeli az elipszoid felszínéhez képest.
*WorldWind.RELATIVE_TO_GROUND : A magasságot a terepen lévő pozíció koordinátáitól vett távolságként kezeli.
*WorldWind.CLAMP_TO_GROUND : A magasságot nem veszi figyelembe és úgy veszi mint ha terepen lenne.

Minden alakzat esetén az alapérték a WorldWind.ABSOLUTE.

===Glóbusz ===

Globe reprezentál egy WGS84 elipszoidot és a területet. továbbá kezeli a különböző 2D-s projekciókat, ami használhatóak a +D-s glóbusz helyett. Alapesetben ezen kívül az alkalmazás nem nagyon lép interakcióba a glóbusszal. Ez alól kivétel például ha az alkalmazásunk a terület emelkedésével szeretne számolni.

Minden World Window-nak eg Globe-ja van és automatikusan létrejön, amikor a World Window is. Az alkalmazásban a Globe lecserélhető egy másikra.

=== Navigátor===

A Navigator objektum felelős azért, hogy a felhasználói interakciókat átalakítsa a földgömbön megjelenő változásokká. Folyamatosan figyeli az egér eseményeket és ezeket alakítja át mozgássá, forgatássá vagy zoomolássá. A Navigator segítségével lehet egy adott pozícióra navigálni.

Minden World Wind objektumnak megvan a saját Navigator objektuma, Ez a Navigator automatikusan jön létre, akkor amikor a World Wind objektumok létrejön. Ez a Navigator lecserélhető, ha a fejlesztő készített egy másképp működőt amely jobban megfelel az igényeknek.

==Főbb funkcionalitások==

=== Alakzatok ===

====Szövegek ====

Egy adott földrajzi ponthoz tartozó szöveget reprezentál.

<syntaxhighlight lang="javascript" line='line'>

// Példa adat
var peaks =
[
{
'name': "Mount McKinley\n(Denali)", // Mount McKinley
'state': "Alaska",
'elevation': 6194,
'latitude': 63.0690,
'longitude': -151.0063
},
{
'name': "Mauna\nKea",
'state': "Hawaii",
'elevation': 4205,
'latitude': 19.8207,
'longitude': -155.4680
}];

var text,
textAttributes = new WorldWind.TextAttributes(null),
textLayer = new WorldWind.RenderableLayer("Fölrajzi szöveg");

//Alap attribútumok beállítása (pl: szín)
textAttributes.color = WorldWind.Color.RED;
textAttributes.depthTest = false;

//Létrehozzuk a szöveg "alakzatokat"
for (var i = 0, len = peaks.length; i < len; i++) {
var peak = peaks[i],
peakPosition = new WorldWind.Position(peak.latitude, peak.longitude, peak.elevation);
text = new WorldWind.GeographicText(peakPosition, peak.name + "\n" + peak.state);

//Beállítjuk az alakzatohoz a szöveget
text.attributes = textAttributes;

//Hozzáadjuk a szöveget a layerhez
textLayer.addRenderable(text);
}

//A szöveg layert hozzáadjuk a globál layerhez
wwd.addLayer(textLayer);

//Létrehozunk egy managert, hogy tudjuk vezérelni a szöveg réteget.
var layerManger = new LayerManager(wwd);

</syntaxhighlight >

====Utak====

Egyenes vagy görbe vonalat reprezentál előre megadott pozíciók között. A megrajzolt vonal az alábbi típusú lehet:

* WorldWind.GREAT_CIRCLE
* WorldWind.RHUMB_LINE
* WorldWind.LINEAR

Az utat alkotó pontok közötti magasságot meghatározza az út magasság módja amely az alábbiak lehetnek:

* WorldWind.ABSOLUTE
* WorldWind.RELATIVE_TO_GROUND
* WorldWind.CLAMP_TO_GROUND

Külön attribútumok tartoznak a normál és a kiemelt megjelenítéshez.

<syntaxhighlight lang="javascript" line='line'>

// Úthoz tartozó poziciók létrehozása
var pathPositions = [];
pathPositions.push(new WorldWind.Position(40, -100, 1e4));
pathPositions.push(new WorldWind.Position(45, -110, 1e4));
pathPositions.push(new WorldWind.Position(46, -122, 1e4));

// Az út létrehozása
var path = new WorldWind.Path(pathPositions, null);
path.altitudeMode = WorldWind.RELATIVE_TO_GROUND;
path.followTerrain = true;
path.extrude = true;
path.useSurfaceShapeFor2D = true;

// Az úthoz tartozó attribútumok étrehozása
var pathAttributes = new WorldWind.ShapeAttributes(null);
pathAttributes.outlineColor = WorldWind.Color.BLUE;
pathAttributes.interiorColor = new WorldWind.Color(0, 1, 1, 0.5);
pathAttributes.drawVerticals = path.extrude;
path.attributes = pathAttributes;

// Kiemelés létrehozása
var highlightAttributes = new WorldWind.ShapeAttributes(pathAttributes);
highlightAttributes.outlineColor = WorldWind.Color.CYAN;
highlightAttributes.interiorColor = new WorldWind.Color(1, 1, 1, 0.5);
path.highlightAttributes = highlightAttributes;

//Az utat hozzáadjuk egy layerhez, és betesszük a globális layerbe
var pathsLayer = new WorldWind.RenderableLayer();
pathsLayer.displayName = "Paths";
pathsLayer.addRenderable(path);
wwd.addLayer(pathsLayer);

//Layermanager létrehozása
var layerManger = new LayerManager(wwd);

//Eseménykezelés a kiemeléshez
var highlightController = new WorldWind.HighlightController(wwd);

</syntaxhighlight >

====Poligonok====

Egy 3D-s poligont reprezentál. A poligonnak több határt is beállíthatunk, ezzel üres területeteket képezve. A poligon magassága az alábbiak lehetnek:

* WorldWind.WorldWind.ABSOLUTE
* WorldWind.RELATIVE_TO_GROUND
* WorldWind.CLAMP_TO_GROUND

Külön attribútumok tartoznak a normál és a kiemelt megjelenítéshez.

<syntaxhighlight lang="javascript" line='line'>

//Létrehozzuk a poligonokat tároló réteget
var polygonsLayer = new WorldWind.RenderableLayer();
polygonsLayer.displayName = "Polygons";
wwd.addLayer(polygonsLayer);

//Létrehozzuk a poligon határait
var boundaries = [];
boundaries[0] = []; // külső határ
boundaries[0].push(new WorldWind.Position(40, -100, 1e5));
boundaries[0].push(new WorldWind.Position(45, -110, 1e5));
boundaries[0].push(new WorldWind.Position(40, -120, 1e5));

boundaries[1] = []; // belső határ
boundaries[1].push(new WorldWind.Position(41, -103, 1e5));
boundaries[1].push(new WorldWind.Position(44, -110, 1e5));
boundaries[1].push(new WorldWind.Position(41, -117, 1e5));

//Létrehozzuka a poligont és hozzáadjuk az attribútumait.

var polygon = new WorldWind.Polygon(boundaries, null);
polygon.altitudeMode = WorldWind.ABSOLUTE;
polygon.extrude = true;

var polygonAttributes = new WorldWind.ShapeAttributes(null);
polygonAttributes.drawInterior = true;
polygonAttributes.drawOutline = true;
polygonAttributes.outlineColor = WorldWind.Color.BLUE;
polygonAttributes.interiorColor = new WorldWind.Color(0, 1, 1, 0.5);
polygonAttributes.drawVerticals = polygon.extrude;
polygonAttributes.applyLighting = true;
polygon.attributes = polygonAttributes;

//Létrehozzuk a poligonhoz tartozó kiemelést
var highlightAttributes = new WorldWind.ShapeAttributes(polygonAttributes);
highlightAttributes.outlineColor = WorldWind.Color.RED;
highlightAttributes.interiorColor = new WorldWind.Color(1, 1, 1, 0.5);
polygon.highlightAttributes = highlightAttributes;

//Hozzáadjuk a layerhez
polygonsLayer.addRenderable(polygon);

</syntaxhighlight >

====Helyjelző====

Bármilyen pozíción megjelenő képet/címkét reprezentál. Lehet használni a beépített képeket vagy használhatunk sajátot, illetve a html-el is lehet rajzolni.

<syntaxhighlight lang="javascript" line='line'>

// Definiáljuk a képeket amiket helyjelzőnek használunk.
var images = [
"plain-black.png",
"plain-blue.png"
];

var pinLibrary = WorldWind.configuration.baseUrl + "images/pushpins/", // a képek helye
placemark,
placemarkAttributes = new WorldWind.PlacemarkAttributes(null),
highlightAttributes,
placemarkLayer = new WorldWind.RenderableLayer("Placemarks"),
latitude = 47.684444,
longitude = -121.129722;

// Létrehozzuk a közös attribútumokat.
placemarkAttributes.imageScale = 1;
placemarkAttributes.imageOffset = new WorldWind.Offset(
WorldWind.OFFSET_FRACTION, 0.3,
WorldWind.OFFSET_FRACTION, 0.0);
placemarkAttributes.imageColor = WorldWind.Color.WHITE;
placemarkAttributes.labelAttributes.offset = new WorldWind.Offset(
WorldWind.OFFSET_FRACTION, 0.5,
WorldWind.OFFSET_FRACTION, 1.0);
placemarkAttributes.labelAttributes.color = WorldWind.Color.YELLOW;
placemarkAttributes.drawLeaderLine = true;
placemarkAttributes.leaderLineAttributes.outlineColor = WorldWind.Color.RED;

// Minden képhez létrehozunk egy Placemarkot és címkét
for (var i = 0, len = images.length; i < len; i++) {

placemark = new WorldWind.Placemark(new WorldWind.Position(latitude, longitude + i, 1e2), true, null);
placemark.label = "Placemark " + i.toString() + "\n"
+ "Lat " + placemark.position.latitude.toPrecision(4).toString() + "\n"
+ "Lon " + placemark.position.longitude.toPrecision(5).toString();
placemark.altitudeMode = WorldWind.RELATIVE_TO_GROUND;

.
placemarkAttributes = new WorldWind.PlacemarkAttributes(placemarkAttributes);
placemarkAttributes.imageSource = pinLibrary + images[i];
placemark.attributes = placemarkAttributes;

//Létrehozzuk a kiemeléshez tartozó attribútumokat
highlightAttributes = new WorldWind.PlacemarkAttributes(placemarkAttributes);
highlightAttributes.imageScale = 1.2;
placemark.highlightAttributes = highlightAttributes;

//Hozzáadjuk a réteghez.
placemarkLayer.addRenderable(placemark);
}

// Hozzáadjuk a réteget a globális réteghez.
wwd.addLayer(placemarkLayer);

// Létrehozunk egy Layermanagert a kezelhetőségért
var layerManger = new LayerManager(wwd);

</syntaxhighlight>

====További alakzatok====

*Felszíni alakzatok: Hasonlóak a fent taglalt Poligonokhoz. (Surface Shapes)
*Képernyő kép: Segítségével képernyő-re képet rajzolhatunk. (Screen Image)
*Képernyő szöveg : Segítségével szöveget helyezhetünk el a képernyőn. (Screen Text)

=== Eseménykezelés ===

A legtöbb alkalmazás általában figyeli és reagál a különböző JavaScript eseményekre. Mivel itt azonban a Navigator objektum figyeli az egér és kézmozdulat eseményeket amivel a felhasználó manipulálhatja a földgömböt, ezért kénytelen vagyunk valamiféle koordinációt végezni az alkalmazás és a Navigator eseménykezelése között. Fontos, hogy a Web World Wind nem figyeli a billentyűzet eseményeit, így ezt nem kell koordinálni.

Ha az alkalmazásunk mobilon is fut akkor az egér mellett az érzékelés eseményeit is figyelni kell.

==== Egér eseménykezelés ====

Az esemény kezelőt be kell regisztrálni a World Window addEventListener metódusával.

<syntaxhighlight lang="javascript" line='line'>
var wwd = new WorldWind.WorldWindow("canvasOne");
wwd.addEventListener("mousemove", function (event) {...});
</syntaxhighlight>

Az így hozzáadott listenerek a Navigator eseménykezelése előtt hívódnak meg.
Azok az eseménykezelők akik választoktak az eseményre meg kell hívniuk a preventDefault -ot, hogy ezzel jelezzék a Navigatornak és a többi eseménykezelőnek, hogy ignorálják az eseményt. Továbbá az eseménykezelőknek érdemes megvizsgálni, hogy az eseményre válaszolt-e már valaki.

A fentiek alól kivétel a kattintás, mivel azt ClickRecognizer-el érdemes lekezelni. Ez kapcsolatban áll a Navigator-ral és kézmozdulat felismerőkkel, így elkerülve a duplikált eseménykezelést.

<syntaxhighlight lang="javascript" line='line'>

var clickRecognizer = new WorldWind.ClickRecognizer(wwd,
function(recognizer) {
...
});

</syntaxhighlight>

==== Kézmozdulat eseménykezelés ====

Itt is érdemes a beépített TapRecognizer osztályt használni. Ez képes felismerni a különböző képernyőt ért kézmozdulatokat.

<syntaxhighlight lang="javascript" line='line'>

// Általános kézmozdulat kezelő function
var handleClick = function (recognizer) {
// Obtain the event location.
var x = recognizer.clientX,
y = recognizer.clientY;

//A felhasználó valahová mutat
var pickList = wwd.pick(wwd.canvasCoordinates(x, y));

//Ha terepre mutatott akkor menjünk oda
if (pickList.objects.length == 1 && pickList.objects[0].isTerrain) {
var position = pickList.objects[0].position;
goToAnimator.goTo(new WorldWind.Location(position.latitude, position.longitude));
}
};

// Figyeljük az egér kattintásokat
var clickRecognizer = new WorldWind.ClickRecognizer(wwd, handleClick);

// Figyeljük a kézmozdulatokat
var tapRecognizer = new WorldWind.TapRecognizer(wwd, handleClick);

</syntaxhighlight>

=== Navigáció ===

Hacsak nem szeretnénk a felhasználó nézetét programmal változtatni, akkor sose kell interakcióba lépni a navigátorral. De természetesen lehetséges a navigátort az alkalmazásból irányítani.

A Navigator objektumnak elsődlegesen kettő attribútuma felel az irányításért:

*LookAtLocation: Jelzi a szélességet és hosszúságot ahová a felhasználó nézőpontja néz
*range: Jelzi a szem távolságát az ellipszoidtól.

<syntaxhighlight lang="javascript" line='line'>

// Beállítjuk, hogy a Navigator erre pontra nézzen és ilyen magasan legyen.
wwd.navigator.lookAtLocation.latitude = 65;
wwd.navigator.lookAtLocation.longitude = -150;
wwd.navigator.range = 2e6; // 2 millió méterrel az ellipsziod felett

</syntaxhighlight>

Ez azonban azonnal az új nézethez ugrik. Viszont szebben néz ki, fokozatosan és simán mozog oda ahová szeretnénk.
Ehhez használhatjuk a GoToAnimator-t.

=== Shape File ===

A World Wind Web támogatja a Shape File-opk használatát egy beépített ShapeFile osztály segítségével. Ez értelmezési a kapott Shape File-t és tartalmából alakzatokat készít. A pontokból helyjelzők, a vonalalkból utak, a poligonokból poligonokat csinál.Az értelmezés végén definiálható egy hívás ami akkor történik miután az egészet értelmeztük, de még nem készültek el az alakzatok.

Amennyiben a Shape File mellett található attribútm file is (.dbf), azt automatikusan felismeri és értelmezi a Shape File-al együtt.

<syntaxhighlight lang="javascript" line='line'>

// Létrehozzuk azt a callback functiont amely lefut a sikeres tötéskor, de még az alakzat rajzolása előtt
var shapeConfigurationCallback = function (attributes, record) {
var configuration = {};
configuration.name = attributes.values.name || attributes.values.Name || attributes.values.NAME;

if (record.isPointType()) {
configuration.name = attributes.values.name || attributes.values.Name || attributes.values.NAME;

configuration.attributes = new WorldWind.PlacemarkAttributes(placemarkAttributes);

if (attributes.values.pop_max) {
var population = attributes.values.pop_max;
configuration.attributes.imageScale = 0.01 * Math.log(population);
}
} else if (record.isPolygonType()) {
configuration.attributes = new WorldWind.ShapeAttributes(null);

//Kiszínezztük a kapott poligonokat valamilyen véletlenszerű színnel
configuration.attributes.interiorColor = new WorldWind.Color(
0.375 + 0.5 * Math.random(),
0.375 + 0.5 * Math.random(),
0.375 + 0.5 * Math.random(),
1.0);

//Kifestjük a határt valamilyen a belsőnél sötátebb színnel
configuration.attributes.outlineColor = new WorldWind.Color(
0.5 * configuration.attributes.interiorColor.red,
0.5 * configuration.attributes.interiorColor.green,
0.5 * configuration.attributes.interiorColor.blue,
1.0);
}

return configuration;
};

// Honnan vegye a file-okat
var shapefileLibrary = "http://worldwindserver.net/webworldwind/data/shapefiles/naturalearth";

// Létrehozzuk a réteget azt adatoknak.
var worldLayer = new WorldWind.RenderableLayer("Countries");

// Létrehozzuk a file-t feldolgozó osztályt
var worldShapefile = new WorldWind.Shapefile(shapefileLibrary + "/ne_110m_admin_0_countries/ne_110m_admin_0_countries.shp");

//Betöltjük a file-t
worldShapefile.load(null, shapeConfigurationCallback, worldLayer);

//Hozzáadjuk a réteget
wwd.addLayer(worldLayer);

</syntaxhighlight>

==Felhasznált irodalom==

NASA World Wind hivatalos oldal : https://worldwind.arc.nasa.gov/

Fájl:Hb0mt7 web world wind.zip

2017-05-25T09:31:43Z

Mate: NASA World Wind SDK keretrendszer

NASA World Wind SDK keretrendszer

Geomajas

2017-05-25T09:18:32Z

Mate: Előadás és minta kód wikibe feltöltése

Fájl:Geomajas JMDTDY.zip

2017-05-25T09:12:12Z

Mate: Előadás és JS minta

Előadás és JS minta

OpenLayers

2017-04-11T16:46:48Z

Mate: Syntax highlight

Az OpenLayers egy olyan JavaScipt programcsomag, mely lehetővé teszi geo adatok böngészőben történő megjelenítését. Maga a programcsomag is JavaScriptben íródott, és nyílt forráskódú, BSD2 engedéllyel rendelkezik.

== Bevezetés ==
=== Főbb funkcionalitások ===

Az OpenLayers 3 (OL3) alapvetően az OpenLayers webes térkép megjelenítő, kezelő csomag újratervezése. A második verzióját is széles kőrben használták, de mivel az korábbi Javascript elemeken alapult, most már újra korszerűsítésre volt igény. Az OL3 alapoktól újra volt építve modern tervezési minták alkalmazásával.

A harmadik kiadás arra irányult, hogy lehetővé tegye a második verzió által támogatott lehető legtöbb funkcionalitást, széles körben támogatva különböző kereskedelmi és ingyenes forrásokat, és a legismertebb vektor adat formátumokat. Ahogyan a második verzióban, az adat bármilyen vetületben lehet. Ugyanakkor a harmadik kiadás hozzáad néhány új funkcionalitást, mint például a könnyű forgathatóságot, valamint a térképek animálását.
A jelenlegi könyvtár 3 interpretert (renderer) foglal magába: Canvas, DOM, és WebGL. Mindhárom támogatja úgy a raszter adatokat csempe/kép szerverektől, illetve vektor adatokat; a WebGL csak pont vektorokat támogat (Point vectors), és nem támogat címkéket. Természetesen csak azon böngészők esetén támogatják a Canvast, melyekben van Canvas interpreter. A WebGL esetében is hasonlóan, csak azon eszközök és böngészők esetében használható, melyek támogatják a WebGL-t. Az Internet Explorer 9 előtt verziók egyáltalán nem kapnak támogatást.

A könyvtár alkalmas desktop/laptop használat esetén, úgy mint mobil eszköz esetén is.
Úgy van megtervezve az alkalmazás, hogy a főbb új irányzatokkal bővíthető legyen a következő kiadást. (pl. 3D térképek megjelenítése, WebGL használata nagyméretű vektoradatok megjelenítéséhez.)

=== Felépítés ===

Az OL3 nagy mértékben épül a Google Closure eszköztárára, nagy mértékben él a Closure könyvtár (Closure Library) nyújtotta segítséggel – például a DOM vagy az esemény kezelés résznél. Ez lehetővé teszi, hogy a fejlesztők a térképészeti funkciókra koncentrálhassanak, tudva, hogy az alá épült szoftver megbízható, jól tesztelt, böngésző szinten egyezményesített. A Closure Library sajátos tervezésének előnye, hogy a Closure fordító (Clusure Compiler) optimalizálni tudja, ráadásul olyan mértékben tömörítve, hogy az messzemenően meghaladja az jelenlegi kínálatokat. Az OL3-nak is nagy előnye származik ebből.
A Closure Compiler használata egyben azt is jelenti, hogy a tulajdonságok és a metódusok át vannak nevezve az előzőekhez képest. A hosszú, jelentést megnevező nevek többsége rövidebbre lett cserélve – ezért nem igazán hatékonyan használhatóak az alkalmazásokban, melyek a könyvtárat használják. A megoldást az a módszer nyújtja, hogy kell explicit módon exportálni őket. Ez azt jelenti, hogy az exportált nevek (vagyis azok, melyek nincsenek átnevezve), képezik tulajdonképpen a publikus API-ját a könyvtárnak. Ezek az exportálható tulajdonságok, metódusok vannak megjelölve a forrásban, és dokumentálva vannak az „API docs”-ban. Ez a nyilvánosan támogatott API-ja a könyvtárnak.

'''Objektumok és névterek'''

Az OL3 a Closure könyvtárhoz hasonló felépítésű. A legfelső szintet az ol névtér képezi (alapértelmezetten, var ol = {}). Alábbi szinteken a következők vannak:
* Alábbi névterek, mint az ol.layer; kisbetűvel kezdődik a nevük
* Egyszerű objektumok, melyek statikus tulajdonságokat és metódusokat használnak, mint pl. ol.animation; ezek is kisbetűvel kezdődnek.
* Típusok, melyek nagybetűvel kezdődnek. Ezek nagyjából „osztályok”, ami itt azt jelenti, hogy konstruktor függvény van prototípusos öröklődéssel, mint az ol.Map vagy ol.layer.Vector (Vector osztály a layer névtérben). Ugyanakkor vannak más, egyszerű típusok, mint pl. ol.Extent, amely egy tömb.

Osztály névtereknek, mint pl. az ol.layer van egy alap (base) osztály típusuk, mint például ol.layer.Layer. Ezek nagyjából absztrakt osztályok, melyekből a más osztályok örökölnek.
A forrás állományok hasonlóan vannak rendezve, minden névtér számára egy külön mappa. Neveik kisbetűsek, és az alosztályok ismétlik a örökölt osztály nevét is, mint pl. ol.layer.vectorlayers.js.
Az OL3 azt a konvenciót követi, hogy a privát tulajdonságok és metódusok, vagyis amelyek nem részei az API-nak, alul-vonásban végződnek. Általában a példány típusú tulajdonságok privátok, és elérésük erre célzott függvényekkel lehetséges.

=== Teljes build, testre-szabott build ===

Azt a fordítás, mely minden exportálható nevet tartalmaz, teljes build-nek (full build) nevezik. Egy befogadó verzió ebből elérhető, mely minden alkalmazás számára használható.
Closure fordítóval az exportálások fordítási időben meghatározhatóak, így saját fordítások (build-ek) könnyedén hozhatóak létre, melyek az adott weboldalhoz, alkalmazáshoz illőek. A testre-szabott build (custom build) csak azokat a tulajdonságokat, metódusokat exportálja, melyeket az adott weblap vagy alkalmazás valóban használni fog. Mivel a teljes build (full build) nagyon nagy méretű, és valószínűleg egyre nagyobb méretűvé fog válni amikor új lehetőségeket kerülnek az API-ba, nagyon ajánlott testre-szabott build-et létrehozni a weblapok számára.

== Alap komponensek ==

=== Térkép ===

Az OpenLayers3 fő komponense a térkép (ol.Map). Egy target típusú elem zárja körül (pl. egy div elem). A térkép minden tulajdonsága beállítható már létrehozása idején, de beállító metódusok is rendelkezésre állnak. (pl. setTarget()).

<syntaxhighlight lang="html">
<div id="map" style="width: 100%, height: 400px"></div>
<script>
var map = new ol.Map({target: 'map'});
</script>
</syntaxhighlight>

=== Nézet ===

Az ol.Map nem felelős a középpont(center), nagyítás(zoom) mértékének számontartásáért. Ezt a nézet (view) típusú elem tudja biztosítani.

<syntaxhighlight lang="javascript">
map.setView(new ol.View({
center: [0, 0],
zoom: 2
}));
</syntaxhighlight>

A nézet elem rendelkezik a vetületről (projection) is. Meghatározza a középpont koordináta rendszerét, és a lépték mértékét. Ha nincsen külön megadva, akkor az alapból beállított vetület a Spherical Mercator (EPSG:3857), és a lépték mértékegysége a méter.
A nagyítás mértéke szorosan összefügg a felbontás nagyságával. Három tulajdonság rögzíti a fontos paramétereket. A maxZoom a rendelkezésre álló nagyítási szintek számát jelöli, alapbeállításban 28. A maxResolution a legnagyobb felbontást jelenti, a 0. nagyítási szint esetén ennyi egység van pixelenként. A további nagyítási szintek úgy állnak elő, hogy az előző szint maxResolution értéke a zoomFactor értékkel lesz osztva. (Alapbeállítás a zoomFactor esetében a 2.)

=== Forrás ===

Hogy távoli adatot tudjunk biztosítani a térképrétegek számára, az OpenLayers 3 az ol.source.Source alosztályokat kínálja. Segítségükkel különböző ingyenes és kereskedelmi térképszolgáltatókat tudunk elérni, mint OpenStreetMap, Bing (térkép csempe szolgáltatások), WMS, WMTS (OBC források), GeoJSON, KML (vektoradatok).

<syntaxhighlight lang="javascript">
var osmSource = new ol.source.OSM();
</syntaxhighlight>

=== Rétegek ===

A réteg(Layer) egy source elem által biztosított adatok megjelenítéséért felelős. Az OpenLayers 3 három fő layer típust kínál: ol.layer.Tile, ol.layer.Image, ol.layer.Vector.
* ol.layer.Tile: olyan réteg forrásokhoz kell rendelni, melyek előre generáltak, rácsban lévő csempés képek, nagyítási mérték szerint rendezve a bizonyos felbontásnak megfelelően.
* ol.layer.Image: szerver által generalizát képekhez, melyek tetszőleges bővítésre, felbontásra nyitottak.
* ol.layer.Vector: olyan vektor adatokhoz, melyek kliens oldalon vannak generalizálva.

<syntaxhighlight lang="javascript">
var osmLayer = new ol.layer.Tile({source: osmSource});
map.addLayer(osmLayer);
</syntaxhighlight>

=== Összefoglaló példa ===

Összefoglalva a példa a következőképpen nézne ki:

<syntaxhighlight lang="html">
<div id="map" style="width: 100%, height: 400px"></div>
<script>
new ol.Map({
layers: [
new ol.layer.Tile({source: new ol.source.OSM()})
],
view: new ol.View({
center: [0, 0],
zoom: 2
}),
target: 'map'
});
</script>
</syntaxhighlight>

== Testre-szabott build-ek készítése ==

Az OpenLayers 3 fordítói eszközök használják a Node-ot és a Java-t, tehát ezek fel kell legyenek telepítve a fejlesztő gépén. A node –version, java –version parancsok segítségével ellenőrizhető, hogy a Java és a Node fel van-e telepítve, a fejlesztői útmutató (developer guide) a minimum verziót is rögzíti.
Következő lépésként le kell tölteni az OpenLayers 3-at, hiszen a testre-szabott build-hez szükség van a forrás állományokra és sajátos build szkriptekre. Ezek beszerzése több módon lehetséges: az ol3 repository klónozásával, vagy valamelyik OL3 közzététel archiv csomagjának letöltésével. Letölthető az openLayres Node csomagja is az NPM (Node Package Manager) segítségével. A következőkben ezt a módszert mutatjuk be:

* 1. Létrehozunk egy új mappát:
<syntaxhighlight lang="bash">
$ mkdir openlayers
</syntaxhighlight>

* 2. Letöltünk egy OpenLayers 3 disztribúciót az NPM használatával:
<syntaxhighlight lang="bash">
$ npm install openlayers
</syntaxhighlight>

Ez mindig az OpenLayers 3 legfrissebb stabil verzióját tölti le, és a node_modules alá telepíti. Ezt követően ellenőrizhető az „openlayers” mappa jelenléte a node_modules listázásával. A node_modules/openlayers/node_modules
mappának például tartalmaznia kell a closure-utilt is, hiszen az OL3 rá épül.

Ezen műveleteket követően mindenünk biztosítva van a testre-szabott build elkészítéséhez.

=== Konfigurációs állomány készítése ===

A következő lépés egy build konfigurációs állomány létrehozása. Ennek formátuma JSON kell legyen. Egy példa build konfigurációs állományra:

<syntaxhighlight lang="javascript">
{
"exports": [
"ol.Map",
"ol.View",
"ol.control.defaults",
"ol.layer.Tile",
"ol.source.OSM"
],
"compile": {
"externs": [
"externs/bingmaps.js",
"externs/closure-compiler.js",
"externs/geojson.js",
"externs/oli.js",
"externs/olx.js",
"externs/proj4js.js",
"externs/tilejson.js",
"externs/topojson.js"
],
"define": [
"goog.DEBUG=false"
],
"extra_annotation_name": [
"api", "observable"
],
"compilation_level": "ADVANCED",
"manage_closure_dependencies": true
}
}
</syntaxhighlight>

Például egy ilyen tartalommal rendelkező állományt ol-custom.json névvel le lehet menteni a node_modulse/openlayers/build mappába.

====Exports lehetőségei====

A legszámottevőbb része ennek a konfigurációs állománynak az „exports” tömb. Ez a tömb deklarálja azokat a függvényeket/konstruktorokat, melyeket a JavaScript kódban használni lehet majd. Például az előbbi konfigurációs állomány alkalmas az előző fejezetben bemutatott javascript esetén. (Alap komponensek/Összefoglaló példa)
Most már minden elő van készítve a OpenLayers 3 build –hez. A következő parancsok következnek.

<syntaxhighlight lang="bash">
$ cd node_modules/openlayers
$ node tasks/build.js build/ol-custom.json build/ol-custom.js
</syntaxhighlight>

A build felvehet egy kis időt, de végül a console-on a következő jelenik meg:
<pre>
<info ol Parsing dependencies
<info ol Compiling 364 sources
</pre>

Ennek a parancsnak a nyomán létre kellett jöjjön az ol-custom.js állomány a node_module/openlayers/build mappában. Ellenőrizhető és megnyitható. Tesztként használhatjuk a következő HTML állományt, hogy lássuk, a testre-szabott build-ünk az elvártaknak megfelelően működik.

<syntaxhighlight lang="html">
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8" />
<title>OpenLayers 3 example</title>
<link rel="stylesheet" href="node_modules/openlayers/css/ol.css" />
<style>
#map {
width: 600px;
height: 400px;
}
</style>
</head>
<body>
<div id="map"></div>
<script src="node_modules/openlayers/build/ol-custom.js"></script>
<script>
var map = new ol.Map({
target: 'map',
layers: [
new ol.layer.Tile({
source: new ol.source.OSM()
})
],
view: new ol.View({
center: [0, 0],
zoom: 4
})
});
</script>
</body>
</html>
</syntaxhighlight>

====Define lehetőségei====

A konfigurációs állományban a define használata a Clusre-hoz kötődik, mely engedi olyan konstansok definiálását, melyek fordítási időben beállíthatóak. A fentebbi példa négy goog tulajdonságot állít be a Closure library számára. Az OpenLayers 3 kód rendelkezik definiált értékekkel is, melyek beállíthatóak.
Néhányat ezek közül hamisra (false) állítva azt érjük el, hogy azok a kódrészletek melyek ezekhez a beállításokhoz kötődnek „halottak” lesznek, vagyis sosem lesznek végrehajtva. Mivel a Closure fordító előrehaladottabb módja eltávolítja a halott kódokat, az előrehaladottabb fordítóval létrehozott kód jóval kisebb méretű lesz.
Észrevehető, hogy az előbbi folyamat során készült build állomány látványosan kisebb, mint a teljes build, de még ennél kisebbre is szorítható. Ez azért van, mert alapból mindhárom interpreter és minden réteg típus bele van vonva. Mivel csak egy interpreterre volt szükségünk, és csak a csempe rétegre, a többit ki is zárhatjuk a tulajdonság listában hamisra állítva őket. A következő kóddal kell kiegészíteni a konfigurációs állomány define részét, és újra kell futtatni a build szkriptet – majd újra láthatjuk, hogy kisebb lett a build mérete.

<pre>
"ol.ENABLE_DOM=false",
"ol.ENABLE_WEBGL=false",
"ol.ENABLE_PROJ4JS=false",
"ol.ENABLE_IMAGE=false",
"ol.ENABLE_VECTOR=false",
</pre>

====Externs lehetőségei====

Az externs alatt olyan külsős dolgok nevei szerepelnek, melyek használva vannak a fordított kódban. A fordító include-olja az externs mappába mindazokat a külsős állományokat, melyeket a könyvtár valamely részében használni fog. Például, ha használjuk a Bing Maps-et, akkor be kell include-olni az konfigurációs állomány externs részénél.
Az oli.js és az olx.js külső állományok az OpenLayers 3 API-hoz. Pédául az olx.js külső definíciókat tartalmaz az OpenLayers 3 konstruktor lehetőségeihez. Ezt a két állományt mindig használni érdemes extern-ként testre-szabott build esetén.

====Egyéb lehetőségek====

Vannak egyébb fordítási lehetőségek a konfigurációs állományban. Például a manage_closure_dependencies mindig használandó. Minden más fordítási opció is beállítható itt, a closure-util-ban látható az összes, listázott formában.
Több információ a build szkriptekről, és a tulajdonságokról, melyeket a konfigurációs állományokban állítani lehet [https://github.com/openlayers/ol3/blob/master/tasks/readme.md itt] található.

===Kód karbantartás===

A kód karbantartása érdekében, ha a Node csomag által telepítjük az OpenLayer-st, akkor az npm használható a legújabb verzióra frissítéshez. Ha a Github repo volt klónozva, nem biztos, hogy elég a pull a legújabb verzióra, mert néhány használt csomag, mint például a fordító, lehet, hogy kíván upgrade-et is. Ezt érdemes npm install paranccsal kiváltani, nem pedig npm update-tel.

== Saját kód és OL3 kód együttes fordítása ==

Egy alternatíva testre-szabott build-ek készítésére a saját kód OpenLayers 3-mal együtt történő fordítása a Closure fordító segítségével. Ennek a módszernek előnye az, hogy a Closure fordító kiszűri azokat a kódokat, melyeket az alkalmazás nem használ, és ehhez nem szükséges egy „exports” lista írása és karbantartása. Ugyanakkor lehetővé teszi olyan OpenLayers 3 függvények és objektumok használatát, melyek nem részei az OpenLayers 3 API-nak. Ez kissé kockázatos is lehet, de szerencsére a fordító szól, ha olyan függvényeket és objektumokat használnánk, melyek már nem az OpenLayers 3 API részei. (A módszerről részletesebben: [http://openlayers.org/en/v3.15.1/doc/tutorials/closure.html itt] olvasható.)

== Eltérő koordináta rendszerek esete ==

Az OpenLayers 3 képes megjeleníteni raszteres adatot WMS, WMTS, statikus kép típusú és sok más forrásból a szervertől kapott koordináta rendszertől eltérően. A koordináták transzformálása a web böngészőben történik. A nézet minden Proj4js támogató koordináta referencia rendszerben lehetséges, és előzetesen inkompatibilis rétegek ma már kombinálhatóak. Az alábbi példa során látható, hogy a forrás és a nézet koordináta rendszere eltérő, az átszámítás megtörténik viszont automatikusan.

<syntaxhighlight lang="javascript">
var map = new ol.Map({
target: 'map',
view: new ol.View({
projection: 'EPSG:3857', //HERE IS THE VIEW PROJECTION
center: [0, 0],
zoom: 2
}),
layers: [
new ol.layer.Tile({
source: new ol.source.TileWMS({
projection: 'EPSG:4326', //HERE IS THE DATA SOURCE PROJECTION
url: 'http://demo.boundlessgeo.com/geoserver/wms',
params: {
'LAYERS': 'ne:NE1_HR_LC_SR_W_DR'
}
})
})
]
});
</syntaxhighlight>

== Érdekes és látványos példák ==

* [http://openlayers.org/en/v3.15.1/examples/animation.html Animációk térképen (View Animation)]
* [http://openlayers.org/en/v3.15.1/examples/box-selection.html Ország, országok kijelölése (Box Selection) ]
* [http://openlayers.org/en/v3.15.1/examples/earthquake-clusters.html Földrengések és mértékének megjelenítése (Eartquake Clusters)]
* [http://openlayers.org/en/v3.15.1/examples/export-pdf.html Exportálás pdf-be]
* [http://openlayers.org/en/v3.15.1/examples/flight-animation.html Repülő animáció (Flight Animation)]
* [http://openlayers.org/en/v3.15.1/examples/kml-timezones.html Időzónák KML-lel (Timezones in KML)]
* [http://openlayers.org/en/v3.15.1/examples/measure.html Terület felmérés (Measure)]

== Források ==
* Open Layers 3 hivatalos oldala: [http://openlayers.org/ http://openlayers.org/]
* FOSSGIS Konferencia - 2015 Münster- Andreas Hocevar, Bart van den Eijnden, Marc Jansen előadása – [https://www.youtube.com/watch?v=U3ByMIIsA_Y OpenLayers 3]

GeoTools

2017-04-11T16:39:38Z

Mate: Syntax highlight

== GeoTools ==

A GeoTools egy általános célú nyílt forráskódú (LGPL) térinformatikai Java kód könyvtár, amely OGC szabványoknak megfelelő adatszerkezeten alapul, lehetővé téve vektor, raszter, adatbázis és térinformatikai formátumok kezelését előre definiált interfészen keresztül, mint:

• WMS: Web Map Service, GIS adatbázisból származó georeferenciával rendelkező térképek internetes továbbítását és megjelenítését teszi lehetővé (a térképi adatokat digitális képpé alakítja)

• WCS: Web Coverage Service, georeferált digitális képek (légifotó, űrfelvétel) internetes továbbítását teszi lehetővé

• WFS: Web Feature Service, georeferenciával rendelkező térbeli adatok (vektoros adatok) internetes továbbítását teszi lehetővé (nem alakítja az adatokat digitális képpé)

== Története ==

1996-ban kezdődött a GeoTools 1 fejlesztése a leedsi egyetem (University of Leeds, West Yorkshire, Anglia) mesterképzésének keretében, amelynek célja, hogy egy olyan eszközt hozzanak létre az ügyfelek számára, mely lehetővé teszi különböző adatok interaktív földrajzi megjelenítését.
2002-ben fejlesztők egy nemzetközi csoportjával újraírták, követve az OGC előírásokat, ez a GeoTools 2. Addig a verziószámokat követve frissítették a projekt nevét, majd 2007-ben ezt ejtették és javították egyszerűen GeoTools-ra, a verziószámot pedig külön kezelik.

== Felépítés ==

Java-ban íródott, nyílt forráskódú platformfüggetlen szoftver/bővítmény, melyet jelenleg is fejlesztenek. Moduláris felépítése lehetővé teszi funkcionalitásának egyszerű bővítését. Másrészről, így szakértői területek szerint tagolódik.

A többi open source szoftverhez hasonlóan a GeoTools is nyílt repozitorival kell, hogy rendelkezzen. Vagyis rendelkezik egy fejlesztői és egy vagy több futó verzióval (stabil és karbantartott). Ez utóbbiak, amelyeket fejlesztenek, ezek új szolgáltatásokat, fejlesztéseket és hibajavításokat tartalmaznak. Verziókezelőnek Git-et használ, ahol major.minor.patch számozási rendszert alkalmaz.

• major – a növekvő fő verziószámot jelöli (pl.: 8.xy-ról 9.0.0-ra), vagyis olyan jelentős változás következett be, amely tönkreteheti az előző verziókkal való kompatibilitást.

• minor – kisebb változás (pl.: 8.0.x-ről 9.0.1-re), ahol új funkciók és/vagy javítások következnek, amely nincs hatással a kompatibilitásra

• patch – csak a patch azonosító változik, azaz kisebb javításokat/változtatásokat eszközöltek az előző verzióhoz képest

== Architektúra ==

[[Fájl:Geotools.jpg]]

Egymásra épülő rétegekből áll.

• Térinformatikai rendszer használatához szükség van: gt-opengis, gt-referencing and gt-metadata,

• továbbá a használni kívánt adatokhoz a gt-api, gt-data, gt-main, jts, gt-opengis, gt-referencing, gt-opengis, gt-metadata modulokra.

== Tereptárgyak, geometriák ==

'''Feature'''

A tereptárgy egy olyan objektum, amit a térképen megjeleníthetünk. JAVA-ra fordítva egy tereptárgy egy JAVA objektum (Object). Mint minden objektumnak, a tereptárgyaknak is lehetnek tulajdonságaik, amik a valós tulajdonságait jelölik (például elhelyezkedés, magasság, felület).

A hasonló tereptárgyakat - például települések, repülőterek - csoportosítani lehet, ezek lesznek a JAVA osztályok (class).

{| class="wikitable"
|+ JAVA és GeoSpatial elemek megfeleltetése egymásnak
|-
! JAVA
! GeoSpatial
|-
| Object
| Feature
|-
| Class
| FetureType
|-
| Field
| Attribute
|-
| Method
| Operation
|}

'''FeatureClass'''

A GeoToolsban a Feature, a FeatureType és az Attribute külön, a GeoAPI projekt által nyújtott interfészeket használnak.
Gyakori, hogy egy Featurenek csak szimpla attribútumai vannak (például név, mérési hely, mérr érték), ahelyett, hogy más Featureökre hivatkoznának vagy összetett struktúrákkal tárolnának adatokat. Emiatt lett különválasztva a Featuretől a SimpleFeature nevű objektum. Implementációs szemszögből ez nagyon hasonlít a Java mapekhez. Az attribútumok neve egy kulcs, ehhez a kulcshoz kapcsolódik az attribútum értéke.

[[Fájl:feature.png]]

'''Geometry'''

Az objektumok és tereptárgyak abban különböznek egymástól, hogy a tereptárgyak tartalmaz valamilyen helyre vonatkozó információt. Ezt az információt tartalmazza a geometria és egy attribútumként lesz tárolva.
Geometriák reprezentálása a JTS használatával történik.

<syntaxhighlight lang="java">
GeometryFactory geometryFactory = JTSFactoryFinder.getGeometryFactory( null );
WKTReader reader = new WKTReader( geometryFactory );
Point point = (Point) reader.read("POINT (1 1)"); //új pont létrehozása Well-Known-Text formátummal

GeometryFactory geometryFactory = JTSFactoryFinder.getGeometryFactory( null );
Coordinate coord = new Coordinate( 1, 1 ); //új koordináta létrehozása
Point point = geometryFactory.createPoint( coord ); //új pont létrehozása a korábban elkészített koordinátából
</syntaxhighlight>

'''DataStore'''

A DataStore API olyan fájlok, szolgáltatások vagy adatbázisok reprezentálására szolgál, amik térbeli adatokat tartalmaznak. A FeatureSource osztály végzi az adatok beolvasását, az ezt implementáló FeatureStore használatos az írási/olvasási engedélyek vizsgálatára.

<syntaxhighlight lang="java">
String typeNames = dataStore.getTypeNames()[0];
SimpleFeatureSource source = store.getfeatureSource( typeName );
if( source instanceof SimpleFeatureStore){
SimpleFeatureStore store = (SimpleFeatureStore) source; // írási jogosultság
store.addFeatures( featureCollection ); //új objektumok hozzáadása a gyűjteményhez
store.removeFeatures( filter ); // szűrés, mint az SQL where feltételében
store.modifyFeature( attribute, value, filter ); //módosítás
}
</syntaxhighlight>

[[Fájl:datastore.png]]

== Alapfunkciók ==

* Interfészek definiálása alapvető térbeli koncepciókhoz és adatstruktúrákhoz
** Integrált geometria támogatás a Java Topology Suite (JTS) által
** Attribútum és térbeli szűrések OGC szabványok alapján

* Letisztult adatelérést biztosító API, tranzakciókezeléshez és szálkezeléshez
** GIS adatokhoz való hozzáférés többféle fájlformátumból és térbeli adatbázisból
** Referencia koordináta-rendszerek közötti konverzió támogatása
** Vetületek széles körű támogatása
** térbeli és nem-térbeli adatok szűrése és feldolgozása

* Állapotmentes, alacsony memóriaigényű megjelenítőréteg, ami kifejezetten előnyös szerver-oldali környezetekben
** Térképek szerkesztése és megjelenítése összetett stílusokkal
** Címkék, színek kezelése bővítményeken keresztül

* Hatékony séma alapú XML feldolgozás

* Beépülő modulok: nyílt plugin rendszer nem támogatott formátumok feldolgozására

* GeoTools Extensions: további térbeli funkcionalitást ad az alapfunkciókhoz
** Gráfok és hálózatok támogatása (például legrövidebb utak meghatározásához)
** Webes térképszerver és kliens

* GeotTools által nem támogatott bővítményeken
**Swing támogatás, lokális és webes folyamattámogatás, új formátumok, négyzetrácsok generálása és ISO geometriák implementációja

== Modulok ==

'''OpenGIS''' (gt-opengis) – ''Térinformatikai koncepciók''

Térinformatikai elemzések a következőkre: környezettudomány, élettan, ökológia, geológia, járványtan. A GIS célja, hogy rögzítse, tárolja, elemezze, kezelni és megjeleníteni tudja a más-más típusú földrajzi adatokat, s azt különböző kontextusokban, műveletekben és alkalmazásokban felhasználja. Az adatok OGC vagy ISO szabvány szerint definiáltak.
Interfészek: gt-main, gt-coverage, gt-referencing, gt-metadata

'''JTS''' (Java Topology Suite) – ''Geometriai adatokat alkalmazásához''

Geometriai műveletek, tranformációk számítása
Interfészek: gt-api, gt-main

'''API'''

Helper osztályokat tartalmaz, melyek geometriai adatokat fordítanak
Interfészek: gt-main

'''Metadata'''

Térinformatikai adatok és szolgáltatások leírása
Interfészek: gt-opengis

'''Referencing''' – (EPSG[http://www.epsg-registry.org/]) ''Referencia információk''

A hivatkozott terület adatait, koordinátáit tartalmazza
Interfészek: gt-opengis
Coverage – Raszter adatok használata
Lehetőséget biztosít különféle távérzékelési, térinformatikai, térképészeti, földmérési adatokat tartalmazó raszter képfájlok használatához (GeoTIFF) vagy többdimenziós mátrixhoz (NetCDF). A TIFF formátumú képek digitális műholdas felvételek tárolására és szállítására alkalmas, ami lehet légi fotó, terepmodell, térkép vagy különféle földrajzi elemzések.
Interfészek: gt-opengis

'''Main''' – ''Szűrők, funkciók, stílusok''

Alapértelmezett implementációkat tartalmaz a gt-api és gt-opengis interfészek számára, mint szűrők, funkciók, stílusok használata, ezek összessége már elegendő egy alkalmazás készítéséhez.
Interfészek: gt-opengis

'''Data'''

Támogatja a hozzáférést a különböző információkhoz, például vektorgrafikus adatok elérése, külső szolgáltatások, lemezfájlok használata az alkalmazásban.
Interfészek: gt-api

'''JDBC'''

Hozzáférést biztosít a különböző adatbázisokhoz a Java JDBC segítségével.

'''CQL'''

A térinformatikai adatokkal való munkához, olyan ember által olvasható szűrőkifejezésekre van szükségünk, mint a gt-cql modulban található kontextus leíró nyelv. (ítéletlogika)

'''XML'''

XML használatával támogatja a térinformatikai adatok elemzését és kódolását.

'''Render'''

Java2D felhasználásával térinformatikai adatok képi megjelenítését teszi lehetővé a térképen.

[[Fájl:Module.png]]

==Java Topolgy Suite==

A GeoTools erősen épít a Java Topology Suite (JTS) nyújtotta szolgáltatásokra.

A JTS is egy nyílt forráskódú könyvtár, az Euklideszi lineáris síkgeometria informatikai alkalmazásaihoz szolgáltat különböző eszközöket. Alapvetően GIS szoftverek részeként használt, az OpenGIS konzorcium által definiált geometriai modelleket és API-kat implementálja.

'''Geometriai modell'''

A geometria osztályok pontok, vonalláncok (Linestring), poligonok és gyűjtemények (collection) modellezését támogatják. A geometriák határai egyértelműen megfogalmazottak, a 2 dimenziós euklideszi térben definiáltak. Ugyanakkor egy Z értéket is tartalmazhatnak az objektumok.

'''Geometriai funkciók'''

* Topológiai érvényesség vizsgálata
* Terület és távolság funkciók
* Fedési funkciók, mint például metszet, különbség, unió, szimmetrikus differencia
* Bufferek számítása
* Konvex burok
* Geometriai egyszerűsítések
* Geometriai sűrítés
* Lineáris vonatkoztatás
* Delaunay háromszögelés
* Voronoi diagramm generálása
* Legkisebb befoglaló háromszög

''' Térbeli struktúrák és algoritmusok '''

* Vonalszegmensek metszete
* Pont a poligonban hatékony meghatározása
* Térbeli indexstruktúrák, mint például a negyedelő-fa
* Planáris gráfstruktúrák és algoritmusok

== Lekérdezések használata ==

A GeoTools programcsomag többféle lekérdezési műveletet és adatbázisok széles körét támogatja. Lehetőség van fájlokból (például shapefile) adatokat betölteni és raktuk lekérdezéseket elvégezni valamint lokális és távoli szerveren elérhető adatbázishoz csatlakozni és ott térbeli lekérdezéseket (spatial query) végrehajtani.

'''A GeoTools adatbázis kezelő rétegének felépítése'''

Adatbázisból úgynevezett Filterek segítségével tudunk lekérdezni. A filterek a CQL nyelv segítségével fogalmazhatjuk meg. A CQL hasonló az SQL nyelv where záradékában használt feltételekhez. Az adatbázist egy DataStore nevű objektum reprezentálja. A CQL nyelv segítségével lehetőségünk van különféle térbeli lekérdezéseket (példáull legkisebb befoglaló négyzet, terület, kerület, távolság meghatározása) elvégezni, de lehetséges nem-térbeli lekérdezések végrehajtása is.

Az adatbázis-kapcsolat felépítésében egy beépített, JDataStoreWizard nevű komponens nyújt segítséget. Itt csak be kell paramétereznünk, hogy milyen adatbázisból vagy fájlból szeretnénk kinyírni az adatokat.

'''Példa kódrészletek'''

'''JDataStoreWizard inícializálása'''

<syntaxhighlight lang="java">
JDataStoreWizard wizard = new JDataStoreWizard(format);
int result = wizard.showModalDialog();
if (result == JWizard.FINISH) {
Map<String, Object> connectionParameters = wizard.getConnectionParameters();
dataStore = DataStoreFinder.getDataStore(connectionParameters);
if (dataStore == null) {
JOptionPane.showMessageDialog(null, "Could not connect - check parameters");
}
updateUI();
}
</syntaxhighlight>

'''Szűrések'''

<syntaxhighlight lang="java">
Filter filter = CQL.toFilter("BBOX(ATTR1, 151.12, 151.14, -33.5, -33.51)");
SimpleFeatureCollection features = source.getFeatures(filter);
FeatureCollectionTableModel model = new FeatureCollectionTableModel(features);
table.setModel(model);
</syntaxhighlight>

Az első sorban létrehozzuk a Filter objektumot. A Filter az argumentumban megadott CQL lekérdezés eredményét - jelen esetben a pontok által határolt befoglaló négyszögben lévő térobjektumokat - adja vissza.

A második sorban lévő kód végzi a tényleges szűrést: egy FeatureCollection-be tölti be a lekérdezésnek eleget tevő tereptárgyakat.

Ez után létrehozunk egy modellt, amit később egy táblázatban meg tudunk jeleníteni grafikusan.

''Példa lekérdezés az elemek számlálásához''

<syntaxhighlight lang="java">
String typeName = (String) featureTypeCBox.getSelectedItem();
SimpleFeatureSource source = dataStore.getFeatureSource(typeName); //adatforrás definiálása
Filter filter = CQL.toFilter("city_population > 350000"); //szűrjünk a 350.000-nél több lakosú városokra
SimpleFeatureCollection features = source.getFeatures(filter); //leszűrt elemek
int count = features.size(); //elemek száma
JOptionPane.showMessageDialog(text, "A feltételeknek megfelelő elemek száma: " + count); //eredmény kiíratása egy dialógusablakba
</syntaxhighlight>

'''Lekérdezés megjelenítése grafikusan'''

A lekérdezett tereptárgyakat grafikus úton a következőképpen tudjuk megjeleníteni:

<syntaxhighlight lang="java">
StyleBuilder styleBuilder = new StyleBuilder();
PolygonSymbolizer restrictedSymb = styleBuilder.createPolygonSymbolizer(Color.BLUE, Color.BLACK, 0);
Style myStyle = styleBuilder.createStyle(restrictedSymb);
FeatureLayer layer = new FeatureLayer(features, myStyle);
layer.setTitle(text.getText());
mapFrame.getMapContent().addLayer(layer);
</syntaxhighlight>

A StyleBuilder osztállyal tudunk egyéni megjelenítési stílust létrehozni.<br />
A 2. sorban beállítjuk, hogy fekete kontúrú, kék színnel kitöltött objektumok keletkezzenek. <br />
Ezután létrehozunk egy FeatureBuildert, ami a tereptárgyak megjelenítésében segít. Erre a rétegre helyezzük fel a különböző objektumokat. Később ezt a réteget tudjuk megjeleníteni a térképen.<br />

[[Fájl:Geotools_terkep.jpg|600px]]

Rövid magyarázat a képhez:
# Rétegek neve, színek, láthatósága
# Lekérdezések eredményének táblázatos megjelenítése az összes attribútummal együtt
# A lekérdezés eredményét (vörös) és az eredeti adathalmazt megjelenítő térkép
# A térkép nagyítására, kicsinyítésére és mozgatására használható eszköztár

'''Az elkészített térkép elmentése képként'''

<syntaxhighlight lang="java">
A GeoTools különböző eszközöket biztosít a stílusokkal formázott térképek képként való mentéséhez.

String[] writers = ImageIO.getWriterFormatNames();
//Formátumot és nevet bekérő panel létrehozása
String format = (String) JOptionPane.showInputDialog(mapFrame,
"Térkép kiterjesztése:", "Kiterjesztés kiválasztása",
JOptionPane.PLAIN_MESSAGE, null, writers, "png");
String localDirectory = SAVE_DIR;
...
//Szerkesztett térképpanel elkérése
JMapPane mapPane = mapFrame.getMapPane();
ImageOutputStream outputImageFile = null;
FileOutputStream fileOutputStream = null;
try {
fileOutputStream = new FileOutputStream(new File(localDirectory));
outputImageFile = ImageIO.createImageOutputStream(fileOutputStream);
//a lekért térkép képét kiírjuk fájlba
RenderedImage bufferedImage = mapPane.getBaseImage();
ImageIO.write(bufferedImage, outputType, outputImageFile);
} catch (IOException ex) {
LOGGER.error(ex);
} finally {
try {
if (outputImageFile != null) {
outputImageFile.flush();
outputImageFile.close();
fileOutputStream.flush();
fileOutputStream.close();
}
} catch (IOException e) {
LOGGER.error(e);
}
}
</syntaxhighlight>

== Használata ==

Telepítést nem igényel, mivel ez egy könyvtár. Szükség van fejlesztői környezetre (Eclipse, NetBeans), valamint magára a könyvtárra[http://sourceforge.net/projects/geotools/files/], ahol a 11-es verziótól kezdődően Java 1.7 SDK szükséges.

Maven használata (ajánlott) Eclipse-ben:

'''1.''' Válasszuk a File > New > Other menüpontot

'''2.''' A varázslóban a Maven > Maven project pontot

'''3.''' A New Maven varázslójában menjünk tovább, majd az alapértelmezett maven-archtype-quickstart –ot választjuk és tovább megyünk

'''4.''' A következő pontban meg kell adnunk a projekt adatait:

• Group Id: org.geotools

• Artifact Id: tutorial

• Version: 0.0.1-SNAPSHOT (default)

• Package: org.geotools.tutorial

'''5.''' Finish-re kattintva létrejött az új projekt

'''6.''' Az App.java futtatásakor megjelenik a konzolon a „Hello World!”

A pom.xml fájlban a különböző pluginokhoz tartozó Jar fájlokat a Maven projekt letölti az ún. „local repository”-ba.
A GeoTools használatához adjuk hozzá a következőket a pom.xml fájlunkhoz:

<syntaxhighlight lang="xml">
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<geotools.version>12-RC1</geotools.version>
</properties>

<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.geotools</groupId>
<artifactId>gt-shapefile</artifactId>
<version>${geotools.version}</version>
</dependency>
<dependency>
<groupId>org.geotools</groupId>
<artifactId>gt-swing</artifactId>
<version>${geotools.version}</version>
</dependency>
</dependencies>

<repositories>
<repository>
<id>maven2-repository.dev.java.net</id>
<name>Java.net repository</name>
<url><nowiki>http://download.java.net/maven/2</nowiki></url>
</repository>
<repository>
<id>osgeo</id>
<name>Open Source Geospatial Foundation Repository</name>
<url><nowiki>http://download.osgeo.org/webdav/geotools/</nowiki></url>
</repository>
</repositories>
</syntaxhighlight>

== Példaprogram shapefájlok megjelenítésére ==

'''1.''' Az előző Maven projektben hozzunk létre egy új csomagot org.geotools.tutorial.quickstart névvel a következő osztállyal <code>org.geotools.tutorial.quickstart.Quickstart</code>

'''2.''' Egy fájlválasztó létrehozásával megkönnyítjük a shapefájlok kiválasztásához
<syntaxhighlight lang="java">
File file = JFileDataStoreChooser.showOpenFile("shp", null);
if (file == null) {
return;
}

FileDataStore store = FileDataStoreFinder.getDataStore(file);
SimpleFeatureSource featureSource = store.getFeatureSource();
</syntaxhighlight>

'''3.''' Betöltjük a shapefájlt
<syntaxhighlight lang="java">
MapContent map = new MapContent();
map.setTitle("Quickstart");

Style style = SLD.createSimpleStyle(featureSource.getSchema());
Layer layer = new FeatureLayer(featureSource, style);
map.addLayer(layer);
</syntaxhighlight>

'''4.''' Megjelenítjük
<syntaxhighlight lang="java">
JMapFrame.showMap(map);
</syntaxhighlight>

== Programozási megoldások ==

'''GeoServer'''

'''1.''' Telepítés után a következő linken érjük el: http://localhost:8080/geoserver/web/

'''2.''' Hozzunk létre egy új Workspace-t

'''3.''' Ehhez adjunk egy új adattárat, amely shapefájlokat tartalmaz, tehát válasszuk a Directory of spatial files (shapefiles) lehetőséget

'''4.''' A GeoServer telepítési helyét keressük meg a számítógépen, ebben a Server Status menüpont szolgál segítségül. Majd a data_dir mappába másoljunk kedvünk szerint shapefájlokat.

'''5.''' Válasszuk ki a 2. pontban létrehozott Workspace-t, töltsük ki az erre a pontra vonatkozó leírást, valamint válasszuk ki a GeoServer data_dir mappájába azt a mappát, amely tartalmazza a használni kívánt shapefájlokat és mentsünk.

'''6.''' A Layers menüpontban tegyük nyilvánossá azokat a shapefájlokat, amelyeket használni szeretnénk a továbbiakban. Ehhez szükséges egy SRS kód, ami legyen 4326 (WSG – földmérési adatokat tartalmaz). Ezek után a határok számítása következik, ezt kitölti az oldal a Compute linkekre kattintva. Mentsünk.

'''7.''' A Layers Group menüpontban hozzunk létre egy csoportját az új rétegeknek. Adjunk nevet és leírást a csoportnak. Majd adjuk hozzá a használni kívánt rétegeket (shapefájlokat). Ezeket kirajzolásuk szerinti sorrendbe helyezhetjük. Mentsünk.

'''8.''' A Layer Prewiev menüpontban keressük meg azt a csoportot, amit az előző pontban létrehoztunk, majd kattintsunk az OpenLayers hivatkozásra. Ekkor egy új lapon kirajzolódnak a shapefájlok.

[[Fájl:Geoserver.jpg]]

== Felhasználási helye ==

* GeoServer
** Nyílt forráskódú szerver alkalmazás, térbeli adatok megosztására

* uDig
** Teljeskörű JAVA asztali megoldás GIS adatok feldolgozására, GIS szoftverek készítéséhez

* GeoPublisher

* Geomajas
** Nyílt forráskódú GIS könyvtárak, eszközök és API-k gyűjteménye, szerver-alapú térképészeti megoldások támogatásához

* Postgresql/PostGIS

* 52N

* Atlas Styler
** Térképszerkesztő szoftver, fejlesztése mára megszűnt, azonban a forráskód szabadon elérhető ([http://en.geopublishing.org//])

== Felhasználási lehetőségek ==

- Térinformatikai adatok, szimbólumok megjelenítése és szűrése OGC szabványból (CQL, SLD, SFS, WCS, WCPS, WFS, WMS, WMTS, WPS)

- JTS - az Euklideszi vektorteren végzett geometriai transzformációk modellezéséhez

- Rácshálók, shape fájlok és raszter felvételek olvasása

- Grafikonok és hálózatok készítése, elemzése

== Jellemző funkciók ==

'''Térbeli fogalmakra és adatszerkezetekre meghatározott interfészek'''

• Attribútum és térbeli szűrőkkel OGC adatok használata

• Geometriai transzformációk modellezése

'''Adatelérés'''

• Térbeli adatbázisok és GIS adatok számos formátumának támogatása

'''Alacsony memóriahasználat'''

• Disk-ről renderel, nem a memóriába ír. Különösen hasznos szerveroldali környezetben.

• Bonyolult térképek megjelenítése

== Támogatott formátumok ==

'''Raszter formátum:'''
arcsde, arcgrid, geotiff, grassraster, gtopo30, image (JPEG, TIFF, GIF, PNG), imageio-ext-gdal, imagemoasaic, imagepyramid, JP2K, matlab

'''Adatbázis “jdbc-ng” támogatás:'''
db2, h2, mysql, oracle, postgis, spatialite, sqlserver

'''Vektor formátum:'''
app-schema, arcsde, csv, dxf, edigeo, excel, geojson, org, property, shapefile, wfs

'''XML:'''
xsd-core (xml simple types), fes, filter, gml2, gml3, kml, ows, sld, wcs, wfs, wms, wps, vpf.

== Implementált szabványok ==

* OGC Styled Layer Descriptor
** Tereptárgyak, felületek felhasználó által definiálható szimbolizálása, színezése

* OGC General Feature Model

* Raszteres adatok OGC Grid Coverage reprezentációja

* OGC Filter and Common Constraint Language (CQL)

* ISO 19107 Geometry
** A tereptárgyakat leíró objektumok alapvetó karakterisztikáját írja le

== Hivatkozások ==

http://geotools.org/

http://www.geoapi.org/

http://geoserver.org/

http://www.opengeospatial.org/

Mi az az OGC? - https://www.youtube.com/watch?v=bfkCdir-yO8

http://svn.osgeo.org/geotools/trunk/modules/plugin/

https://github.com/geotools/geotools/wiki

http://sourceforge.net/projects/geotools/files/

http://www.naturalearthdata.com/

http://www.epsg-registry.org/

http://spatialreference.org/ref/epsg/wgs-84/

http://docs.geotools.org/latest/userguide/tutorial/filter/query.html

https://github.com/geopublishing/atlasframework

https://en.wikipedia.org/wiki/JTS_Topology_Suite

http://docs.geotools.org/latest/userguide/tutorial/feature/csv2shp.html

DotSpatial

2017-04-11T16:34:09Z

Mate: Syntax highlight

A '''DotSpatial''' egy nyílt forráskódú térinformatikai programkönyvtár, amely különböző funkcionalitásokat biztosít téradat kezelés, betöltés és mentés, valamint elemzési feladatokra. A programkönyvtár <span class="plainlinks">[https://hu.wikipedia.org/wiki/C_Sharp C#]</span>-ban íródott és a <span class="plainlinks">[https://hu.wikipedia.org/wiki/.NET_keretrendszer .NET 4.0 keretrendszeren]</span> alapszik. Elsősorban asztali alkalmazások elkészítését segíti elő, amely a <span class="plainlinks">[https://en.wikipedia.org/wiki/Windows_Forms Windows Forms]</span> platformra épülnek. A programcsomag <span class="plainlinks">[https://hu.wikipedia.org/wiki/GNU_Lesser_General_Public_License GNU LGPL]</span> licenc alatt használható.

== Története ==

A könyvtár létrehozását az Idaho állami egyetemen (<span class="plainlinks">[https://en.wikipedia.org/wiki/Idaho_State_University Idaho State University]</span>) fejlesztett [[MapWindow]] alkalmazás ihlette. Kezdetben csak a saját belső fejlesztésüket szerették volna megkönnyíteni különféle központi funkciók kiszervezésével, idővel azonban a felhalmozott szolgáltatások száma elérte azt a méretet, hogy a fejlesztők úgy érezték, érdemes kiadni a nagyközönség számára is.
Sajnos a folyamatosan rétegződő, és központi koncepció nélküli fejlesztés rányomta a bélyegét a kódbázisra. Ennek megfelelően modulonként, vagy akár azokon belül is erősen eltérő megközelítéseket láthatunk a forráskódban.

== Szolgáltatások ==

* Térinformatikai adatok megjelenítése ''.Net Windows Form'', vagy Web alkalmazásokban
* Shapefájlok, rácshálók valamint raszter felvételek olvasása.
* Menet közbeni projektálás
* Tudományos analízis
* GPS adatok olvasása

== Kik használják? ==

* [http://mapwindow6.codeplex.com/ MapWindow 6]
* [http://hydrodesktop.codeplex.com/ HydroDesktop]
* [http://mad.codeplex.com/ MAD]
* [http://linesiter.codeplex.com/ LineSiter]
* [http://cetamon.codeplex.com/ Marine Life]
* [https://pvdesktop.codeplex.com/ PVMapper Site Designer]

== Használat ==

Telepítést nem igényel, ha használni szeretnénk, akkor két lehetőségünk közül választhatunk.

* Letölthetjük azt össze modult egyben a http://dotspatial.codeplex.com/ oldalról, majd később a szükséges projektekbe referenciázzuk őket.
* ''Visual Studio'' 2010-től felfelé használhatjuk a ''NuGet'' csomagkezelő, ahonnan telepíthetjük az egyes modulokat a kiválasztott projektek alá. Nagy előnye, hogy csomag frissülése esetén automatikusan eljut hozzánk is az új csomag.

== Windows Forms vezérlők ==

A DotSpatialt egyik legnagyobb előnye az előre megírt kontrolok, amiket a már jól megszokott Windows Formsos recept alapján akár vizuális szerkesztőben is összeállíthatunk.

=== DotSpatialt vezérlők telepítése ===

Ha szeretnénk használni a grafikus szerkesztőt, akkor mindenekelőtt hozzá kell adnunk a ''Toolbox''-hoz a DotSpatialt vezérlőit.

# Jobbklikk a Toolboxon, majd válasszuk ki az ''Add Tab'' menüpontot.
# Nevezzük az előbb hozzáadott fület.
# Ismét jobbklikk az új fülön, és válasszuk ki a Choose Item opciót.
# A felugró ablakból válasszuk ki a ''DotSpatial.Controls.dll''-t, ha nem találjuk a listából, akkor manuálisan adjuk hozz.

Most már ugyanúgy használhatjuk DotSpatial vezérlőit, mit a .NET alapértelmezettjeit.

== Vezérlők demonstrációja ==

A DotSpatial vezérlők segítségével rendkívül gyorsan tudjuk alkalmazásunkat felruházni térinformatikai képességekkel. A következő alkalmazás remek példa az előbbiekre.
Először készítsük el a felületet az alapértelmezett .NET, illetve a már ismertetett DotSpatial vezérlőkből.

<KÉP>

Miután megfelelően elneveztük a felületre elhelyezett elemeket, a hozzájuk tartozó kód mindössze ennyi:

<syntaxhighlight lang="csharp" line="line">
public partial class DesktopMapping : Form
{
private AppManager _AppManager;

public DesktopMapping()
{
InitializeComponent();

_AppManager = new AppManager();
_AppManager.LoadExtensions();
}

private void uxOpenFile_Click(object sender, EventArgs e)
{
uxMap.AddLayer();
}

private void uxZoomIn_Click(object sender, EventArgs e)
{
uxMap.ZoomIn();
}

private void uxZoomWide_Click(object sender, EventArgs e)
{
uxMap.ZoomToMaxExtent();
}

private void uxPan_Click(object sender, EventArgs e)
{
uxMap.FunctionMode = DotSpatial.Controls.FunctionMode.Pan;
}

private void uxGenShp_Click(object sender, EventArgs e)
{
var rnd = new Random();
var pg = new Polygon[100];
var f = new Feature();
var fs = new FeatureSet(f.FeatureType);

for (int i = 0; i < 100; i++)
{
var center = new Coordinate((rnd.Next(50) * 360) - 180, (rnd.Next(60) * 180) - 90);
var coord = new Coordinate[50];
for (int ii = 0; ii < 50; ii++)
{
coord[ii] = new Coordinate(center.X + Math.Cos((ii * 10) * Math.PI / 10), center.Y + (ii * 10) * Math.PI / 10);
}
coord[35] = new Coordinate(coord[0].X, coord[0].Y);
pg[i] = new Polygon(coord);
fs.Features.Add(pg[i]);
}
fs.SaveAs("C:\\Temp\\test.shp", true);
}
}
</syntaxhighlight>

== Bővítmények ==
Lehetőségünk van bővítmények készítésére, amelyek akár a már kész alkalmazásokba is könnyedén integrálódnak (ilyen például a MapWindow).

=== Példaprogram beépülő modulra ===

A bemutatásra kerülő bővítménnyel lehetőségünk lesz vonalakat rajzolni, réteget létrehozni, illetve megjeleníthetünk velük kapcsolatos magassági adatokat.
Elsőnek le kell töltenünk az online megtalálható [http://visualstudiogallery.msdn.microsoft.com/92919cee-a2b0-43c6-8993-aeac965bc4b5 sémával].

==== Diagram készítése ====

A magassági adatok megjelenítéséhez egy Windows Form alkalmazást készítünk.

<syntaxhighlight lang="csharp" line="line">
public void Plot(double[] data)
{
chart1.Series.Clear();
var series = chart1.Series.Add("Elevation (meters)");
series.ChartType = System.Windows.Forms.DataVisualization.Charting.SeriesChartType.Line;
series.Points.DataBindY(data);
}
</syntaxhighlight>

==== Raszter adatok kinyerése ====

A DotSpatial segítségével könnyedén kinyerhetjük a szükséges magassági adatokat.

<syntaxhighlight lang="csharp" line="line">
private static double GetElevation(IMapRasterLayer raster, Coordinate coordinate)
{
RcIndex rowColumn = raster.DataSet.Bounds.ProjToCell(coordinate);
double elevation = raster.DataSet.Value[rowColumn.Row, rowColumn.Column];
return elevation;
}
private static double GetDistance(double x1, double y1, double x2, double y2)
{
return Math.Sqrt(((x2 - x1) * (x2 - x1)) + ((y2 - y1) * (y2 - y1)));
}
</syntaxhighlight>

==== Koordináták kinyerése ====

<syntaxhighlight lang="csharp" line="line">
private List<Coordinate> GetCoordinatesFromLine(IMapLineLayer lineLayer)
{
IFeatureSet featureSet = lineLayer.DataSet;

// The coordinates should be the first feature of the feature set.
IList<Coordinate> lineCoordinates = featureSet.Features[0].Coordinates;

// Though the original line may only have a few points, we split
// each line segment into many points
List<Coordinate> pathCoordinates = new List<Coordinate>();

for (int i = 0; i < lineCoordinates.Count - 1; i++)
{
Coordinate startCoord = lineCoordinates[i];
Coordinate endCoord = lineCoordinates[i + 1];
List<Coordinate> segmentCoordinates = SplitSegment(startCoord.X, startCoord.Y, endCoord.X, endCoord.Y);

//add list of points from this line segment to the complete list
pathCoordinates.AddRange(segmentCoordinates);
}
return pathCoordinates;
}

private static List<Coordinate> SplitSegment(double startX, double startY, double endX, double endY)
{
const int MinimumDistanceBetweenPoints = 15;

double points = Math.Floor(GetDistance(startX, startY, endX, endY) / MinimumDistanceBetweenPoints);
int PointsPerSegment = (int)Math.Max(points, 1);

double curX = startX;
double curY = startY;
double constXdif = ((endX - startX) / PointsPerSegment);
double constYdif = ((endY - startY) / PointsPerSegment);

List<Coordinate> pathPointList = new List<Coordinate>(PointsPerSegment);
for (int i = 0; i <= PointsPerSegment; i++)
{
if (i == 0)
{
curX = startX;
curY = startY;
}
else
{
curX = curX + constXdif;
curY = curY + constYdif;
}
Coordinate coordinate = new Coordinate(curX, curY);
pathPointList.Add(coordinate);
}
return pathPointList;
}

private void ShowElevation()
{
if (!map.GetRasterLayers().Any())
{
MessageBox.Show("Please add a DEM raster layer to the map.");
return;
}

if (!map.GetLineLayers().Any())
{
MessageBox.Show("Please create a path by left clicking to add points and right-clicking to complete the path.");
return;
}

try
{
IMapRasterLayer rasterLayer = map.GetRasterLayers().First();
IMapLineLayer pathLayer = map.GetLineLayers().First();
var coords = GetCoordinatesFromLine(pathLayer);

double[] elevation = new double[coords.Count];
for (int i = 0; i < coords.Count; i++)
{
elevation[i] = GetElevation(rasterLayer, coords[i]);
}

ChartForm chart = new ChartForm();
chart.Plot(elevation);
chart.Show();
}
catch (Exception ex)
{
MessageBox.Show("Error calculating elevation. The whole path should be inside the DEM area. " + ex.Message);
}
}
</syntaxhighlight>

==== SimpleActionItem használata (menüelem) ====

<syntaxhighlight lang="csharp" line="line">
public void ButtonClick(object sender, EventArgs e)
{
// We're expecting this extension to only be run in a Windows Forms application.
// We'll depend on a few Windows Forms (Map) features like MouseDown, so we cast
// the App.Map as a Map and store a reference to it.
map = App.Map as Map;

// remove any existing path if needed.
if (_PathLineLayer != null)
map.Layers.Remove(_PathLineLayer);

_PathLineLayer = null;
_LineFeature = null;

// Let the user know we are ready for them to set points by changing the cursor.
map.Cursor = Cursors.Cross;
map.MouseDown += map_MouseDown;
}
</syntaxhighlight>

==== Vektor réteg létrehozása ====

<syntaxhighlight lang="csharp" line="line">
private void map_MouseDown(object sender, MouseEventArgs e)
{
if (e.Button == MouseButtons.Left)
{
// Encourage the user to select a raster, if they haven't done so.
if (!map.GetRasterLayers().Any())
{
map.AddRasterLayer();
map.ZoomToMaxExtent();
return;
}

StartOrContinueDrawingPath(e.Location);
App.ProgressHandler.Progress(null, 0, "Point registered. Click again to add line segment. Right-click to finish.");
}
else if (e.Button == MouseButtons.Right)
{
EndDrawingPath();
ShowElevation();
App.ProgressHandler.Progress(null, 0, "Ready.");
}
}

private IFeature AddLineFeatureSetToMap()
{
FeatureSet lineFeatureSet = new FeatureSet(FeatureType.Line);
lineFeatureSet.Projection = map.Projection;

// Initialize the featureSet attribute table by creating columns
DataColumn column = new DataColumn("ID", typeof(short));
lineFeatureSet.DataTable.Columns.Add(column);
DataColumn column2 = new DataColumn("Number of Points", typeof(int));
lineFeatureSet.DataTable.Columns.Add(column2);
DataColumn column3 = new DataColumn("Description");
lineFeatureSet.DataTable.Columns.Add(column3);

// Add the featureSet as map layer
_PathLineLayer = (MapLineLayer)map.Layers.Add(lineFeatureSet);
_PathLineLayer.Symbolizer = new LineSymbolizer(Color.Blue, 2);
_PathLineLayer.LegendText = "Path Layer";

var newList = new List<Coordinate>();
LineString lineGeometry = new LineString(newList);

// AddFeature creates the point and a row in the DataTable
return lineFeatureSet.AddFeature(lineGeometry);
}

private void StartOrContinueDrawingPath(System.Drawing.Point mouseLocation)
{
Coordinate coord = map.PixelToProj(mouseLocation);

if (_LineFeature == null)
{
// This is the first time we see a left click; create empty line feature.
_LineFeature = AddLineFeatureSetToMap();

// Add first coordinate to the line feature.
_LineFeature.Coordinates.Add(coord);

// Set the line feature attribute. This line may have multiple points,
// but there is only one row in the attribute table for the entire feature (line).
_LineFeature.DataRow["ID"] = 0;
_LineFeature.DataRow["Description"] = "Path (line)";
}
else
{
// Second or later click - add points to the existing feature
_LineFeature.BasicGeometry.Coordinates.Add(coord);
_LineFeature.ParentFeatureSet.InitializeVertices();

// Draw the line.
map.ResetBuffer();

// Update the attribute table.
_LineFeature.DataRow["Number of Points"] = _LineFeature.BasicGeometry.Coordinates.Count;
}
}

private void EndDrawingPath()
{
// The path is complete.
map.ResetBuffer();
map.Cursor = Cursors.Arrow;
map.MouseDown -= map_MouseDown;
_LineFeature = null;
}
</syntaxhighlight>

PgRouting

2017-04-11T16:27:50Z

Mate: Syntax highlight

Kezdőlap

2017-03-14T14:45:46Z

Mate:

'''Üdvözlet a GIS Wikin!'''

A GIS Wiki az [http://www.elte.hu Eötvös Loránd Tudományegyetem] [http://www.inf.elte.hu Informatikai Karának] egy belső információs oldala, amelynek célja alapvetően <span class="plainlinks">[http://hu.wikipedia.org/wiki/F%C3%B6ldrajzi_inform%C3%A1ci%C3%B3s_rendszer térinformatikai rendszerrek]</span>kel kapcsolatos ismeretek gyűjtése. A szócikkek anyagát elsősorban a [http://mcserep.web.elte.hu/elte/ttaf/ Térinformatikai és Távérzékelési Alkalmazások fejlesztése] tárgy hallgatói biztosították.

Jelenleg elérhető szócikkek:

* [[DotSpatial]]
* [[GeoTools]]
* [[GDAL/OGR]]
* [[MapServer]]
* [[OpenLayers]]
* [[PgRouting]]
* [[SharpMap]]
* [[SUMO]]

Az oldalt [http://people.inf.elte.hu/groberto Giachetta Roberto] és [http://mcserep.web.elte.hu Cserép Máté] szerkeszti.

Kezdőlap

2017-02-21T13:12:49Z

Mate:

'''Üdvözlet a GIS Wikin!'''

A GIS Wiki az [http://www.elte.hu Eötvös Loránd Tudományegyetem] [http://www.inf.elte.hu Informatikai Karának] egy belső információs oldala, amelynek célja alapvetően <span class="plainlinks">[http://hu.wikipedia.org/wiki/F%C3%B6ldrajzi_inform%C3%A1ci%C3%B3s_rendszer térinformatikai rendszerrek]</span>kel kapcsolatos ismeretek gyűjtése. A szócikkek anyagát elsősorban a [http://people.inf.elte.hu/groberto/elte_ttaf/ Térinformatikai és Távérzékelési Alkalmazások fejlesztése] tárgy hallgatói biztosították.

Jelenleg elérhető szócikkek:

* [[DotSpatial]]
* [[GeoTools]]
* [[GDAL/OGR]]
* [[MapServer]]
* [[OpenLayers]]
* [[PgRouting]]
* [[SharpMap]]
* [[SUMO]]

Az oldalt [http://people.inf.elte.hu/groberto Giachetta Roberto] és [http://mcserep.web.elte.hu Cserép Máté] szerkeszti.