streamalism.org

1. Oversikt

I denne artikkelen vil vi gå gjennom det grunnleggende om GeoTools open source Java-bibliotek - for å jobbe med geospatiale data. Dette biblioteket tilbyr kompatible metoder for implementering av Geographic Information Systems (GIS) og implementerer og støtter mange Open Geospatial Consortium (OGC) standarder.

Ettersom OGC utvikler nye standarder, blir de implementert av GeoTools, noe som gjør det ganske praktisk for geospatialt arbeid.

2. Avhengigheter

Vi må legge til GeoTools-avhengighetene i vår pom.xml fil. Siden disse avhengighetene ikke er vert på Maven Central, må vi også erklære deres arkiver slik at Maven kan laste dem ned:

  osgeo Open Source Geospatial Foundation Repository //download.osgeo.org/webdav/geotools/ opengeo OpenGeo Maven Repository //repo.opengeo.org 

Etter det kan vi legge til våre avhengigheter:

 org.geotools gt-shapefile 15.2 org.geotools gt-epsg-hsql 15.2 

3. GIS og Shapefiles

For å ha praktisk bruk av GeoTools-biblioteket, trenger vi å vite noen ting om geografiske informasjonssystemer og shapefiles.

3.1. GIS

Hvis vi ønsker å jobbe med geografiske data, trenger vi et geografisk informasjonssystem (GIS). Dette systemet kan brukes å presentere, fange, lagre, manipulere, analysere eller administrere geografiske data.

En del av de geografiske dataene er romlige - de refererer til konkrete steder på jorden. Romlige data ledsages vanligvis av attributtdataene. Attributtdata kan være tilleggsinformasjon om hver av de romlige funksjonene.

Et eksempel på geografiske data vil være byer. Byens faktiske plassering er romlige data. Ytterligere data som bynavn og befolkning utgjør attributtdataene.

3.2. Shapefiles

Forskjellige formater er tilgjengelige for arbeid med geospatiale data. Raster og vektor er de to primære datatypene.

I denne artikkelen skal vi se hvordan vi kan jobbe med vektordatatypene. Denne datatypen kan vises som punkter, linjer eller polygoner.

For å lagre vektordata i en fil, bruker vi a shapefile. Dette filformatet brukes når du arbeider med geospatial vektordatatype. Den er også kompatibel med et bredt spekter av GIS-programvare.

Vi kan bruke GeoTools til å legge til funksjoner som byer, skoler og landemerker til shapefiles.

4. Lage funksjoner

De GeoTools dokumentasjonen spesifiserer at en funksjon er alt som kan tegnes på et kart, som en by eller et landemerke. Og som vi nevnte, når funksjonene er opprettet, kan de deretter lagres i filer som kalles shapefiles.

4.1. Oppbevaring av geospatiale data

Før vi oppretter en funksjon, må vi kjenne dens geospatiale data eller lengde- og breddekoordinatene til plasseringen på jorden. Når det gjelder attributtdata, må vi vite navnet på funksjonen vi vil lage.

Denne informasjonen finner du på nettet. Noen nettsteder som simplemaps.com eller maxmind.com tilbyr gratis databaser med geodata.

Når vi vet lengden og bredden til en by, kan vi enkelt lagre dem i et eller annet objekt. Vi kan bruke en Kart objekt som inneholder bynavnet og en liste over koordinatene.

La oss lage en hjelpemetode for å lette lagring av data i vår Kart gjenstand:

privat statisk tomrom addToLocationMap (strengnavn, dobbel lat, dobbel lng, kart steder) {Listekoordinater = ny ArrayList (); koordinater.add (lat); koordinater.add (lng); locations.put (navn, koordinater); }

La oss nå fylle ut vårt Kart gjenstand:

Kart steder = nye HashMap (); addToLocationMap ("Bangkok", 13.752222, 100.493889, locations); addToLocationMap ("New York", 53.083333, -0.15, steder); addToLocationMap ("Cape Town", -33.925278, 18.423889, steder); addToLocationMap ("Sydney", -33.859972, 151.211111, lokasjoner); addToLocationMap ("Ottawa", 45.420833, -75.69, locations); addToLocationMap ("Cairo", 30.07708, 31.285909, locations);

Hvis vi laster ned noen CSV-database som inneholder disse dataene, kan vi enkelt opprette en leser for å hente dataene i stedet for å ha den i et objekt som her.

4.2. Definere funksjonstyper

Så nå har vi et kart over byer. For å kunne lage funksjoner med disse dataene, må vi først definere typen. GeoTools tilbyr to måter å definere funksjonstyper på.

En måte er å bruke createType metoden for DataUtilites klasse:

SimpleFeatureType TYPE = DataUtilities.createType ("Location", "location: Point: srid = 4326," + "name: String");

En annen måte er å bruk en SimpleFeatureTypeBuilder, som gir mer fleksibilitet. For eksempel kan vi angi koordinatreferansesystemet for typen, og vi kan angi en maksimal lengde for navnefeltet:

SimpleFeatureTypeBuilder builder = ny SimpleFeatureTypeBuilder (); builder.setName ("Location"); builder.setCRS (DefaultGeographicCRS.WGS84); byggmester .add ("Location", Point.class); .length (15) .add ("Name", String.class); SimpleFeatureType CITY = builder.buildFeatureType ();

Begge typene lagrer den samme informasjonen. Byens beliggenhet er lagret som en Punkt, og navnet på byen er lagret som en String.

Du har sannsynligvis lagt merke til at typevariablene TYPE og BY er navngitt med alle store bokstaver, som konstanter. Type variabler bør behandles som endelig variabler og bør ikke endres etter at de er opprettet, så denne måten å navngi kan brukes til å indikere nettopp det.

4.3. Feature Creation og Feature Collections

Når vi har definert funksjonstypen og vi har et objekt som har dataene som trengs for å opprette funksjoner, kan vi begynne å lage dem med deres byggherre.

La oss instantiere en SimpleFeatureBuilder gir vår funksjonstype:

SimpleFeatureBuilder featureBuilder = ny SimpleFeatureBuilder (CITY);

Vi trenger også en samling for å lagre alle de opprettet funksjonsobjektene:

DefaultFeatureCollection samling = ny DefaultFeatureCollection ();

Siden vi erklærte i vår funksjonstype å ha en Punkt for plasseringen, må vi lag poeng for byene våre basert på koordinatene. Vi kan gjøre dette med GeoTools JTSGeometryFactoryFinder:

GeometryFactory geometryFactory = JTSFactoryFinder.getGeometryFactory (null);

Noter det vi kan også bruke andre Geometri klasser som Linje og Polygon.

Vi kan lage en funksjon som vil hjelpe oss å sette funksjoner i samlingen:

privat statisk funksjon<>, SimpleFeature> toFeature (SimpleFeatureType CITY, GeometryFactory geometryFactory) {return location -> {Point point = geometryFactory.createPoint (new Coordinate (location.getValue () .get (0), location.getValue (). Get (1))) ; SimpleFeatureBuilder featureBuilder = ny SimpleFeatureBuilder (CITY); featureBuilder.add (punkt); featureBuilder.add (location.getKey ()); retur featureBuilder.buildFeature (null); }; }

Når vi har byggeren og samlingen, ved å bruke det tidligere opprettet funksjon, vi kan lag funksjoner og lagre dem i samlingen vår:

locations.entrySet (). stream () .map (toFeature (CITY, geometryFactory)) .forEach (collection :: add);

Samlingen inneholder nå alle funksjonene som er opprettet basert på vår Kart objekt som inneholdt geodata.

5. Opprette en DataStore

GeoTools inneholder en API for DataStore som brukes til å representere en kilde til geospatiale data. Denne kilden kan være en fil, en database eller en tjeneste som returnerer data. Vi kan bruke en DataStoreFactory å skape vårt DataStore, som inneholder funksjonene våre.

La oss angi filen som skal inneholde funksjonene:

File shapefile = ny fil (ny fil ("."). GetAbsolutePath () + "shapefile.shp");

La oss nå sette parametrene vi skal bruke til å fortelle DataStoreFactory hvilken fil vi skal bruke og indikerer at vi trenger å lagre en romlig indeks når vi oppretter vår DataStore:

Kartparametere = nye HashMap (); params.put ("url", shapeFile.toURI (). toURL ()); params.put ("create spatial index", Boolean.TRUE);

La oss lage DataStoreFactory ved hjelp av parametrene vi nettopp opprettet, og bruk fabrikken til å lage DataStore:

ShapefileDataStoreFactory dataStoreFactory = ny ShapefileDataStoreFactory (); ShapefileDataStore dataStore = (ShapefileDataStore) dataStoreFactory.createNewDataStore (params); dataStore.createSchema (CITY);

6. Skrive til en Shapefile

Det siste trinnet vi må gjøre er å skrive dataene våre til en shapefile. For å gjøre dette trygt, skal vi bruke Transaksjon grensesnitt det er en del av GeoTools API.

Dette grensesnittet gir oss muligheten til Enkelt begå endringene i filen. Det gir også en måte å utføre en tilbakeføring av de mislykkede endringene hvis det oppstår noe problem mens du skriver til filen:

Transaksjonstransaksjon = ny DefaultTransaction ("opprett"); String typeName = dataStore.getTypeNames () [0]; SimpleFeatureSource featureSource = dataStore.getFeatureSource (typeName); if (featureSource instanceof SimpleFeatureStore) {SimpleFeatureStore featureStore = (SimpleFeatureStore) featureSource; featureStore.setTransaction (transaksjon); prøv {featureStore.addFeatures (samling); transaction.commit (); } fangst (Unntaksproblem) {transaction.rollback (); } til slutt {transaction.close (); }}

De SimpleFeatureSource brukes til å lese funksjoner, og SimpleFeatureStore brukes til lese- / skrivetilgang. Det er spesifisert i GeoTools dokumentasjon som bruker tilfelle av metoden for å sjekke om vi kan skrive til filen er den rette måten å gjøre det på.

Dette shapefile kan senere åpnes med hvilken som helst GIS-seer som har shapefile Brukerstøtte.

7. Konklusjon

I denne artikkelen så vi hvordan vi kan bruke GeoTools bibliotek for å gjøre noe veldig interessant geo-romlig arbeid.

Selv om eksemplet var enkelt, kan det utvides og brukes til å skape rike shapefiles for forskjellige formål.

Vi burde ha det i bakhodet GeoTools er et levende bibliotek, og denne artikkelen fungerer bare som en grunnleggende introduksjon til biblioteket. Også, GeoTools er ikke begrenset til å opprette kun vektordatatyper - den kan også brukes til å lage eller jobbe med rasterdatatyper.

Du kan finne hele eksemplet på koden som brukes i denne artikkelen i GitHub-prosjektet vårt. Dette er et Maven-prosjekt, så du bør kunne importere det og kjøre det som det er.