Introduction
The GeoScript Groovy Cookbook contains short recipes on how to use the GeoScript Groovy library.
GeoScript is a geospatial library written in Groovy. It provides modules for working with geometries, projections, features, layers, rasters, styles, rendering, and tiles. It is built on top of the Java Topology Suite (JTS) and GeoTools libraries. GeoScript Groovy is open source and licensed under the MIT license.
Using GeoScript
To use GeoScript Groovy you need Java, Java Advanced Imaging (JAI), and Groovy installed and on your PATH. Next, download the latest stable release, the latest in development build, or build the code yourself. Then put the GeoScript Groovy bin directory on your PATH. You are now ready to use GeoScript Groovy!
GeoScript Groovy has three commands:
-
geoscript-groovy (which can run Groovy files)
-
geoscript-groovysh (which starts a REPL shell)
-
geoscript-groovyConsole (which starts a graphical editor/mini IDE)
geoscript-groovy
The geoscript-groovy command can run scripts file but it can also run inline scripts.
Convert a shapefile to geojson
geoscript-groovy -e "println new geoscript.layer.Shapefile('states.shp').toJSONString()"Get the Bounds of a Shapefile as a Geometry
geoscript-groovy -e "println new geoscript.layer.Shapefile('states.shp').bounds.geometry"Count the number of Features in a Shapefile
geoscript-groovy -e "println new geoscript.layer.Shapefile('states.shp').count"Render a Shapefile to an image
geoscript-groovy -e "geoscript.render.Draw.draw(new geoscript.layer.Shapefile('states.shp'), out: 'image.png')"Pipe a Shapefile’s geometry to another command line application that buffers each feature
geoscript-groovy -e "new geoscript.layer.Shapefile('states.shp').eachFeature{ println it.geom.centroid}" | geom combine | geom buffer -d 1.5Pipe the results of buffering a point to convert it to KML
echo "POINT (1 1)" | geom buffer -d 10 | geoscript-groovy -e "println geoscript.geom.Geometry.fromWKT(System.in.text).kml"Library
Maven
You can also use GeoScript Groovy as a library. If you use Maven you will need to add the Boundless Maven Repository:
<repositories>
<repository>
<id>boundless</id>
<name>Boundless Maven Repository</name>
<url>https://repo.boundlessgeo.com/main</url>
<snapshots>
<enabled>true</enabled>
</snapshots>
</repository>
</repositories>and then include the GeoScript Groovy dependency:
<dependency>
<groupId>org.geoscript</groupId>
<artifactId>geoscript-groovy</artifactId>
<version>1.14.0</version>
</dependency>Gradle
To use GeoScript Groovy in a Gradle project, add the following repositories:
repositories {
maven {
url "https://repo.boundlessgeo.com/main"
}
maven {
url "http://download.osgeo.org/webdav/geotools/"
}
}and the include the GeoScript Groovy dependency:
dependencies {
compile("org.geoscript:geoscript-groovy:1.14.0")
}Geometry Recipes
The Geometry classes are in the geoscript.geom package.
Creating Geometries
LineString
Create a LineString from Coordinates
LineString lineString = new LineString(
[3.1982421875, 43.1640625],
[6.7138671875, 49.755859375],
[9.7021484375, 42.5927734375],
[15.3271484375, 53.798828125]
)
Polygon
Create a Polygon from a List of Coordinates
Polygon polygon = new Polygon([[
[-101.35986328125, 47.754097979680026],
[-101.5576171875, 46.93526088057719],
[-100.12939453125, 46.51351558059737],
[-99.77783203125, 47.44294999517949],
[-100.45898437499999, 47.88688085106901],
[-101.35986328125, 47.754097979680026]
]])
Create a Polygon with holes
Polygon polygonWithHoles = new Polygon(
// Exterior Ring
new LinearRing(
[-122.39138603210449, 47.58659965790016],
[-122.41250038146973, 47.57681522195182],
[-122.40305900573729, 47.56523364515569],
[-122.38117218017578, 47.56621817878201],
[-122.3712158203125, 47.57235661809739],
[-122.37602233886717, 47.584747123985615],
[-122.39138603210449, 47.58659965790016]
),
// Holes
[
new LinearRing(
[-122.39859580993652, 47.578957532923376],
[-122.40468978881836, 47.57548347095205],
[-122.39593505859376, 47.570271945800094],
[-122.3920726776123, 47.57606249728773],
[-122.39859580993652, 47.578957532923376]
),
new LinearRing(
[-122.3836612701416, 47.58156292813543],
[-122.38829612731934, 47.57114056934196],
[-122.37456321716309, 47.57420959047542],
[-122.37868309020995, 47.58023129789275],
[-122.3836612701416, 47.58156292813543]
)
]
)
MultiPoint
Create a MultiPoint with a List of Points
MultiPoint multiPoint = new MultiPoint([
new Point(-122.3876953125, 47.5820839916191),
new Point(-122.464599609375, 47.25686404408872),
new Point(-122.48382568359374, 47.431803338643334)
])
MultiLineString
Create a MultiLineString with a List of LineStrings
MultiLineString multiLineString = new MultiLineString([
new LineString (
[-122.3822021484375, 47.57837853860192],
[-122.32452392578125, 47.48380086737799]
),
new LineString (
[-122.32452392578125, 47.48380086737799],
[-122.29705810546874, 47.303447043862626]
),
new LineString (
[-122.29705810546874, 47.303447043862626],
[-122.42889404296875, 47.23262467463881]
)
])
MultiPolygon
Create a MultiPolygon with a List of Polygons
MultiPolygon multiPolygon = new MultiPolygon(
new Polygon ([[
[-122.2723388671875, 47.818687628247105],
[-122.37945556640624, 47.66168780332917],
[-121.95373535156249, 47.67093619422418],
[-122.2723388671875, 47.818687628247105]
]]),
new Polygon ([[
[-122.76672363281249, 47.42437092240516],
[-122.76672363281249, 47.59505101193038],
[-122.52227783203125, 47.59505101193038],
[-122.52227783203125, 47.42437092240516],
[-122.76672363281249, 47.42437092240516]
]]),
new Polygon ([[
[-122.20367431640624, 47.543163654317304],
[-122.3712158203125, 47.489368981370724],
[-122.33276367187499, 47.35371061951363],
[-122.11029052734374, 47.3704545156932],
[-122.08831787109375, 47.286681888764214],
[-122.28332519531249, 47.2270293988673],
[-122.2174072265625, 47.154237057576594],
[-121.904296875, 47.32579231609051],
[-122.06085205078125, 47.47823216312885],
[-122.20367431640624, 47.543163654317304]
]])
)
GeometryCollection
Create a GeometryCollection with a List of Geometries
GeometryCollection geometryCollection = new GeometryCollection(
new LineString ([-157.044, 58.722], [-156.461, 58.676]),
new Point(-156.648, 58.739),
new Polygon([[
[-156.395, 58.7083],
[-156.412, 58.6026],
[-155.874, 58.5825],
[-155.313, 58.4822],
[-155.385, 58.6655],
[-156.203, 58.7368],
[-156.395, 58.7083]
]]),
new Point(-156.741, 58.582)
)
CircularString
Create a CircularString with a List of Points
CircularString circularString = new CircularString([
[-122.464599609375, 47.247542522268006],
[-122.03613281249999, 47.37789454155521],
[-122.37670898437499, 47.58393661978134]
])
CircularRing
Create a CircularRing with a List of Points
CircularRing circularRing = new CircularRing([
[-118.47656249999999, 41.508577297439324],
[-109.6875, 57.51582286553883],
[-93.8671875, 42.032974332441405],
[-62.57812500000001, 30.14512718337613],
[-92.10937499999999, 7.36246686553575],
[ -127.265625, 14.604847155053898],
[-118.47656249999999, 41.508577297439324]
])
CompoundCurve
Create a CompoundCurve with a List of CircularStrings and LineStrings
CompoundCurve compoundCurve = new CompoundCurve([
new CircularString([
[27.0703125, 23.885837699862005],
[5.9765625, 40.17887331434696],
[22.5, 47.98992166741417],
]),
new LineString([
[22.5, 47.98992166741417],
[71.71875, 49.15296965617039],
]),
new CircularString([
[71.71875, 49.15296965617039],
[81.5625, 39.36827914916011],
[69.9609375, 24.5271348225978]
])
])
CompoundRing
Create a CompoundRing with a connected List of CircularStrings and LineStrings
CompoundRing compoundRing = new CompoundRing([
new CircularString([
[27.0703125, 23.885837699862005],
[5.9765625, 40.17887331434696],
[22.5, 47.98992166741417],
]),
new LineString([
[22.5, 47.98992166741417],
[71.71875, 49.15296965617039],
]),
new CircularString([
[71.71875, 49.15296965617039],
[81.5625, 39.36827914916011],
[69.9609375, 24.5271348225978]
]),
new LineString([
[69.9609375, 24.5271348225978],
[27.0703125, 23.885837699862005],
])
])
Points
Get x, y, and z values from a Point
Point point = new Point(-122.38632, 47.58208, 101.45)
println "X = ${point.x}"
println "Y = ${point.y}"
println "Z = ${point.z}"
X = -122.38632 Y = 47.58208 Z = 101.45
Add two Points together to create a MultiPoint
Point point1 = new Point(-122.38632, 47.58208)
Point point2 = new Point(-122.37001, 47.55868)
MultiPoint points = point1 + point2
Add a Point to a MultiPoint
MultiPoint multiPoint = new MultiPoint(
new Point(-122.83813,47.05141),
new Point(-122.38220,47.58023)
)
println multiPoint.wkt
MultiPoint newMultiPoint = multiPoint + new Point(-122.48657, 47.271775)
println newMultiPoint.wktMULTIPOINT ((-122.83813 47.05141), (-122.3822 47.58023)) MULTIPOINT ((-122.83813 47.05141), (-122.3822 47.58023), (-122.48657 47.271775))
MultiPoint
MultiPoint with extra Point
Calculate the angle between two points
Point point1 = new Point(-122.29980, 47.65058)
Point point2 = new Point(-120.54199, 46.64943)
double angleInDegrees = point1.getAngle(point2, "degrees")
println "Angle in degrees = ${angleInDegrees}"
double angleInRadians = point1.getAngle(point2, "radians")
println "Angle in radians = ${angleInRadians}"
Angle in degrees = -29.663413013476646 Angle in radians = -0.5177242244641005
Calculate the azimuth between two points
Point point1 = new Point(-122.29980, 47.65058)
Point point2 = new Point(-120.54199, 46.64943)
double azimuth = point1.getAzimuth(point2)
println "Azimuth = ${azimuth}"
Azimuth = 129.21026122904846
LineStrings
Get the start Point from a LineString
LineString lineString = new LineString(
[3.1982421875, 43.1640625],
[6.7138671875, 49.755859375],
[9.7021484375, 42.5927734375],
[15.3271484375, 53.798828125]
)
Point startPoint = lineString.startPoint
Get the end Point from a LineString
LineString lineString = new LineString(
[3.1982421875, 43.1640625],
[6.7138671875, 49.755859375],
[9.7021484375, 42.5927734375],
[15.3271484375, 53.798828125]
)
Point endPoint = lineString.endPoint
Reverse a LineString
LineString lineString = new LineString(
[3.1982421875, 43.1640625],
[6.7138671875, 49.755859375],
[9.7021484375, 42.5927734375],
[15.3271484375, 53.798828125]
)
Point startPoint = lineString.startPoint
LineString reversedLineString = lineString.reverse()
Point reversedStartPoint = reversedLineString.startPointOriginal LineString showing start point
Reversed LineString showing start point
Determine if a LineString is closed or not
LineString lineString1 = new LineString(
[3.1982421875, 43.1640625],
[6.7138671875, 49.755859375],
[9.7021484375, 42.5927734375],
[15.3271484375, 53.798828125]
)
boolean isClosed1 = lineString1.closed
println "Is ${lineString1.wkt} closed? ${isClosed1}"
LineString lineString2 = new LineString(
[3.1982421875, 43.1640625],
[6.7138671875, 49.755859375],
[9.7021484375, 42.5927734375],
[15.3271484375, 53.798828125],
[3.1982421875, 43.1640625]
)
boolean isClosed2 = lineString2.closed
println "Is ${lineString2.wkt} closed? ${isClosed2}"
Is LINESTRING (3.1982421875 43.1640625, 6.7138671875 49.755859375, 9.7021484375 42.5927734375, 15.3271484375 53.798828125) closed? false
Is LINESTRING (3.1982421875 43.1640625, 6.7138671875 49.755859375, 9.7021484375 42.5927734375, 15.3271484375 53.798828125, 3.1982421875 43.1640625) closed? true
Determine if a LineString is a Ring or not
LineString lineString1 = new LineString(
[-122.391428, 47.563300],
[-122.391836, 47.562793],
[-122.391010, 47.562417],
[-122.390516, 47.563126]
)
boolean isRing1 = lineString1.ring
println "Is ${lineString1.wkt} a ring? ${isRing1}"
LineString lineString2 = new LineString(
[-122.391428, 47.563300],
[-122.391836, 47.562793],
[-122.391010, 47.562417],
[-122.390516, 47.563126],
[-122.391428, 47.563300]
)
boolean isRing2 = lineString2.ring
println "Is ${lineString2.wkt} a ring? ${isRing2}"
Is LINESTRING (-122.391428 47.5633, -122.391836 47.562793, -122.39101 47.562417, -122.390516 47.563126) a ring? false
Is LINESTRING (-122.391428 47.5633, -122.391836 47.562793, -122.39101 47.562417, -122.390516 47.563126, -122.391428 47.5633) a ring? true
Close an open LineString to create a LinearRing
LineString lineString = new LineString(
[-122.391428, 47.563300],
[-122.391836, 47.562793],
[-122.391010, 47.562417],
[-122.390516, 47.563126]
)
LinearRing linearRing = lineString.close()Open LineString
Closed LinearRing
Add a LineString to another LineString to create a MultiLineString
LineString lineString1 = new LineString([
[-122.39142894744873, 47.5812734461813],
[-122.38237380981445, 47.58121554959838]
])
LineString lineString2 = new LineString([
[-122.38640785217285, 47.58552866972616],
[-122.38670825958253, 47.57837853860192]
])
MultiLineString multiLineString = lineString1 + lineString2
Add a Point to a LineString
LineString lineString = new LineString([
[-122.39142894744873, 47.5812734461813],
[-122.38237380981445, 47.58121554959838]
])
Point point = new Point(-122.38640785217285, 47.58552866972616)
LineString lineStringWithPoint = lineString + point
Add a Point to a LineString at a specific index
LineString lineString = new LineString([
[-122.39142894744873, 47.5812734461813],
[-122.38237380981445, 47.58121554959838]
])
Point point = new Point(-122.38640785217285, 47.58552866972616)
LineString lineStringWithPoint = lineString.addPoint(1, point)
Set a Point on a LineString at a specific index
LineString lineString = new LineString([
[-122.39142894744873, 47.5812734461813],
[-122.38237380981445, 47.58121554959838]
])
Point point = new Point(-122.38640785217285, 47.58552866972616)
LineString newLineString = lineString.setPoint(1, point)
Remove a Point on a LineString at a specific index
LineString lineString = new LineString([
[-122.39142894744873, 47.5812734461813],
[-122.38237380981445, 47.58121554959838],
[-122.38640785217285, 47.58552866972616]
])
LineString newLineString = lineString.removePoint(2)
Remove a Point from the end of a LineString.
LineString lineString1 = new LineString([
[-122.39423990249632, 47.57926150237904],
[-122.3918581008911, 47.58121554959838],
[-122.38657951354979, 47.58121554959838],
[-122.38638639450075, 47.58535499390333],
[-122.38374710083008, 47.58535499390333]
])
LineString lineString2 = -lineString1
LineString lineString3 = -lineString2
Interpolate Points on a LineString
LineString lineString = new LineString([
[-122.39423990249632, 47.57926150237904],
[-122.3918581008911, 47.58121554959838],
[-122.38657951354979, 47.58121554959838],
[-122.38638639450075, 47.58535499390333],
[-122.38374710083008, 47.58535499390333]
])
Point startPoint = lineString.interpolatePoint(0.0)
Point midPoint = lineString.interpolatePoint(0.5)
Point endPoint = lineString.interpolatePoint(1.0)
Locate the position of Points on a LineString
LineString lineString = new LineString([
[-122.39423990249632, 47.57926150237904],
[-122.3918581008911, 47.58121554959838],
[-122.38657951354979, 47.58121554959838],
[-122.38638639450075, 47.58535499390333],
[-122.38374710083008, 47.58535499390333]
])
Point point1 = new Point(-122.39423990249632, 47.57926150237904)
Double position1 = lineString.locatePoint(point1)
println "Position of ${point1} is ${position1}"
Point point2 = new Point(-122.38736758304911, 47.58121554959838)
Double position2 = lineString.locatePoint(point2)
println "Position of ${point2} is ${position2}"
Point point3 = new Point(-122.38374710083008, 47.58535499390333)
Double position3 = lineString.locatePoint(point3)
println "Position of ${point3} is ${position3}"
Position of POINT (-122.39423990249632 47.57926150237904) is 0.0 Position of POINT (-122.38736758304911 47.58121554959838) is 0.5000000000004425 Position of POINT (-122.38374710083008 47.58535499390333) is 1.0
Place Points on a LineString
LineString lineString = new LineString ([
[-122.37155914306639, 47.57166173655188],
[-122.32160568237306, 47.5714301073211]
])
Point point1 = new Point(-122.358341217041, 47.57432539907205)
Point pointOnLine1 = lineString.placePoint(point1)
Point point2 = new Point(-122.33860015869139, 47.56830301243495)
Point pointOnLine2 = lineString.placePoint(point2)Points near LineString
Point on LineString
Extract part of a LineString
LineString lineString = new LineString([
[-122.39423990249632, 47.57926150237904],
[-122.3918581008911, 47.58121554959838],
[-122.38657951354979, 47.58121554959838],
[-122.38638639450075, 47.58535499390333],
[-122.38374710083008, 47.58535499390333]
])
LineString subLine = lineString.subLine(0.33, 0.66)
Create Points along a LineString
LineString lineString = new LineString([
[-122.39423990249632, 47.57926150237904],
[-122.3918581008911, 47.58121554959838],
[-122.38657951354979, 47.58121554959838],
[-122.38638639450075, 47.58535499390333],
[-122.38374710083008, 47.58535499390333]
])
MultiPoint multiPoint = lineString.createPointsAlong(0.001)
Polygons
Get a Polygon’s exterior LinearRing
Polygon polygon = new Polygon(
// Exterior Ring
new LinearRing(
[-122.39138603210449, 47.58659965790016],
[-122.41250038146973, 47.57681522195182],
[-122.40305900573729, 47.56523364515569],
[-122.38117218017578, 47.56621817878201],
[-122.3712158203125, 47.57235661809739],
[-122.37602233886717, 47.584747123985615],
[-122.39138603210449, 47.58659965790016]
),
// Holes
[
new LinearRing(
[-122.39859580993652, 47.578957532923376],
[-122.40468978881836, 47.57548347095205],
[-122.39593505859376, 47.570271945800094],
[-122.3920726776123, 47.57606249728773],
[-122.39859580993652, 47.578957532923376]
),
new LinearRing(
[-122.3836612701416, 47.58156292813543],
[-122.38829612731934, 47.57114056934196],
[-122.37456321716309, 47.57420959047542],
[-122.37868309020995, 47.58023129789275],
[-122.3836612701416, 47.58156292813543]
)
]
)
LinearRing exteriorRing = polygon.getExteriorRing()
Get a Polygon’s interior LinearRings
Polygon polygon = new Polygon(
// Exterior Ring
new LinearRing(
[-122.39138603210449, 47.58659965790016],
[-122.41250038146973, 47.57681522195182],
[-122.40305900573729, 47.56523364515569],
[-122.38117218017578, 47.56621817878201],
[-122.3712158203125, 47.57235661809739],
[-122.37602233886717, 47.584747123985615],
[-122.39138603210449, 47.58659965790016]
),
// Holes
[
new LinearRing(
[-122.39859580993652, 47.578957532923376],
[-122.40468978881836, 47.57548347095205],
[-122.39593505859376, 47.570271945800094],
[-122.3920726776123, 47.57606249728773],
[-122.39859580993652, 47.578957532923376]
),
new LinearRing(
[-122.3836612701416, 47.58156292813543],
[-122.38829612731934, 47.57114056934196],
[-122.37456321716309, 47.57420959047542],
[-122.37868309020995, 47.58023129789275],
[-122.3836612701416, 47.58156292813543]
)
]
)
println "# Interior Rings = ${polygon.numInteriorRing}"
(0..<polygon.numInteriorRing).each { int i ->
println " ${polygon.getInteriorRingN(i)}"
}
println "Interior Rings"
polygon.interiorRings.each { LinearRing ring ->
println " ${ring}"
}# Interior Rings = 2 LINEARRING (-122.39859580993652 47.578957532923376, -122.40468978881836 47.57548347095205, -122.39593505859376 47.570271945800094, -122.3920726776123 47.57606249728773, -122.39859580993652 47.578957532923376) LINEARRING (-122.3836612701416 47.58156292813543, -122.38829612731934 47.57114056934196, -122.37456321716309 47.57420959047542, -122.37868309020995 47.58023129789275, -122.3836612701416 47.58156292813543) Interior Rings LINEARRING (-122.39859580993652 47.578957532923376, -122.40468978881836 47.57548347095205, -122.39593505859376 47.570271945800094, -122.3920726776123 47.57606249728773, -122.39859580993652 47.578957532923376) LINEARRING (-122.3836612701416 47.58156292813543, -122.38829612731934 47.57114056934196, -122.37456321716309 47.57420959047542, -122.37868309020995 47.58023129789275, -122.3836612701416 47.58156292813543)
Add a Polygon to another Polygon to create a MultiPolygon
Polygon polygon1 = new Polygon ([[
[-122.2723388671875, 47.818687628247105],
[-122.37945556640624, 47.66168780332917],
[-121.95373535156249, 47.67093619422418],
[-122.2723388671875, 47.818687628247105]
]])
Polygon polygon2 = new Polygon ([[
[-122.76672363281249, 47.42437092240516],
[-122.76672363281249, 47.59505101193038],
[-122.52227783203125, 47.59505101193038],
[-122.52227783203125, 47.42437092240516],
[-122.76672363281249, 47.42437092240516]
]])
MultiPolygon multiPolygon = polygon1 + polygon2
Split a Polygon with a LineString
Polygon polygon = new Polygon(
new LinearRing(
[-122.39138603210449, 47.58659965790016],
[-122.41250038146973, 47.57681522195182],
[-122.40305900573729, 47.56523364515569],
[-122.38117218017578, 47.56621817878201],
[-122.3712158203125, 47.57235661809739],
[-122.37602233886717, 47.584747123985615],
[-122.39138603210449, 47.58659965790016]
)
)
LineString lineString = new LineString([
[-122.3924160003662, 47.56395951534652],
[-122.38649368286131, 47.58729434121508]
])
MultiPolygon multiPolygon = polygon.split(lineString)
MultiLineStrings
Add a LineString to a MultiLineString to get a new MultiLineString
MultiLineString multiLineString = new MultiLineString([
new LineString (
[-122.3822021484375, 47.57837853860192],
[-122.32452392578125, 47.48380086737799]
),
new LineString (
[-122.32452392578125, 47.48380086737799],
[-122.29705810546874, 47.303447043862626]
)
])
LineString lineString = new LineString (
[-122.29705810546874, 47.303447043862626],
[-122.42889404296875, 47.23262467463881]
)
MultiLineString newMultiLineString = multiLineString + lineString
Merge the LineStrings in a MultiLineString
MultiLineString multiLineString = new MultiLineString([
new LineString (
[-122.3822021484375, 47.57837853860192],
[-122.32452392578125, 47.48380086737799]
),
new LineString (
[-122.32452392578125, 47.48380086737799],
[-122.29705810546874, 47.303447043862626]
),
new LineString (
[-122.29705810546874, 47.303447043862626],
[-122.42889404296875, 47.23262467463881]
)
])
MultiLineString mergedMultiLineString = multiLineString.merge()
println "Original MultiLineString = ${multiLineString}"
println "Merged MultiLineString = ${mergedMultiLineString}"Original MultiLineString = MULTILINESTRING ((-122.3822021484375 47.57837853860192, -122.32452392578125 47.48380086737799), (-122.32452392578125 47.48380086737799, -122.29705810546874 47.303447043862626), (-122.29705810546874 47.303447043862626, -122.42889404296875 47.23262467463881)) Merged MultiLineString = MULTILINESTRING ((-122.3822021484375 47.57837853860192, -122.32452392578125 47.48380086737799, -122.29705810546874 47.303447043862626, -122.42889404296875 47.23262467463881))
Create Points along a MultiLineString
MultiLineString lines = new MultiLineString(
new LineString ([-5.70068359375, 45.1416015625], [2.47314453125, 53.9306640625]),
new LineString ([-1.21826171875, 53.9306640625], [8.88916015625, 46.1962890625]),
new LineString ([0.71533203125, 42.63671875], [7.13134765625, 50.37109375]),
new LineString ([-5.83251953125, 46.943359375], [4.45068359375, 42.98828125])
)
MultiPoint points = lines.createPointsAlong(1)
MultiPolygons
Add a Polygon to a MultiPolygon to get a new MultiPolygon
MultiPolygon multiPolygon = new MultiPolygon (
new Polygon([[
[-122.2723388671875, 47.818687628247105],
[-122.37945556640624, 47.66168780332917],
[-121.95373535156249, 47.67093619422418],
[-122.2723388671875, 47.818687628247105]
]]),
new Polygon ([[
[-122.76672363281249, 47.42437092240516],
[-122.76672363281249, 47.59505101193038],
[-122.52227783203125, 47.59505101193038],
[-122.52227783203125, 47.42437092240516],
[-122.76672363281249, 47.42437092240516]
]])
)
Polygon polygon = new Polygon ([[
[-122.32177734375, 47.54501765940571],
[-122.27645874023438, 47.36673410912714],
[-122.03887939453125, 47.44480754169437],
[-122.15972900390624, 47.55150616084034],
[-122.32177734375, 47.54501765940571]
]])
MultiPolygon newMultiPolygon = multiPolygon + polygon
Split a MultiPolygon with a LineString
MultiPolygon multiPolygon = new MultiPolygon (
new Polygon([[
[-122.2723388671875, 47.818687628247105],
[-122.37945556640624, 47.66168780332917],
[-121.95373535156249, 47.67093619422418],
[-122.2723388671875, 47.818687628247105]
]]),
new Polygon ([[
[-122.76672363281249, 47.42437092240516],
[-122.76672363281249, 47.59505101193038],
[-122.52227783203125, 47.59505101193038],
[-122.52227783203125, 47.42437092240516],
[-122.76672363281249, 47.42437092240516]
]]),
new Polygon ([[
[-122.32177734375, 47.54501765940571],
[-122.27645874023438, 47.36673410912714],
[-122.03887939453125, 47.44480754169437],
[-122.15972900390624, 47.55150616084034],
[-122.32177734375, 47.54501765940571]
]])
)
LineString lineString = new LineString([
[-122.84362792968749, 47.484728927366504],
[-122.05810546875, 47.50421439972969],
[-122.35748291015625, 47.85832433461554]
])
Geometry splitGeometry = multiPolygon.split(lineString)Before
After
Geometry Collections
Add a Geometry to a Geometry Collection
GeometryCollection geometryCollection = new GeometryCollection([
new Point(-122.38654196262358, 47.581211931059826),
new LineString([
[-122.3865446448326, 47.58118841055313],
[-122.38657146692276, 47.58067638459562]
]),
new Polygon(new LinearRing([
[-122.38693356513977, 47.58088445228483],
[-122.38672703504562, 47.58088445228483],
[-122.38672703504562, 47.58096225129535],
[-122.38693356513977, 47.58096225129535],
[-122.38693356513977, 47.58088445228483]
]))
])
GeometryCollection newGeometryCollection = geometryCollection + new Point(-122.38718032836913, 47.58121374032914)Original Geometry Collection
New Geometry Collection
Get a subset of Geometries from a Geometry Collection
GeometryCollection geometryCollection = new GeometryCollection([
new Point(-122.38654196262358, 47.581211931059826),
new LineString([
[-122.3865446448326, 47.58118841055313],
[-122.38657146692276, 47.58067638459562]
]),
new Polygon(new LinearRing([
[-122.38693356513977, 47.58088445228483],
[-122.38672703504562, 47.58088445228483],
[-122.38672703504562, 47.58096225129535],
[-122.38693356513977, 47.58096225129535],
[-122.38693356513977, 47.58088445228483]
]))
])
Polygon slicedGeometryCollection1 = geometryCollection.slice(2)
GeometryCollection slicedGeometryCollection2 = geometryCollection.slice(0,2)
Get a Geometry from a GeometryCollection that is the most type specific as possible.
GeometryCollection geometryCollection1 = new GeometryCollection([
new Point(-122.38654196262358, 47.581211931059826),
new Point(-122.38718032836913, 47.58121374032914),
])
Geometry narrowedGeometry1 = geometryCollection1.narrow()
println "Narrow Geometry #1 = ${narrowedGeometry1.wkt}"
Narrow Geometry #1 = MULTIPOINT ((-122.38654196262358 47.581211931059826), (-122.38718032836913 47.58121374032914))
GeometryCollection geometryCollection2 = new GeometryCollection([
new Point(-122.38654196262358, 47.581211931059826),
new Polygon(new LinearRing([
[-122.38693356513977, 47.58088445228483],
[-122.38672703504562, 47.58088445228483],
[-122.38672703504562, 47.58096225129535],
[-122.38693356513977, 47.58096225129535],
[-122.38693356513977, 47.58088445228483]
]))
])
Geometry narrowedGeometry2 = geometryCollection2.narrow()
println "Narrow Geometry #2 = ${narrowedGeometry2.wkt}"
Narrow Geometry #2 = GEOMETRYCOLLECTION (POINT (-122.38654196262358 47.581211931059826), POLYGON ((-122.38693356513977 47.58088445228483, -122.38672703504562 47.58088445228483, -122.38672703504562 47.58096225129535, -122.38693356513977 47.58096225129535, -122.38693356513977 47.58088445228483)))
Circular Strings
Get Curved WKT from a Circular Strings
CircularString circularString = new CircularString([
[-122.464599609375, 47.247542522268006],
[-122.03613281249999, 47.37789454155521],
[-122.37670898437499, 47.58393661978134]
])
println "WKT = ${circularString.wkt}"
println "Curnved WKT = ${circularString.curvedWkt}"
WKT = LINESTRING (-122.464599609375 47.247542522268006, -122.4550237920096 47.23410579860605, -122.4348780833765 47.21113402059009, -122.41190630536055 47.19098831195699, -122.38650151145254 47.17401337136692, -122.3590983847198 47.16049964475972, -122.33016580025833 47.15067835574435, -122.30019880260986 47.144717549298825, -122.26971013541258 47.1427192164741, -122.2392214682153 47.144717549298825, -122.20925447056683 47.15067835574435, -122.18032188610536 47.16049964475972, -122.15291875937262 47.17401337136692, -122.12751396546462 47.19098831195699, -122.10454218744866 47.21113402059009, -122.08439647881556 47.23410579860605, -122.06742153822549 47.259510592514054, -122.05390781161829 47.28691371924678, -122.04408652260291 47.31584630370827, -122.0381257161574 47.34581330135674, -122.03612738333267 47.37630196855401, -122.03613281249999 47.37789454155521, -122.0381257161574 47.40679063575128, -122.04408652260291 47.43675763339975, -122.05390781161829 47.46569021786124, -122.06742153822549 47.493093344593966, -122.08439647881556 47.51849813850197, -122.10454218744866 47.54146991651793, -122.12751396546462 47.56161562515103, -122.15291875937262 47.5785905657411, -122.18032188610536 47.5921042923483, -122.20925447056683 47.60192558136367, -122.2392214682153 47.607886387809195, -122.26971013541258 47.60988472063392, -122.30019880260986 47.607886387809195, -122.33016580025833 47.60192558136367, -122.3590983847198 47.5921042923483, -122.37670898437499 47.58393661978134) Curnved WKT = CIRCULARSTRING (-122.464599609375 47.247542522268006, -122.03613281249999 47.37789454155521, -122.37670898437499 47.58393661978134)
Get control points from a Circular Strings
CircularString circularString = new CircularString([
[-122.464599609375, 47.247542522268006],
[-122.03613281249999, 47.37789454155521],
[-122.37670898437499, 47.58393661978134]
])
List<Point> points = circularString.controlPoints
points.each { Point point ->
println point
}
POINT (-122.464599609375 47.247542522268006) POINT (-122.03613281249999 47.37789454155521) POINT (-122.37670898437499 47.58393661978134)
Convert a Circural Strings to a Linear Geometry
CircularString circularString = new CircularString([
[-122.464599609375, 47.247542522268006],
[-122.03613281249999, 47.37789454155521],
[-122.37670898437499, 47.58393661978134]
])
Geometry linear = circularString.linear
println linear.wkt
LINESTRING (-122.464599609375 47.247542522268006, -122.4550237920096 47.23410579860605, -122.4348780833765 47.21113402059009, -122.41190630536055 47.19098831195699, -122.38650151145254 47.17401337136692, -122.3590983847198 47.16049964475972, -122.33016580025833 47.15067835574435, -122.30019880260986 47.144717549298825, -122.26971013541258 47.1427192164741, -122.2392214682153 47.144717549298825, -122.20925447056683 47.15067835574435, -122.18032188610536 47.16049964475972, -122.15291875937262 47.17401337136692, -122.12751396546462 47.19098831195699, -122.10454218744866 47.21113402059009, -122.08439647881556 47.23410579860605, -122.06742153822549 47.259510592514054, -122.05390781161829 47.28691371924678, -122.04408652260291 47.31584630370827, -122.0381257161574 47.34581330135674, -122.03612738333267 47.37630196855401, -122.03613281249999 47.37789454155521, -122.0381257161574 47.40679063575128, -122.04408652260291 47.43675763339975, -122.05390781161829 47.46569021786124, -122.06742153822549 47.493093344593966, -122.08439647881556 47.51849813850197, -122.10454218744866 47.54146991651793, -122.12751396546462 47.56161562515103, -122.15291875937262 47.5785905657411, -122.18032188610536 47.5921042923483, -122.20925447056683 47.60192558136367, -122.2392214682153 47.607886387809195, -122.26971013541258 47.60988472063392, -122.30019880260986 47.607886387809195, -122.33016580025833 47.60192558136367, -122.3590983847198 47.5921042923483, -122.37670898437499 47.58393661978134)
Circular Rings
Get Curved WKT from a Circular Ring
CircularRing circularRing = new CircularRing([
[-118.47656249999999, 41.508577297439324],
[-109.6875, 57.51582286553883],
[-93.8671875, 42.032974332441405],
[-62.57812500000001, 30.14512718337613],
[-92.10937499999999, 7.36246686553575],
[ -127.265625, 14.604847155053898],
[-118.47656249999999, 41.508577297439324]
])
println "WKT = ${circularRing.wkt}"
println "Curnved WKT = ${circularRing.curvedWkt}"
WKT = LINEARRING (-118.47656249999999 41.508577297439324, -118.58869123015452 41.901774579059115, -118.91479847512254 43.54122641035517, -119.02412442253558 45.209218040904574, -118.91479847512252 46.877209671453976, -118.58869123015451 48.516661502750026, -118.05138247300694 50.09952205941734, -117.31206570548474 51.59870815847947, -116.38339084245754 52.98856831012856, -115.28124776830906 54.245321621827856, -114.02449445660976 55.347464695976335, -112.63463430496067 56.27613955900354, -111.13544820589854 57.01545632652574, -109.6875 57.51582286553883, -109.55258764923123 57.552765083673314, -107.91313581793517 57.87887232864133, -106.24514418738576 57.98819827605437, -104.57715255683635 57.87887232864133, -102.9377007255403 57.552765083673314, -101.35484016887298 57.01545632652574, -99.85565406981085 56.27613955900354, -98.46579391816176 55.347464695976335, -97.20904060646247 54.245321621827856, -96.10689753231398 52.98856831012856, -95.17822266928678 51.59870815847947, -94.43890590176458 50.09952205941733, -93.901597144617 48.51666150275002, -93.575489899649 46.87720967145396, -93.46616395223595 45.20921804090456, -93.575489899649 43.54122641035516, -93.8671875 42.032974332441405, -92.52944589377746 42.87620255408929, -90.13998424943787 44.0545546346726, -87.61715897053445 44.91093841996455, -85.00413629704853 45.43070094596436, -82.34562577139025 45.60494893174677, -79.68711524573196 45.43070094596437, -77.07409257224604 44.910938419964566, -74.55126729334262 44.05455463467261, -72.16180564900301 42.876202554089296, -69.94659199044581 41.396044109014326, -67.9435292375422 39.639405220820365, -66.18689034934823 37.63634246791675, -64.70673190427325 35.42112880935955, -63.528379823689946 33.03166716501995, -62.67199603839799 30.50884188611652, -62.57812500000001 30.14512718337613, -62.15223351239818 27.895819212630613, -61.97798552661578 25.237308686972327, -62.15223351239818 22.578798161314037, -62.671996038397985 19.965775487828132, -63.52837982368993 17.442950208924703, -64.70673190427325 15.0534885645851, -66.18689034934822 12.838274906027902, -67.94352923754218 10.835212153124278, -69.9465919904458 9.078573264930323, -72.16180564900299 7.598414819855346, -74.55126729334259 6.42006273927203, -77.07409257224602 5.563678953980077, -79.68711524573193 5.0439164279802675, -82.34562577139022 4.869668442197863, -85.00413629704852 5.043916427980264, -87.61715897053442 5.5636789539800695, -90.13998424943784 6.420062739272023, -92.10937499999999 7.36246686553575, -94.00832592648507 5.722586433241059, -96.3693387982898 4.1450080684486466, -98.91606817456314 2.88910012519991, -101.60493880959022 1.9763515366073037, -104.38994338130999 1.4223796840833636, -107.22342968935115 1.2366631796147907, -110.05691599739232 1.4223796840833813, -112.84192056911208 1.9763515366073356, -115.53079120413916 2.8891001251999597, -118.07752058041248 4.1450080684487105, -120.43853345221721 5.722586433241133, -122.57343223472037 7.594842416368293, -124.4456882178475 9.729741198871439, -126.02326658263992 12.09075407067618, -127.265625 14.604847155053898, -127.27917452588866 14.637483446949503, -128.19192311448128 17.326354081976593, -128.7458949670052 20.111358653696357, -128.9316114714738 22.944844961737523, -128.7458949670052 25.77833126977869, -128.19192311448126 28.56333584149845, -127.27917452588864 31.252206476525537, -126.02326658263989 33.798935852798856, -124.44568821784746 36.159948724603595, -122.57343223472031 38.29484750710673, -120.43853345221717 40.16710349023388, -118.47656249999999 41.508577297439324) Curnved WKT = CIRCULARSTRING (-118.47656249999999 41.508577297439324, -109.6875 57.51582286553883, -93.8671875 42.032974332441405, -62.57812500000001 30.14512718337613, -92.10937499999999 7.36246686553575, -127.265625 14.604847155053898, -118.47656249999999 41.508577297439324)
Get control points from a Circular Ring
CircularRing circularRing = new CircularRing([
[-118.47656249999999, 41.508577297439324],
[-109.6875, 57.51582286553883],
[-93.8671875, 42.032974332441405],
[-62.57812500000001, 30.14512718337613],
[-92.10937499999999, 7.36246686553575],
[ -127.265625, 14.604847155053898],
[-118.47656249999999, 41.508577297439324]
])
List<Point> points = circularRing.controlPoints
points.each { Point point ->
println point
}
POINT (-118.47656249999999 41.508577297439324) POINT (-109.6875 57.51582286553883) POINT (-93.8671875 42.032974332441405) POINT (-62.57812500000001 30.14512718337613) POINT (-92.10937499999999 7.36246686553575) POINT (-127.265625 14.604847155053898) POINT (-118.47656249999999 41.508577297439324)
Convert a Circural Ring to a Linear Geometry
CircularRing circularRing = new CircularRing([
[-118.47656249999999, 41.508577297439324],
[-109.6875, 57.51582286553883],
[-93.8671875, 42.032974332441405],
[-62.57812500000001, 30.14512718337613],
[-92.10937499999999, 7.36246686553575],
[ -127.265625, 14.604847155053898],
[-118.47656249999999, 41.508577297439324]
])
Geometry linear = circularRing.linear
println linear.wkt
LINEARRING (-118.47656249999999 41.508577297439324, -118.58869123015452 41.901774579059115, -118.91479847512254 43.54122641035517, -119.02412442253558 45.209218040904574, -118.91479847512252 46.877209671453976, -118.58869123015451 48.516661502750026, -118.05138247300694 50.09952205941734, -117.31206570548474 51.59870815847947, -116.38339084245754 52.98856831012856, -115.28124776830906 54.245321621827856, -114.02449445660976 55.347464695976335, -112.63463430496067 56.27613955900354, -111.13544820589854 57.01545632652574, -109.6875 57.51582286553883, -109.55258764923123 57.552765083673314, -107.91313581793517 57.87887232864133, -106.24514418738576 57.98819827605437, -104.57715255683635 57.87887232864133, -102.9377007255403 57.552765083673314, -101.35484016887298 57.01545632652574, -99.85565406981085 56.27613955900354, -98.46579391816176 55.347464695976335, -97.20904060646247 54.245321621827856, -96.10689753231398 52.98856831012856, -95.17822266928678 51.59870815847947, -94.43890590176458 50.09952205941733, -93.901597144617 48.51666150275002, -93.575489899649 46.87720967145396, -93.46616395223595 45.20921804090456, -93.575489899649 43.54122641035516, -93.8671875 42.032974332441405, -92.52944589377746 42.87620255408929, -90.13998424943787 44.0545546346726, -87.61715897053445 44.91093841996455, -85.00413629704853 45.43070094596436, -82.34562577139025 45.60494893174677, -79.68711524573196 45.43070094596437, -77.07409257224604 44.910938419964566, -74.55126729334262 44.05455463467261, -72.16180564900301 42.876202554089296, -69.94659199044581 41.396044109014326, -67.9435292375422 39.639405220820365, -66.18689034934823 37.63634246791675, -64.70673190427325 35.42112880935955, -63.528379823689946 33.03166716501995, -62.67199603839799 30.50884188611652, -62.57812500000001 30.14512718337613, -62.15223351239818 27.895819212630613, -61.97798552661578 25.237308686972327, -62.15223351239818 22.578798161314037, -62.671996038397985 19.965775487828132, -63.52837982368993 17.442950208924703, -64.70673190427325 15.0534885645851, -66.18689034934822 12.838274906027902, -67.94352923754218 10.835212153124278, -69.9465919904458 9.078573264930323, -72.16180564900299 7.598414819855346, -74.55126729334259 6.42006273927203, -77.07409257224602 5.563678953980077, -79.68711524573193 5.0439164279802675, -82.34562577139022 4.869668442197863, -85.00413629704852 5.043916427980264, -87.61715897053442 5.5636789539800695, -90.13998424943784 6.420062739272023, -92.10937499999999 7.36246686553575, -94.00832592648507 5.722586433241059, -96.3693387982898 4.1450080684486466, -98.91606817456314 2.88910012519991, -101.60493880959022 1.9763515366073037, -104.38994338130999 1.4223796840833636, -107.22342968935115 1.2366631796147907, -110.05691599739232 1.4223796840833813, -112.84192056911208 1.9763515366073356, -115.53079120413916 2.8891001251999597, -118.07752058041248 4.1450080684487105, -120.43853345221721 5.722586433241133, -122.57343223472037 7.594842416368293, -124.4456882178475 9.729741198871439, -126.02326658263992 12.09075407067618, -127.265625 14.604847155053898, -127.27917452588866 14.637483446949503, -128.19192311448128 17.326354081976593, -128.7458949670052 20.111358653696357, -128.9316114714738 22.944844961737523, -128.7458949670052 25.77833126977869, -128.19192311448126 28.56333584149845, -127.27917452588864 31.252206476525537, -126.02326658263989 33.798935852798856, -124.44568821784746 36.159948724603595, -122.57343223472031 38.29484750710673, -120.43853345221717 40.16710349023388, -118.47656249999999 41.508577297439324)
Compound Curves
Get Curved WKT from a Compound Curves
CompoundCurve compoundCurve = new CompoundCurve([
new CircularString([
[27.0703125, 23.885837699862005],
[5.9765625, 40.17887331434696],
[22.5, 47.98992166741417],
]),
new LineString([
[22.5, 47.98992166741417],
[71.71875, 49.15296965617039],
]),
new CircularString([
[71.71875, 49.15296965617039],
[81.5625, 39.36827914916011],
[69.9609375, 24.5271348225978]
])
])
println "WKT = ${compoundCurve.wkt}"
println "Curnved WKT = ${compoundCurve.curvedWkt}"
WKT = LINESTRING (27.0703125 23.885837699862005, 27.022331449414295 23.8488525605847, 25.524767337284196 22.84821221194479, 23.909405319245263 22.051603821364203, 22.203884687289108 21.472657579267334, 20.43738737228815 21.12127941637069, 18.64013863306764 21.00348151046186, 16.842889893847133 21.1212794163707, 15.076392578846175 21.472657579267356, 13.370871946890022 22.051603821364232, 11.755509928851094 22.848212211944833, 10.257945816720998 23.848852560584746, 8.903803347661494 25.036403633488835, 7.716252274757412 26.390546102548342, 6.715611926117504 27.88811021467844, 5.919003535536911 29.50347223271737, 5.340057293440038 31.20899286467353, 4.988679130543391 32.97549017967449, 4.8708812246345605 34.772738918894994, 4.988679130543396 36.5699876581155, 5.340057293440047 38.336484973116455, 5.9190035355369215 40.04200560507262, 5.9765625 40.17887331434696, 6.715611926117516 41.65736762311154, 7.71625227475743 43.15493173524164, 8.903803347661514 44.50907420430114, 10.257945816721021 45.69662527720523, 11.755509928851117 46.69726562584515, 13.37087194689005 47.49387401642574, 15.076392578846209 48.07282025852261, 16.84288989384717 48.42419842141926, 18.64013863306768 48.5419963273281, 20.437387372288192 48.42419842141926, 22.20388468728915 48.07282025852261, 22.5 47.98992166741417, 71.71875 49.15296965617039, 72.58658076138724 48.953451060440116, 74.12646468490568 48.43073090444654, 75.58494601643167 47.71148750685245, 76.93706973601537 46.80802732160263, 78.15970063193521 45.735808802953194, 79.23191915058464 44.513177907033366, 80.13537933583446 43.16105418744966, 80.85462273342854 41.70257285592367, 81.37734288942212 40.162688932405224, 81.5625 39.36827914916011, 81.69459591702075 38.567750257762206, 81.80095352896302 36.9450466749183, 81.69459591702075 35.3223430920744, 81.37734288942212 33.72740441743138, 80.85462273342854 32.187520493912935, 80.13537933583446 30.729039162386947, 79.23191915058464 29.376915442803238, 78.15970063193521 28.15428454688341, 76.93706973601537 27.082066028233974, 75.58494601643167 26.178605842984155, 74.12646468490568 25.459362445390067, 72.58658076138724 24.936642289396488, 70.99164208674422 24.61938926179787, 69.9609375 24.5271348225978) Curnved WKT = COMPOUNDCURVE (CIRCULARSTRING (27.0703125 23.885837699862005, 5.9765625 40.17887331434696, 22.5 47.98992166741417), (22.5 47.98992166741417, 71.71875 49.15296965617039), CIRCULARSTRING (71.71875 49.15296965617039, 81.5625 39.36827914916011, 69.9609375 24.5271348225978))
Get component LineStrings from a Compound Curves
CompoundCurve compoundCurve = new CompoundCurve([
new CircularString([
[27.0703125, 23.885837699862005],
[5.9765625, 40.17887331434696],
[22.5, 47.98992166741417],
]),
new LineString([
[22.5, 47.98992166741417],
[71.71875, 49.15296965617039],
]),
new CircularString([
[71.71875, 49.15296965617039],
[81.5625, 39.36827914916011],
[69.9609375, 24.5271348225978]
])
])
List<LineString> lineStrings = compoundCurve.components
lineStrings.each { LineString lineString ->
println lineString
}
LINESTRING (27.0703125 23.885837699862005, 27.022331449414295 23.8488525605847, 25.524767337284196 22.84821221194479, 23.909405319245263 22.051603821364203, 22.203884687289108 21.472657579267334, 20.43738737228815 21.12127941637069, 18.64013863306764 21.00348151046186, 16.842889893847133 21.1212794163707, 15.076392578846175 21.472657579267356, 13.370871946890022 22.051603821364232, 11.755509928851094 22.848212211944833, 10.257945816720998 23.848852560584746, 8.903803347661494 25.036403633488835, 7.716252274757412 26.390546102548342, 6.715611926117504 27.88811021467844, 5.919003535536911 29.50347223271737, 5.340057293440038 31.20899286467353, 4.988679130543391 32.97549017967449, 4.8708812246345605 34.772738918894994, 4.988679130543396 36.5699876581155, 5.340057293440047 38.336484973116455, 5.9190035355369215 40.04200560507262, 5.9765625 40.17887331434696, 6.715611926117516 41.65736762311154, 7.71625227475743 43.15493173524164, 8.903803347661514 44.50907420430114, 10.257945816721021 45.69662527720523, 11.755509928851117 46.69726562584515, 13.37087194689005 47.49387401642574, 15.076392578846209 48.07282025852261, 16.84288989384717 48.42419842141926, 18.64013863306768 48.5419963273281, 20.437387372288192 48.42419842141926, 22.20388468728915 48.07282025852261, 22.5 47.98992166741417) LINESTRING (22.5 47.98992166741417, 71.71875 49.15296965617039) LINESTRING (71.71875 49.15296965617039, 72.58658076138724 48.953451060440116, 74.12646468490568 48.43073090444654, 75.58494601643167 47.71148750685245, 76.93706973601537 46.80802732160263, 78.15970063193521 45.735808802953194, 79.23191915058464 44.513177907033366, 80.13537933583446 43.16105418744966, 80.85462273342854 41.70257285592367, 81.37734288942212 40.162688932405224, 81.5625 39.36827914916011, 81.69459591702075 38.567750257762206, 81.80095352896302 36.9450466749183, 81.69459591702075 35.3223430920744, 81.37734288942212 33.72740441743138, 80.85462273342854 32.187520493912935, 80.13537933583446 30.729039162386947, 79.23191915058464 29.376915442803238, 78.15970063193521 28.15428454688341, 76.93706973601537 27.082066028233974, 75.58494601643167 26.178605842984155, 74.12646468490568 25.459362445390067, 72.58658076138724 24.936642289396488, 70.99164208674422 24.61938926179787, 69.9609375 24.5271348225978)
Convert a Compound Curves to a Linear Geometry
CompoundCurve compoundCurve = new CompoundCurve([
new CircularString([
[27.0703125, 23.885837699862005],
[5.9765625, 40.17887331434696],
[22.5, 47.98992166741417],
]),
new LineString([
[22.5, 47.98992166741417],
[71.71875, 49.15296965617039],
]),
new CircularString([
[71.71875, 49.15296965617039],
[81.5625, 39.36827914916011],
[69.9609375, 24.5271348225978]
])
])
Geometry linear = compoundCurve.linear
println linear.wkt
LINESTRING (27.0703125 23.885837699862005, 27.022331449414295 23.8488525605847, 25.524767337284196 22.84821221194479, 23.909405319245263 22.051603821364203, 22.203884687289108 21.472657579267334, 20.43738737228815 21.12127941637069, 18.64013863306764 21.00348151046186, 16.842889893847133 21.1212794163707, 15.076392578846175 21.472657579267356, 13.370871946890022 22.051603821364232, 11.755509928851094 22.848212211944833, 10.257945816720998 23.848852560584746, 8.903803347661494 25.036403633488835, 7.716252274757412 26.390546102548342, 6.715611926117504 27.88811021467844, 5.919003535536911 29.50347223271737, 5.340057293440038 31.20899286467353, 4.988679130543391 32.97549017967449, 4.8708812246345605 34.772738918894994, 4.988679130543396 36.5699876581155, 5.340057293440047 38.336484973116455, 5.9190035355369215 40.04200560507262, 5.9765625 40.17887331434696, 6.715611926117516 41.65736762311154, 7.71625227475743 43.15493173524164, 8.903803347661514 44.50907420430114, 10.257945816721021 45.69662527720523, 11.755509928851117 46.69726562584515, 13.37087194689005 47.49387401642574, 15.076392578846209 48.07282025852261, 16.84288989384717 48.42419842141926, 18.64013863306768 48.5419963273281, 20.437387372288192 48.42419842141926, 22.20388468728915 48.07282025852261, 22.5 47.98992166741417, 71.71875 49.15296965617039, 72.58658076138724 48.953451060440116, 74.12646468490568 48.43073090444654, 75.58494601643167 47.71148750685245, 76.93706973601537 46.80802732160263, 78.15970063193521 45.735808802953194, 79.23191915058464 44.513177907033366, 80.13537933583446 43.16105418744966, 80.85462273342854 41.70257285592367, 81.37734288942212 40.162688932405224, 81.5625 39.36827914916011, 81.69459591702075 38.567750257762206, 81.80095352896302 36.9450466749183, 81.69459591702075 35.3223430920744, 81.37734288942212 33.72740441743138, 80.85462273342854 32.187520493912935, 80.13537933583446 30.729039162386947, 79.23191915058464 29.376915442803238, 78.15970063193521 28.15428454688341, 76.93706973601537 27.082066028233974, 75.58494601643167 26.178605842984155, 74.12646468490568 25.459362445390067, 72.58658076138724 24.936642289396488, 70.99164208674422 24.61938926179787, 69.9609375 24.5271348225978)
Compound Rings
Get Curved WKT from a Compound Rings
CompoundRing compoundRing = new CompoundRing([
new CircularString([
[27.0703125, 23.885837699862005],
[5.9765625, 40.17887331434696],
[22.5, 47.98992166741417],
]),
new LineString([
[22.5, 47.98992166741417],
[71.71875, 49.15296965617039],
]),
new CircularString([
[71.71875, 49.15296965617039],
[81.5625, 39.36827914916011],
[69.9609375, 24.5271348225978]
]),
new LineString([
[69.9609375, 24.5271348225978],
[27.0703125, 23.885837699862005],
])
])
println "WKT = ${compoundRing.wkt}"
println "Curnved WKT = ${compoundRing.curvedWkt}"
WKT = LINEARRING (27.0703125 23.885837699862005, 27.022331449414295 23.8488525605847, 25.524767337284196 22.84821221194479, 23.909405319245263 22.051603821364203, 22.203884687289108 21.472657579267334, 20.43738737228815 21.12127941637069, 18.64013863306764 21.00348151046186, 16.842889893847133 21.1212794163707, 15.076392578846175 21.472657579267356, 13.370871946890022 22.051603821364232, 11.755509928851094 22.848212211944833, 10.257945816720998 23.848852560584746, 8.903803347661494 25.036403633488835, 7.716252274757412 26.390546102548342, 6.715611926117504 27.88811021467844, 5.919003535536911 29.50347223271737, 5.340057293440038 31.20899286467353, 4.988679130543391 32.97549017967449, 4.8708812246345605 34.772738918894994, 4.988679130543396 36.5699876581155, 5.340057293440047 38.336484973116455, 5.9190035355369215 40.04200560507262, 5.9765625 40.17887331434696, 6.715611926117516 41.65736762311154, 7.71625227475743 43.15493173524164, 8.903803347661514 44.50907420430114, 10.257945816721021 45.69662527720523, 11.755509928851117 46.69726562584515, 13.37087194689005 47.49387401642574, 15.076392578846209 48.07282025852261, 16.84288989384717 48.42419842141926, 18.64013863306768 48.5419963273281, 20.437387372288192 48.42419842141926, 22.20388468728915 48.07282025852261, 22.5 47.98992166741417, 71.71875 49.15296965617039, 72.58658076138724 48.953451060440116, 74.12646468490568 48.43073090444654, 75.58494601643167 47.71148750685245, 76.93706973601537 46.80802732160263, 78.15970063193521 45.735808802953194, 79.23191915058464 44.513177907033366, 80.13537933583446 43.16105418744966, 80.85462273342854 41.70257285592367, 81.37734288942212 40.162688932405224, 81.5625 39.36827914916011, 81.69459591702075 38.567750257762206, 81.80095352896302 36.9450466749183, 81.69459591702075 35.3223430920744, 81.37734288942212 33.72740441743138, 80.85462273342854 32.187520493912935, 80.13537933583446 30.729039162386947, 79.23191915058464 29.376915442803238, 78.15970063193521 28.15428454688341, 76.93706973601537 27.082066028233974, 75.58494601643167 26.178605842984155, 74.12646468490568 25.459362445390067, 72.58658076138724 24.936642289396488, 70.99164208674422 24.61938926179787, 69.9609375 24.5271348225978, 27.0703125 23.885837699862005) Curnved WKT = COMPOUNDCURVE (CIRCULARSTRING (27.0703125 23.885837699862005, 5.9765625 40.17887331434696, 22.5 47.98992166741417), (22.5 47.98992166741417, 71.71875 49.15296965617039), CIRCULARSTRING (71.71875 49.15296965617039, 81.5625 39.36827914916011, 69.9609375 24.5271348225978), (69.9609375 24.5271348225978, 27.0703125 23.885837699862005))
Get component LineStrings from a Compound Rings
CompoundRing compoundRing = new CompoundRing([
new CircularString([
[27.0703125, 23.885837699862005],
[5.9765625, 40.17887331434696],
[22.5, 47.98992166741417],
]),
new LineString([
[22.5, 47.98992166741417],
[71.71875, 49.15296965617039],
]),
new CircularString([
[71.71875, 49.15296965617039],
[81.5625, 39.36827914916011],
[69.9609375, 24.5271348225978]
]),
new LineString([
[69.9609375, 24.5271348225978],
[27.0703125, 23.885837699862005],
])
])
List<LineString> lineStrings = compoundRing.components
lineStrings.each { LineString lineString ->
println lineString
}
LINESTRING (27.0703125 23.885837699862005, 27.022331449414295 23.8488525605847, 25.524767337284196 22.84821221194479, 23.909405319245263 22.051603821364203, 22.203884687289108 21.472657579267334, 20.43738737228815 21.12127941637069, 18.64013863306764 21.00348151046186, 16.842889893847133 21.1212794163707, 15.076392578846175 21.472657579267356, 13.370871946890022 22.051603821364232, 11.755509928851094 22.848212211944833, 10.257945816720998 23.848852560584746, 8.903803347661494 25.036403633488835, 7.716252274757412 26.390546102548342, 6.715611926117504 27.88811021467844, 5.919003535536911 29.50347223271737, 5.340057293440038 31.20899286467353, 4.988679130543391 32.97549017967449, 4.8708812246345605 34.772738918894994, 4.988679130543396 36.5699876581155, 5.340057293440047 38.336484973116455, 5.9190035355369215 40.04200560507262, 5.9765625 40.17887331434696, 6.715611926117516 41.65736762311154, 7.71625227475743 43.15493173524164, 8.903803347661514 44.50907420430114, 10.257945816721021 45.69662527720523, 11.755509928851117 46.69726562584515, 13.37087194689005 47.49387401642574, 15.076392578846209 48.07282025852261, 16.84288989384717 48.42419842141926, 18.64013863306768 48.5419963273281, 20.437387372288192 48.42419842141926, 22.20388468728915 48.07282025852261, 22.5 47.98992166741417) LINESTRING (22.5 47.98992166741417, 71.71875 49.15296965617039) LINESTRING (71.71875 49.15296965617039, 72.58658076138724 48.953451060440116, 74.12646468490568 48.43073090444654, 75.58494601643167 47.71148750685245, 76.93706973601537 46.80802732160263, 78.15970063193521 45.735808802953194, 79.23191915058464 44.513177907033366, 80.13537933583446 43.16105418744966, 80.85462273342854 41.70257285592367, 81.37734288942212 40.162688932405224, 81.5625 39.36827914916011, 81.69459591702075 38.567750257762206, 81.80095352896302 36.9450466749183, 81.69459591702075 35.3223430920744, 81.37734288942212 33.72740441743138, 80.85462273342854 32.187520493912935, 80.13537933583446 30.729039162386947, 79.23191915058464 29.376915442803238, 78.15970063193521 28.15428454688341, 76.93706973601537 27.082066028233974, 75.58494601643167 26.178605842984155, 74.12646468490568 25.459362445390067, 72.58658076138724 24.936642289396488, 70.99164208674422 24.61938926179787, 69.9609375 24.5271348225978) LINESTRING (69.9609375 24.5271348225978, 27.0703125 23.885837699862005)
Convert a Compound Rings to a Linear Geometry
CompoundRing compoundRing = new CompoundRing([
new CircularString([
[27.0703125, 23.885837699862005],
[5.9765625, 40.17887331434696],
[22.5, 47.98992166741417],
]),
new LineString([
[22.5, 47.98992166741417],
[71.71875, 49.15296965617039],
]),
new CircularString([
[71.71875, 49.15296965617039],
[81.5625, 39.36827914916011],
[69.9609375, 24.5271348225978]
]),
new LineString([
[69.9609375, 24.5271348225978],
[27.0703125, 23.885837699862005],
])
])
Geometry linear = compoundRing.linear
println linear.wkt
LINEARRING (27.0703125 23.885837699862005, 27.022331449414295 23.8488525605847, 25.524767337284196 22.84821221194479, 23.909405319245263 22.051603821364203, 22.203884687289108 21.472657579267334, 20.43738737228815 21.12127941637069, 18.64013863306764 21.00348151046186, 16.842889893847133 21.1212794163707, 15.076392578846175 21.472657579267356, 13.370871946890022 22.051603821364232, 11.755509928851094 22.848212211944833, 10.257945816720998 23.848852560584746, 8.903803347661494 25.036403633488835, 7.716252274757412 26.390546102548342, 6.715611926117504 27.88811021467844, 5.919003535536911 29.50347223271737, 5.340057293440038 31.20899286467353, 4.988679130543391 32.97549017967449, 4.8708812246345605 34.772738918894994, 4.988679130543396 36.5699876581155, 5.340057293440047 38.336484973116455, 5.9190035355369215 40.04200560507262, 5.9765625 40.17887331434696, 6.715611926117516 41.65736762311154, 7.71625227475743 43.15493173524164, 8.903803347661514 44.50907420430114, 10.257945816721021 45.69662527720523, 11.755509928851117 46.69726562584515, 13.37087194689005 47.49387401642574, 15.076392578846209 48.07282025852261, 16.84288989384717 48.42419842141926, 18.64013863306768 48.5419963273281, 20.437387372288192 48.42419842141926, 22.20388468728915 48.07282025852261, 22.5 47.98992166741417, 71.71875 49.15296965617039, 72.58658076138724 48.953451060440116, 74.12646468490568 48.43073090444654, 75.58494601643167 47.71148750685245, 76.93706973601537 46.80802732160263, 78.15970063193521 45.735808802953194, 79.23191915058464 44.513177907033366, 80.13537933583446 43.16105418744966, 80.85462273342854 41.70257285592367, 81.37734288942212 40.162688932405224, 81.5625 39.36827914916011, 81.69459591702075 38.567750257762206, 81.80095352896302 36.9450466749183, 81.69459591702075 35.3223430920744, 81.37734288942212 33.72740441743138, 80.85462273342854 32.187520493912935, 80.13537933583446 30.729039162386947, 79.23191915058464 29.376915442803238, 78.15970063193521 28.15428454688341, 76.93706973601537 27.082066028233974, 75.58494601643167 26.178605842984155, 74.12646468490568 25.459362445390067, 72.58658076138724 24.936642289396488, 70.99164208674422 24.61938926179787, 69.9609375 24.5271348225978, 27.0703125 23.885837699862005)
Processing Geometries
Get the geometry type (Point, LineString, Polygon, ect…) from a Geometry
Geometry geom = Geometry.fromString("POINT (-124.80 48.92)")
String type = geom.geometryType
println typePoint
Determine if one Geometry exactly equal another Geometry.
Point point1 = new Point(-121.915, 47.390)
Point point2 = new Point(-121.915, 47.390)
Point point3 = new Point(-121.409, 47.413)
boolean does1equal2 = point1.equals(point2)
println "Does ${point1} equal ${point2}? ${does1equal2 ? 'Yes' : 'No'}"
boolean does1equal3 = point1.equals(point3)
println "Does ${point1} equal ${point3}? ${does1equal3 ? 'Yes' : 'No'}"
boolean does2equal3 = point2.equals(point3)
println "Does ${point2} equal ${point3}? ${does2equal3 ? 'Yes' : 'No'}"Does POINT (-121.915 47.39) equal POINT (-121.915 47.39)? Yes Does POINT (-121.915 47.39) equal POINT (-121.409 47.413)? No Does POINT (-121.915 47.39) equal POINT (-121.409 47.413)? No
Determine if one Geometry equals another Geometry topologically.
Point point1 = new Point(-121.915, 47.390)
Point point2 = new Point(-121.915, 47.390)
Point point3 = new Point(-121.409, 47.413)
boolean does1equal2 = point1.equalsTopo(point2)
println "Does ${point1} equal ${point2}? ${does1equal2 ? 'Yes' : 'No'}"
boolean does1equal3 = point1.equalsTopo(point3)
println "Does ${point1} equal ${point3}? ${does1equal3 ? 'Yes' : 'No'}"
boolean does2equal3 = point2.equalsTopo(point3)
println "Does ${point2} equal ${point3}? ${does2equal3 ? 'Yes' : 'No'}"Does POINT (-121.915 47.39) equal POINT (-121.915 47.39)? Yes Does POINT (-121.915 47.39) equal POINT (-121.409 47.413)? No Does POINT (-121.915 47.39) equal POINT (-121.409 47.413)? No
Determine if one Geometry equals another Geometry when both are normalized.
Geometry geom1 = Geometry.fromWKT("POLYGON ((2 4, 1 3, 2 1, 6 1, 6 3, 4 4, 2 4))")
Geometry geom2 = Geometry.fromWKT("POLYGON ((1 3, 2 4, 4 4, 6 3, 6 1, 2 1, 1 3))")
Geometry geom3 = Geometry.fromWKT("POLYGON ((1 1, 1 4, 4 4, 4 1, 1 1))")
boolean does1equal2 = geom1.equalsNorm(geom2)
println "Does ${geom1} equal ${geom2}? ${does1equal2 ? 'Yes' : 'No'}"
boolean does1equal3 = geom1.equalsNorm(geom3)
println "Does ${geom1} equal ${geom3}? ${does1equal3 ? 'Yes' : 'No'}"
boolean does2equal3 = geom2.equalsNorm(geom3)
println "Does ${geom2} equal ${geom3}? ${does2equal3 ? 'Yes' : 'No'}"Does POLYGON ((2 4, 1 3, 2 1, 6 1, 6 3, 4 4, 2 4)) equal POLYGON ((1 3, 2 4, 4 4, 6 3, 6 1, 2 1, 1 3))? Yes Does POLYGON ((2 4, 1 3, 2 1, 6 1, 6 3, 4 4, 2 4)) equal POLYGON ((1 1, 1 4, 4 4, 4 1, 1 1))? No Does POLYGON ((1 3, 2 4, 4 4, 6 3, 6 1, 2 1, 1 3)) equal POLYGON ((1 1, 1 4, 4 4, 4 1, 1 1))? No
Get a Geometry by index in a GeometryCollection
MultiPoint multiPoint = new MultiPoint([
new Point(-122.3876953125, 47.5820839916191),
new Point(-122.464599609375, 47.25686404408872),
new Point(-122.48382568359374, 47.431803338643334)
])
Point p1 = multiPoint[0]
println p1
Point p2 = multiPoint[1]
println p2
Point p3 = multiPoint[2]
println p3POINT (-122.3876953125 47.5820839916191) POINT (-122.464599609375 47.25686404408872) POINT (-122.48382568359374 47.431803338643334)
Cast a Geometry to a Bounds or to a Point
Geometry geometry = new Polygon([[
[-121.915, 47.390],
[-122.640, 46.995],
[-121.739, 46.308],
[-121.168, 46.777],
[-120.981, 47.316],
[-121.409, 47.413],
[-121.915, 47.390]
]])
Bounds bounds = geometry as Bounds
println bounds
Point point = geometry as Point
println point(-122.64,46.308,-120.981,47.413) POINT (-121.73789467295867 46.95085967283822)
Get the area of a Geometry
Polygon polygon = new Polygon([[
[-124.80, 48.92],
[-126.21, 45.33],
[-114.60, 45.08],
[-115.31, 51.17],
[-121.99, 52.05],
[-124.80, 48.92]
]])
double area = polygon.area
println area62.4026
Get the length of a Geometry
LineString lineString = new LineString([-122.69, 49.61], [-99.84, 45.33])
double length = lineString.length
println length23.24738479915536
Buffer a Point
Point point = new Point(-123,46)
Geometry bufferedPoint = point.buffer(2)
Buffer a LineString with a butt cap
LineString line = new LineString([
[-122.563, 47.576],
[-112.0166, 46.589],
[-101.337, 47.606]
])
Geometry bufferedLine1 = line.buffer(2.1, 10, Geometry.CAP_BUTT)
Buffer a LineString with a round cap
Geometry bufferedLine2 = line.buffer(2.1, 10, Geometry.CAP_ROUND)
Buffer a LineString with a square cap
Geometry bufferedLine3 = line.buffer(2.1, 10, Geometry.CAP_SQUARE)
Buffer a LineString on the right side only
LineString line = new LineString([
[-122.563, 47.576],
[-112.0166, 46.589],
[-101.337, 47.606]
])
Geometry rightBufferedLine = line.singleSidedBuffer(1.5)
Buffer a LineString on the left side only
Geometry leftBufferedLine = line.singleSidedBuffer(-1.5)
Check whether a Geometry contains another Geometry
Polygon polygon1 = new Polygon([[
[-120.739, 48.151],
[-121.003, 47.070],
[-119.465, 47.137],
[-119.553, 46.581],
[-121.267, 46.513],
[-121.168, 45.706],
[-118.476, 45.951],
[-118.762, 48.195],
[-120.739, 48.151]
]])
Polygon polygon2 = new Polygon([[
[-120.212, 47.591],
[-119.663, 47.591],
[-119.663, 47.872],
[-120.212, 47.872],
[-120.212, 47.591]
]])
boolean contains = polygon1.contains(polygon2)
println contains
true
Check whether a Geometry is within another Geometry
Polygon polygon1 = new Polygon([[
[-120.212, 47.591],
[-119.663, 47.591],
[-119.663, 47.872],
[-120.212, 47.872],
[-120.212, 47.591]
]])
Polygon polygon2 = new Polygon([[
[-120.739, 48.151],
[-121.003, 47.070],
[-119.465, 47.137],
[-119.553, 46.581],
[-121.267, 46.513],
[-121.168, 45.706],
[-118.476, 45.951],
[-118.762, 48.195],
[-120.739, 48.151]
]])
boolean within = polygon1.within(polygon2)
println within
true
Polygon polygon3 = new Polygon([[
[-120.563, 46.739],
[-119.948, 46.739],
[-119.948, 46.965],
[-120.563, 46.965],
[-120.563, 46.739]
]])
within = polygon1.within(polygon3)
println within
false
Check whether a Geometry touches another Geometry
LineString line1 = new LineString([
[-122.38651514053345, 47.58219978280006],
[-122.38651514053345, 47.58020234903306]
])
LineString line2 = new LineString([
[-122.38651514053345, 47.58124449789785],
[-122.38333940505981, 47.58124449789785]
])
boolean touches = line1.touches(line2)
true
LineString line3 = new LineString([
[-122.386257648468, 47.58183793450921],
[-122.38348960876465, 47.5818668824645]
])
touches = line1.touches(line3)
false
Create a convexhull Geometry around a Geometry
Geometry geometry = new MultiPoint(
new Point(-119.882, 47.279),
new Point(-100.195, 46.316),
new Point(-111.796, 42.553),
new Point(-90.7031, 34.016)
)
Geometry convexHull = geometry.convexHull
Check whether a Geometry covers another Geometry
Polygon polygon1 = new Polygon([[
[-120.739, 48.151],
[-121.003, 47.070],
[-119.465, 47.137],
[-119.553, 46.581],
[-121.267, 46.513],
[-121.168, 45.706],
[-118.476, 45.951],
[-118.762, 48.195],
[-120.739, 48.151]
]])
Polygon polygon2 = new Polygon([[
[-120.212, 47.591],
[-119.663, 47.591],
[-119.663, 47.872],
[-120.212, 47.872],
[-120.212, 47.591]
]])
boolean isCovered = polygon1.covers(polygon2)
println isCovered
true
Polygon polygon3 = new Polygon([[
[-120.563, 46.739],
[-119.948, 46.739],
[-119.948, 46.965],
[-120.563, 46.965],
[-120.563, 46.739]
]])
isCovered = polygon1.covers(polygon3)
println isCovered
false
Check whether a Geometry is covered by another Geometry
Polygon polygon1 = new Polygon([[
[-120.739, 48.151],
[-121.003, 47.070],
[-119.465, 47.137],
[-119.553, 46.581],
[-121.267, 46.513],
[-121.168, 45.706],
[-118.476, 45.951],
[-118.762, 48.195],
[-120.739, 48.151]
]])
Polygon polygon2 = new Polygon([[
[-120.212, 47.591],
[-119.663, 47.591],
[-119.663, 47.872],
[-120.212, 47.872],
[-120.212, 47.591]
]])
boolean isCoveredBy = polygon2.coveredBy(polygon1)
println isCoveredBy
true
Polygon polygon3 = new Polygon([[
[-120.563, 46.739],
[-119.948, 46.739],
[-119.948, 46.965],
[-120.563, 46.965],
[-120.563, 46.739]
]])
isCoveredBy = polygon3.coveredBy(polygon1)
println isCoveredBy
false
Check whether one Geometry crosses another Geometry
LineString line1 = new LineString([[-122.486, 47.256], [-121.695, 46.822]])
LineString line2 = new LineString([[-122.387, 47.613], [-121.750, 47.353]])
LineString line3 = new LineString([[-122.255, 47.368], [-121.882, 47.746]])
boolean doesCross12 = line1.crosses(line2)
println doesCross12
boolean doesCross13 = line1.crosses(line3)
println doesCross13
boolean doesCross23 = line2.crosses(line3)
println doesCross23
false false true
Calculate the difference between two Geometries
Polygon polygon1 = new Polygon([[
[-121.915, 47.390],
[-122.640, 46.995],
[-121.739, 46.308],
[-121.168, 46.777],
[-120.981, 47.316],
[-121.409, 47.413],
[-121.915, 47.390]
]])
Polygon polygon2 = new Polygon([[
[-120.794, 46.664],
[-121.541, 46.995],
[-122.200, 46.536],
[-121.937, 45.890],
[-120.959, 46.096],
[-120.794, 46.664]
]])
Geometry difference = polygon1.difference(polygon2)
Calculate the symmetric difference between two Geometries
Polygon polygon1 = new Polygon([[
[-121.915, 47.390],
[-122.640, 46.995],
[-121.739, 46.308],
[-121.168, 46.777],
[-120.981, 47.316],
[-121.409, 47.413],
[-121.915, 47.390]
]])
Polygon polygon2 = new Polygon([[
[-120.794, 46.664],
[-121.541, 46.995],
[-122.200, 46.536],
[-121.937, 45.890],
[-120.959, 46.096],
[-120.794, 46.664]
]])
Geometry symDifference = polygon1.symDifference(polygon2)
Check whether one Geometry is disjoint from another Geometry
Polygon polygon1 = new Polygon([[
[-121.915, 47.390],
[-122.640, 46.995],
[-121.739, 46.308],
[-121.168, 46.777],
[-120.981, 47.316],
[-121.409, 47.413],
[-121.915, 47.390]
]])
Polygon polygon2 = new Polygon([[
[-120.794, 46.664],
[-121.541, 46.995],
[-122.200, 46.536],
[-121.937, 45.890],
[-120.959, 46.096],
[-120.794, 46.664]
]])
Polygon polygon3 = new Polygon([[
[-120.541, 47.376],
[-120.695, 47.047],
[-119.794, 46.830],
[-119.586, 47.331],
[-120.102, 47.509],
[-120.541, 47.376]
]])
boolean isDisjoint12 = polygon1.disjoint(polygon2)
println isDisjoint12
boolean isDisjoint13 = polygon1.disjoint(polygon3)
println isDisjoint13
boolean isDisjoint23 = polygon2.disjoint(polygon3)
println isDisjoint23
false true true
Calculate the distance bewteen two Geometries
Point point1 = new Point(-122.442, 47.256)
Point point2 = new Point(-122.321, 47.613)
double distance = point1.distance(point2)
println distance
0.37694827231332195
Get Bounds from a Geometry
Point point = new Point(-123,46)
Polygon polygon = point.buffer(2)
Bounds bounds = polygon.bounds
Get the Boundary from a Geometry
Polygon polygon = new Polygon([
[
[-121.915, 47.390],
[-122.640, 46.995],
[-121.739, 46.308],
[-121.168, 46.777],
[-120.981, 47.316],
[-121.409, 47.413],
[-121.915, 47.390]
],
[
[-122.255, 46.935],
[-121.992, 46.935],
[-121.992, 47.100],
[-122.255, 47.100],
[-122.255, 46.935]
],
[
[-121.717, 46.777],
[-121.398, 46.777],
[-121.398, 47.002],
[-121.717, 47.002],
[-121.717, 46.777]
]
])
Geometry boundary = polygon.boundary
Get the Centroid from a Geometry
Polygon polygon = new Polygon([[
[-118.937, 48.327],
[-121.157, 48.356],
[-121.684, 46.331],
[-119.355, 46.498],
[-119.355, 47.219],
[-120.629, 47.219],
[-120.607, 47.783],
[-119.201, 47.739],
[-118.937, 48.327]
]])
Geometry centroid = polygon.centroid
Get the Interior Point from a Geometry
Polygon polygon = new Polygon([[
[-118.937, 48.327],
[-121.157, 48.356],
[-121.684, 46.331],
[-119.355, 46.498],
[-119.355, 47.219],
[-120.629, 47.219],
[-120.607, 47.783],
[-119.201, 47.739],
[-118.937, 48.327]
]])
Geometry interiorPoint = polygon.interiorPoint
Get the number of Geometries
MultiPoint multiPoint = new MultiPoint([
new Point(-122.3876953125, 47.5820839916191),
new Point(-122.464599609375, 47.25686404408872),
new Point(-122.48382568359374, 47.431803338643334)
])
int number = multiPoint.numGeometries
println number
3
Get a Geometry by index
MultiPoint multiPoint = new MultiPoint([
new Point(-122.3876953125, 47.5820839916191),
new Point(-122.464599609375, 47.25686404408872),
new Point(-122.48382568359374, 47.431803338643334)
])
(0..<multiPoint.getNumGeometries()).each { int i ->
Geometry geometry = multiPoint.getGeometryN(i)
println geometry.wkt
}
POINT (-122.3876953125 47.5820839916191) POINT (-122.464599609375 47.25686404408872) POINT (-122.48382568359374 47.431803338643334)
Get a List of Geometries
MultiPoint multiPoint = new MultiPoint([
new Point(-122.3876953125, 47.5820839916191),
new Point(-122.464599609375, 47.25686404408872),
new Point(-122.48382568359374, 47.431803338643334)
])
List<Geometry> geometries = multiPoint.geometries
geometries.each { Geometry geometry ->
println geometry.wkt
}
POINT (-122.3876953125 47.5820839916191) POINT (-122.464599609375 47.25686404408872) POINT (-122.48382568359374 47.431803338643334)
Get the number of Points in a Geometry
Polygon polygon = new Polygon([[
[-120.563, 46.739],
[-119.948, 46.739],
[-119.948, 46.965],
[-120.563, 46.965],
[-120.563, 46.739]
]])
int number = polygon.numPoints
println number
5
Create a Geometry of a String
Geometry geometry = Geometry.createFromText("Geo")
Create a Sierpinski Carpet in a given Bounds and with a number of points
Bounds bounds = new Bounds(21.645,36.957,21.676,36.970, "EPSG:4326")
Geometry geometry = Geometry.createSierpinskiCarpet(bounds, 50)
Create a Kock Snowflake in a given Bounds and with a number of points
Bounds bounds = new Bounds(21.645,36.957,21.676,36.970, "EPSG:4326")
Geometry geometry = Geometry.createKochSnowflake(bounds, 50)
Perform a cascaded union on a List of Polygons.
Geometry randomPoints = Geometry.createRandomPoints(new Bounds(-180,-90,180,90, "EPSG:4326").geometry, 100)
List<Geometry> bufferedPoints = randomPoints.collect{Geometry geom -> geom.buffer(4.5)}
Geometry unionedGeometry = Geometry.cascadedUnion(bufferedPoints)
Create a number of random points within a given Geometry
Geometry geometry = new Bounds(-180, -90, 180, 90).geometry
MultiPoint randomPoints = Geometry.createRandomPoints(geometry, 100)
Create a number of random points within a given Geometry where the points are contrained to the cells of a grid
Bounds bounds = new Bounds(-180, -90, 180, 90)
MultiPoint randomPoints = Geometry.createRandomPointsInGrid(bounds, 100, true, 0.5)
Create a delaunay triangle diagram around a Geometry
Geometry points = Geometry.createRandomPoints(new Bounds(-180, -90, 180, 90).geometry, 100)
Geometry delaunayTriangle = points.delaunayTriangleDiagram
Create a voronoi diagram around a Geometry
Geometry points = Geometry.createRandomPoints(new Bounds(-180, -90, 180, 90).geometry, 100)
Geometry voronoiDiagram = points.voronoiDiagram
Calculate the union of two Geometries
Polygon polygon1 = new Polygon([[
[-121.915, 47.390],
[-122.640, 46.995],
[-121.739, 46.308],
[-121.168, 46.777],
[-120.981, 47.316],
[-121.409, 47.413],
[-121.915, 47.390]
]])
Polygon polygon2 = new Polygon([[
[-120.794, 46.664],
[-121.541, 46.995],
[-122.200, 46.536],
[-121.937, 45.890],
[-120.959, 46.096],
[-120.794, 46.664]
]])
Geometry union = polygon1.union(polygon2)
Calculate the intersection between two Geometries
Polygon polygon1 = new Polygon([[
[-121.915, 47.390],
[-122.640, 46.995],
[-121.739, 46.308],
[-121.168, 46.777],
[-120.981, 47.316],
[-121.409, 47.413],
[-121.915, 47.390]
]])
Polygon polygon2 = new Polygon([[
[-120.794, 46.664],
[-121.541, 46.995],
[-122.200, 46.536],
[-121.937, 45.890],
[-120.959, 46.096],
[-120.794, 46.664]
]])
Geometry intersection = polygon1.intersection(polygon2)
Check whether one Geometry intersects from another Geometry
Polygon polygon1 = new Polygon([[
[-121.915, 47.390],
[-122.640, 46.995],
[-121.739, 46.308],
[-121.168, 46.777],
[-120.981, 47.316],
[-121.409, 47.413],
[-121.915, 47.390]
]])
Polygon polygon2 = new Polygon([[
[-120.794, 46.664],
[-121.541, 46.995],
[-122.200, 46.536],
[-121.937, 45.890],
[-120.959, 46.096],
[-120.794, 46.664]
]])
Polygon polygon3 = new Polygon([[
[-120.541, 47.376],
[-120.695, 47.047],
[-119.794, 46.830],
[-119.586, 47.331],
[-120.102, 47.509],
[-120.541, 47.376]
]])
boolean does1intersect2 = polygon1.intersects(polygon2)
println does1intersect2
boolean does1intersect3 = polygon1.intersects(polygon3)
println does1intersect3
boolean does2intersect3 = polygon2.intersects(polygon3)
println does2intersect3
true false false
Check whether one Geometry overlaps from another Geometry
Polygon polygon1 = new Polygon([[
[-121.915, 47.390],
[-122.640, 46.995],
[-121.739, 46.308],
[-121.168, 46.777],
[-120.981, 47.316],
[-121.409, 47.413],
[-121.915, 47.390]
]])
Polygon polygon2 = new Polygon([[
[-120.794, 46.664],
[-121.541, 46.995],
[-122.200, 46.536],
[-121.937, 45.890],
[-120.959, 46.096],
[-120.794, 46.664]
]])
Polygon polygon3 = new Polygon([[
[-120.541, 47.376],
[-120.695, 47.047],
[-119.794, 46.830],
[-119.586, 47.331],
[-120.102, 47.509],
[-120.541, 47.376]
]])
boolean does1overlap2 = polygon1.overlaps(polygon2)
println does1overlap2
boolean does1overlap3 = polygon1.overlaps(polygon3)
println does1overlap3
boolean does2overlap3 = polygon2.overlaps(polygon3)
println does2overlap3
true false false
Calculate the octagonal envelope of a Geometry
Geometry geometry = new Polygon ([[
[-122.20367431640624, 47.543163654317304],
[-122.3712158203125, 47.489368981370724],
[-122.33276367187499, 47.35371061951363],
[-122.11029052734374, 47.3704545156932],
[-122.08831787109375, 47.286681888764214],
[-122.28332519531249, 47.2270293988673],
[-122.2174072265625, 47.154237057576594],
[-121.904296875, 47.32579231609051],
[-122.06085205078125, 47.47823216312885],
[-122.20367431640624, 47.543163654317304]
]])
Geometry octagonalEnvelope = geometry.octagonalEnvelope
Calculate the minimum rectangle of a Geometry
Geometry geometry = new Polygon ([[
[-122.20367431640624, 47.543163654317304],
[-122.3712158203125, 47.489368981370724],
[-122.33276367187499, 47.35371061951363],
[-122.11029052734374, 47.3704545156932],
[-122.08831787109375, 47.286681888764214],
[-122.28332519531249, 47.2270293988673],
[-122.2174072265625, 47.154237057576594],
[-121.904296875, 47.32579231609051],
[-122.06085205078125, 47.47823216312885],
[-122.20367431640624, 47.543163654317304]
]])
Geometry minimumRectangle = geometry.minimumRectangle
Calculate the minimum circle of a Geometry
Geometry geometry = new Polygon ([[
[-122.20367431640624, 47.543163654317304],
[-122.3712158203125, 47.489368981370724],
[-122.33276367187499, 47.35371061951363],
[-122.11029052734374, 47.3704545156932],
[-122.08831787109375, 47.286681888764214],
[-122.28332519531249, 47.2270293988673],
[-122.2174072265625, 47.154237057576594],
[-121.904296875, 47.32579231609051],
[-122.06085205078125, 47.47823216312885],
[-122.20367431640624, 47.543163654317304]
]])
Geometry minimumBoundingCircle = geometry.minimumBoundingCircle
Calculate the minimum diameter of a Geometry
Geometry geometry = new Polygon ([[
[-122.20367431640624, 47.543163654317304],
[-122.3712158203125, 47.489368981370724],
[-122.33276367187499, 47.35371061951363],
[-122.11029052734374, 47.3704545156932],
[-122.08831787109375, 47.286681888764214],
[-122.28332519531249, 47.2270293988673],
[-122.2174072265625, 47.154237057576594],
[-121.904296875, 47.32579231609051],
[-122.06085205078125, 47.47823216312885],
[-122.20367431640624, 47.543163654317304]
]])
Geometry minimumDiameter = geometry.minimumDiameter
Calculate the minimum clearance of a Geometry
Geometry geometry = new Polygon ([[
[-122.20367431640624, 47.543163654317304],
[-122.3712158203125, 47.489368981370724],
[-122.33276367187499, 47.35371061951363],
[-122.11029052734374, 47.3704545156932],
[-122.08831787109375, 47.286681888764214],
[-122.28332519531249, 47.2270293988673],
[-122.2174072265625, 47.154237057576594],
[-121.904296875, 47.32579231609051],
[-122.06085205078125, 47.47823216312885],
[-122.20367431640624, 47.543163654317304]
]])
Geometry minimumClearance = geometry.minimumClearance
Offset a LineString by a given distance. Positive distances will offset to the right. Negative distance will offset to the left.
LineString line = new LineString(
[3.198, 43.164],
[6.713, 49.755],
[9.702, 42.592],
[15.32, 53.798]
)
LineString positive = line.offset(1.2)
LineString negative = line.offset(-2.4)
Get the dimension of a Geometry
Point point = Geometry.fromWKT("POINT (-122.3437 47.7540)")
println "Point Dimension = ${point.dimension}"
LineString lineString = Geometry.fromWKT("LINESTRING (-122.525 47.256, -122.376 47.595)")
println "LineString Dimension = ${lineString.dimension}"
Polygon polygon = Geometry.fromWKT("POLYGON ((-122.590 47.204, -122.365 47.204, -122.365 47.312, -122.590 47.312, -122.590 47.204))")
println "Polygon Dimension = ${polygon.dimension}"Point Dimension = 0 LineString Dimension = 1 Polygon Dimension = 2
Determine if a Geometry is empty or not
Geometry geom1 = Geometry.fromWKT("POINT EMPTY")
boolean isGeom1Empty = geom1.empty
println "Is ${geom1.wkt} empty? ${isGeom1Empty ? 'Yes' : 'No'}"
Geometry geom2 = Geometry.fromWKT("POINT (-122.3437 47.7540)")
boolean isGeom2Empty = geom2.empty
println "Is ${geom2.wkt} empty? ${isGeom2Empty ? 'Yes' : 'No'}"Is POINT EMPTY empty? Yes Is POINT (-122.3437 47.754) empty? No
Determine if a Geometry is rectanglular
Geometry geom1 = Geometry.fromWKT("POLYGON ((-122.590 47.204, -122.365 47.204, -122.365 47.312, -122.590 47.312, -122.590 47.204))")
boolean isGeom1Rect = geom1.isRectangle()
println "Is the geometry a rectangle? ${isGeom1Rect ? 'Yes' : 'No'}"
Is the geometry a rectangle? Yes
Geometry geom2 = Geometry.fromWKT("POLYGON ((-122.360 47.215, -122.656 46.912, -121.838 46.931, -122.360 47.215))")
boolean isGeom2Rect = geom2.isRectangle()
println "Is the geometry a rectangle? ${isGeom2Rect ? 'Yes' : 'No'}"
Is the geometry a rectangle? No
Determine if a Geometry is simple
Geometry geom1 = new LineString(
[-122.323, 47.599],
[-122.385, 47.581]
)
boolean isGeom1Simple = geom1.simple
println "Is the Geometry simple? ${isGeom1Simple}"
Is the Geometry simple? true
Geometry geom2 = new LineString(
[-122.356, 47.537],
[-122.295, 47.580],
[-122.284, 47.532],
[-122.353, 47.574]
)
boolean isGeom2Simple = geom2.simple
println "Is the Geometry simple? ${isGeom2Simple}"
Is the Geometry simple? false
Determine if a Geometry is valid
Geometry geom1 = new LineString(
[-122.323, 47.599],
[-122.385, 47.581]
)
boolean isGeom1Valid = geom1.valid
println "Is the Geometry valid? ${isGeom1Valid}"
Is the Geometry valid? true
Geometry geom2 = new Polygon(new LinearRing([
[48.16406, 42.29356],
[35.15625, 25.79989],
[64.33593, 24.52713],
[26.71875, 39.09596],
[48.16406, 42.29356],
]))
boolean isGeom2Valid = geom2.valid
println "Is the Geometry valid? ${isGeom2Valid}"
println geom2.validReason
Is the Geometry valid? false Self-intersection
Determine if a Geometry is curved
Geometry geom1 = new CircularString([
[-122.464599609375, 47.247542522268006],
[-122.03613281249999, 47.37789454155521],
[-122.37670898437499, 47.58393661978134]
])
boolean isGeom1Curved = geom1.curved
println "Is the Geometry valid? ${isGeom1Curved}"
Is the Geometry curved? true
Geometry geom2 = new LineString(
[-122.323, 47.599],
[-122.385, 47.581]
)
boolean isGeom2Curved = geom2.curved
println "Is the Geometry valid? ${isGeom2Curved}"
Is the Geometry curved? false
Determine if a Geometry is within a given distance of another Geometry
Geometry geom1 = new Point(-88.945, 41.771)
Geometry geom2 = new Point(-113.906, 37.160)
double distance1 = 26.0
boolean isWithin1 = geom1.isWithinDistance(geom2, distance1)
println "Is ${geom1} within ${distance1} of ${geom2}? ${isWithin1 ? 'Yes' : 'No'}"Is POINT (-88.945 41.771) within 26.0 of POINT (-113.906 37.16)? Yes
double distance2 = 15.5
boolean isWithin2 = geom1.isWithinDistance(geom2, distance2)
println "Is ${geom1} within ${distance2} of ${geom2}? ${isWithin2 ? 'Yes' : 'No'}"
Is POINT (-88.945 41.771) within 15.5 of POINT (-113.906 37.16)? No
Normalizing a Geometry changes the Geometry in place.
Geometry geometry = Geometry.fromWKT("POLYGON((2 4, 1 3, 2 1, 6 1, 6 3, 4 4, 2 4))")
geometry.normalize()
println "Normalized Geometry = ${geometry}"
Normalized Geometry = POLYGON ((1 3, 2 4, 4 4, 6 3, 6 1, 2 1, 1 3))
Calculating a normalized Geometry from a Geometry does not change the original Geometry.
Geometry geometry = Geometry.fromWKT("POLYGON((2 4, 1 3, 2 1, 6 1, 6 3, 4 4, 2 4))")
Geometry normalizedGeometry = geometry.norm
println "Un-normalized Geometry = ${geometry}"
println "Normalized Geometry = ${normalizedGeometry}"
Un-normalized Geometry = POLYGON ((2 4, 1 3, 2 1, 6 1, 6 3, 4 4, 2 4)) Normalized Geometry = POLYGON ((1 3, 2 4, 4 4, 6 3, 6 1, 2 1, 1 3))
Smooth a Geometry
Geometry geometry = Geometry.fromWKT("POLYGON((10 0, 10 20, 0 20, 0 30, 30 30, 30 20, 20 20, 20 0, 10 0))")
Geometry smoothed = geometry.smooth(0.75)
Calculate the DE-9IM Intersection Matrix between two geometries.
Polygon polygon1 = new Polygon([[
[-121.915, 47.390],
[-122.640, 46.995],
[-121.739, 46.308],
[-121.168, 46.777],
[-120.981, 47.316],
[-121.409, 47.413],
[-121.915, 47.390]
]])
Polygon polygon2 = new Polygon([[
[-120.794, 46.664],
[-121.541, 46.995],
[-122.200, 46.536],
[-121.937, 45.890],
[-120.959, 46.096],
[-120.794, 46.664]
]])
IntersectionMatrix matrix = polygon1.relate(polygon2)
println "Intersection Matrix = ${matrix}"
println "Contains = ${matrix.contains}"
println "Covered By = ${matrix.coveredBy}"
println "Covers = ${matrix.covers}"
println "Disjoint = ${matrix.disjoint}"
println "Intersects = ${matrix.intersects}"
println "Within = ${matrix.within}"
Intersection Matrix = 212101212 Contains = false Covered By = false Covers = false Disjoint = false Intersects = true Within = false
Determine if a Geometry relates to another Geometry according to the given DE-9IM Intersection Matrix string
Polygon polygon1 = new Polygon([[
[-121.915, 47.390],
[-122.640, 46.995],
[-121.739, 46.308],
[-121.168, 46.777],
[-120.981, 47.316],
[-121.409, 47.413],
[-121.915, 47.390]
]])
Polygon polygon2 = new Polygon([[
[-120.794, 46.664],
[-121.541, 46.995],
[-122.200, 46.536],
[-121.937, 45.890],
[-120.959, 46.096],
[-120.794, 46.664]
]])
println polygon1.relate(polygon2, "212101212")
println polygon1.relate(polygon2, "111111111")
println polygon1.relate(polygon2, "222222222")
true false false
Densify a Geometry by adding points at a given interval.
Geometry geometry = new LineString([
[-122.28062152862547, 47.12986316579223],
[-122.2809863090515, 47.12935221617075],
[-122.2809863090515, 47.12786313499169],
[-122.28111505508421, 47.127731743474406],
[-122.28137254714966, 47.127673347140345],
[-122.28178024291992, 47.12768794622986],
[-122.28227376937865, 47.128067521151195],
[-122.28227376937865, 47.12906024275466]
])
Geometry densified = geometry.densify(0.0001)
println "# of points in original geometry = ${geometry.numPoints}"
println "# of points in densified geometry = ${densified.numPoints}"
# of points in original geometry = 8 # of points in densified geometry = 50
Simplify a Geometry by removing points at a given interval.
Geometry geometry = new LineString([
[-123.59619140625001, 47.338822694822],
[-123.04687499999999, 47.010225655683485],
[-122.2119140625, 46.965259400349275],
[-121.201171875, 47.17477833929903],
[-120.87158203125, 47.487513008956554],
[-120.62988281249999, 48.31242790407178],
[-120.84960937499999, 48.647427805533546],
[-121.59667968749999, 48.850258199721495],
[-122.36572265625, 48.980216985374994],
[-123.134765625, 48.83579746243093],
[-123.3984375, 48.44377831058802],
[-123.59619140625001, 48.10743118848039],
[-123.85986328124999, 47.62097541515849]
])
Geometry simplified = geometry.simplify(0.5)
println "# of points in original geometry = ${geometry.numPoints}"
println "# of points in simplified geometry = ${simplified.numPoints}"
# of points in original geometry = 13 # of points in simplified geometry = 5
Simplify a Geometry by removing points at a given interval but preserve the topological structure.
Geometry geometry = new LineString([
[-123.59619140625001, 47.338822694822],
[-123.04687499999999, 47.010225655683485],
[-122.2119140625, 46.965259400349275],
[-121.201171875, 47.17477833929903],
[-120.87158203125, 47.487513008956554],
[-120.62988281249999, 48.31242790407178],
[-120.84960937499999, 48.647427805533546],
[-121.59667968749999, 48.850258199721495],
[-122.36572265625, 48.980216985374994],
[-123.134765625, 48.83579746243093],
[-123.3984375, 48.44377831058802],
[-123.59619140625001, 48.10743118848039],
[-123.85986328124999, 47.62097541515849]
])
Geometry simplified = geometry.simplifyPreservingTopology(0.1)
println "# of points in original geometry = ${geometry.numPoints}"
println "# of points in simplified geometry = ${simplified.numPoints}"
# of points in original geometry = 13 # of points in simplified geometry = 11
Translate or move a geometry a given distance along the x and y axis.
Geometry geometry = new Polygon(new LinearRing([
[-121.83837890625, 47.5913464767971],
[-122.76123046875, 46.9802523552188],
[-122.67333984374, 46.3014061543733],
[-121.00341796874, 46.3772542051002],
[-121.22314453124, 47.1448974855539],
[-121.83837890625, 47.5913464767971]
]))
Geometry translatedGeometry = geometry.translate(2.1, 3.2)
Scale a geometry a given amount in an x and y direction around the origin
Geometry geometry = new Polygon(new LinearRing([
[-121.83837890625, 47.5913464767971],
[-122.76123046875, 46.9802523552188],
[-122.67333984374, 46.3014061543733],
[-121.00341796874, 46.3772542051002],
[-121.22314453124, 47.1448974855539],
[-121.83837890625, 47.5913464767971]
]))
Geometry scaledGeometry = geometry.scale(1.1,1.2)
println scaledGeometry
Scale a geometry a given amount in an x and y direction around a point
Geometry geometry = new Polygon(new LinearRing([
[-121.83837890625, 47.5913464767971],
[-122.76123046875, 46.9802523552188],
[-122.67333984374, 46.3014061543733],
[-121.00341796874, 46.3772542051002],
[-121.22314453124, 47.1448974855539],
[-121.83837890625, 47.5913464767971]
]))
Point centroid = geometry.centroid
Geometry scaledGeometry = geometry.scale(1.1, 1.1, centroid.x, centroid.y)
Rotate a Geometry around it’s origin by a given angle theta (in radians).
Geometry geometry = new Polygon(new LinearRing([
[-121.83837890625, 47.5913464767971],
[-122.76123046875, 46.9802523552188],
[-122.67333984374, 46.3014061543733],
[-121.00341796874, 46.3772542051002],
[-121.22314453124, 47.1448974855539],
[-121.83837890625, 47.5913464767971]
]))
Geometry theta = geometry.rotate(Math.toRadians(45))
Rotate a Geometry around an XY coordinate by a given angle theta (in radians).
Geometry thetaXY = geometry.rotate(Math.toRadians(90), geometry.centroid.x, geometry.centroid.y)
Rotate a Geometry around it’s origin by a given angle sine and cosine (in radians).
Geometry sinCos = geometry.rotate(Math.toRadians(15), Math.toRadians(35))
Rotate a Geometry around an XY coordinate by a given angle sine and cosine (in radians).
Geometry sinCosXY = geometry.rotate(Math.toRadians(15), Math.toRadians(35), geometry.centroid.x, geometry.centroid.y)
Shear a Geometry around it’s origin by a given distance along the x and y axis.
Geometry geometry = new Polygon(new LinearRing([
[-121.83837890625, 47.5913464767971],
[-122.76123046875, 46.9802523552188],
[-122.67333984374, 46.3014061543733],
[-121.00341796874, 46.3772542051002],
[-121.22314453124, 47.1448974855539],
[-121.83837890625, 47.5913464767971]
]))
Geometry shearedGeometry = geometry.shear(0.1,0.4)
Reflect a Geometry around an XY coordinate for given distance along the x and y axis
Geometry geometry = new Polygon(new LinearRing([
[-121.83837890625, 47.5913464767971],
[-122.76123046875, 46.9802523552188],
[-122.67333984374, 46.3014061543733],
[-121.00341796874, 46.3772542051002],
[-121.22314453124, 47.1448974855539],
[-121.83837890625, 47.5913464767971]
]))
Point centroid = geometry.centroid
Geometry reflectedGeometry = geometry.reflect(0.1,0.4, centroid.x, centroid.y)
Reflect a Geometry around the origin for given distance along the x and y axis
Geometry reflectedAroundOrigin = geometry.reflect(0.5, 0.34)
Reduce the precision of a Geometry’s coordinates.
Geometry g1 = new Point(5.19775390625, 51.07421875)
println "Original Geometry: ${g1.wkt}"
Geometry g2 = g1.reducePrecision()
println "Floating Point Geometry: ${g2.wkt}"
Geometry g3 = g1.reducePrecision("fixed", scale: 100)
println "Fixed Point Geometry: ${g3.wkt}"
Geometry g4 = g1.reducePrecision("floating_single", pointwise: true, removecollapsed: true)
println "Floating Point Single Geometry: ${g4.wkt}"Original Geometry: POINT (5.19775390625 51.07421875) Floating Point Geometry: POINT (5.19775390625 51.07421875) Fixed Point Geometry: POINT (5.2 51.07) Floating Point Single Geometry: POINT (5.19775390625 51.07421875)
Find the nearest points in one Geometry to another
Geometry point = new Point( -122.3845276236534, 47.58285653105873)
Geometry polygon = Geometry.fromWKT("POLYGON ((-122.3848307132721 47.58285110342092, " +
"-122.38484144210814 47.58255620092149, -122.38469392061235 47.582558010144346, " +
"-122.3846912384033 47.5825797208137, -122.38460808992384 47.58258695770149, " +
"-122.38460808992384 47.582628569786834, -122.38458126783371 47.58263037900717, " +
"-122.38458126783371 47.58277330721735, -122.38460540771483 47.58277149800195, " +
"-122.38460540771483 47.582805873084084, -122.38467246294022 47.5828131099406, " +
"-122.38467246294022 47.58285110342092, -122.3848307132721 47.58285110342092))")
List<Point> nearestPoints = polygon.getNearestPoints(point)
Convert a Geometry to a PreparedGeometry for more effecient spatial queries.
Geometry geometry = new Polygon([[
[-121.915, 47.390],
[-122.640, 46.995],
[-121.739, 46.308],
[-121.168, 46.777],
[-120.981, 47.316],
[-121.409, 47.413],
[-121.915, 47.390]
]])
PreparedGeometry preparedGeometry = geometry.prepare()
Closure timer = { Closure action ->
long start = System.nanoTime()
action.call()
long end = System.nanoTime()
end - start
}
MultiPoint points = Geometry.createRandomPoints(new Bounds(-180, -90, 180, 90).geometry, 100000)
long timeWithGeometry = timer({ ->
points.geometries.each { Point point ->
geometry.contains(point)
}
})
println "Time with Geometry = ${timeWithGeometry} nanoseconds"
long timeWithPreparedGeometry = timer({ ->
points.geometries.each { Point point ->
preparedGeometry.contains(point)
}
})
println "Time with PreparedGeometry = ${timeWithPreparedGeometry} nanoseconds"Time with Geometry = 357222443 nanoseconds Time with PreparedGeometry = 214496717 nanoseconds
Convert a Geometry to a PreparedGeometry using a static method for more effecient spatial queries.
Geometry geometry = new Polygon([[
[-121.915, 47.390],
[-122.640, 46.995],
[-121.739, 46.308],
[-121.168, 46.777],
[-120.981, 47.316],
[-121.409, 47.413],
[-121.915, 47.390]
]])
PreparedGeometry preparedGeometry = Geometry.prepare(geometry)
Closure timer = { Closure action ->
long start = System.nanoTime()
action.call()
long end = System.nanoTime()
end - start
}
MultiPoint points = Geometry.createRandomPoints(new Bounds(-180, -90, 180, 90).geometry, 100000)
long timeWithGeometry = timer({ ->
points.geometries.each { Point point ->
geometry.contains(point)
}
})
println "Time with Geometry = ${timeWithGeometry} nanoseconds"
long timeWithPreparedGeometry = timer({ ->
points.geometries.each { Point point ->
preparedGeometry.contains(point)
}
})
println "Time with PreparedGeometry = ${timeWithPreparedGeometry} nanoseconds"Time with Geometry = 304872303 nanoseconds Time with PreparedGeometry = 111271858 nanoseconds
Prepared Geometry
PreparedGeometry are more effecient for spatial queries.
You can create a PreparedGeometry by wrapping an existing Geometry. You can then get the original Geometry with the geometry property.
Polygon polygon = new Polygon([[
[-120.739, 48.151],
[-121.003, 47.070],
[-119.465, 47.137],
[-119.553, 46.581],
[-121.267, 46.513],
[-121.168, 45.706],
[-118.476, 45.951],
[-118.762, 48.195],
[-120.739, 48.151]
]])
PreparedGeometry preparedGeometry = new PreparedGeometry(polygon)
Geometry geometry = preparedGeometry.geometry
Check whether a PreparedGeometry contains another Geometry
PreparedGeometry polygon1 = new PreparedGeometry(new Polygon([[
[-120.739, 48.151],
[-121.003, 47.070],
[-119.465, 47.137],
[-119.553, 46.581],
[-121.267, 46.513],
[-121.168, 45.706],
[-118.476, 45.951],
[-118.762, 48.195],
[-120.739, 48.151]
]]))
Polygon polygon2 = new Polygon([[
[-120.212, 47.591],
[-119.663, 47.591],
[-119.663, 47.872],
[-120.212, 47.872],
[-120.212, 47.591]
]])
boolean contains = polygon1.contains(polygon2)
println contains
true
false
Check whether a PreparedGeometry properly contains another Geometry. This means that every point in the other geometry doesn’t intersect with the first.
PreparedGeometry polygon1 = new PreparedGeometry(new Polygon([[
[-122.50064849853516, 47.22096718353454],
[-122.41928100585938, 47.22096718353454],
[-122.41928100585938, 47.277365616965646],
[-122.50064849853516, 47.277365616965646],
[-122.50064849853516, 47.22096718353454]
]]))
Polygon polygon2 = new Polygon([[
[-122.44571685791014, 47.24031721435104],
[-122.42958068847656, 47.24031721435104],
[-122.42958068847656, 47.253135632244216],
[-122.44571685791014, 47.253135632244216],
[-122.44571685791014, 47.24031721435104]
]])
boolean contains = polygon1.containsProperly(polygon2)
println contains
true
false
Check whether a PreparedGeometry is covered by another Geometry.
Polygon polygon1 = new Polygon([[
[-120.739, 48.151],
[-121.003, 47.070],
[-119.465, 47.137],
[-119.553, 46.581],
[-121.267, 46.513],
[-121.168, 45.706],
[-118.476, 45.951],
[-118.762, 48.195],
[-120.739, 48.151]
]])
PreparedGeometry polygon2 = new PreparedGeometry(new Polygon([[
[-120.212, 47.591],
[-119.663, 47.591],
[-119.663, 47.872],
[-120.212, 47.872],
[-120.212, 47.591]
]]))
boolean isCoveredBy = polygon2.coveredBy(polygon1)
println isCoveredBy
true
false
Check whether a PreparedGeometry covers another Geometry.
PreparedGeometry polygon1 = new PreparedGeometry(new Polygon([[
[-120.739, 48.151],
[-121.003, 47.070],
[-119.465, 47.137],
[-119.553, 46.581],
[-121.267, 46.513],
[-121.168, 45.706],
[-118.476, 45.951],
[-118.762, 48.195],
[-120.739, 48.151]
]]))
Polygon polygon2 = new Polygon([[
[-120.212, 47.591],
[-119.663, 47.591],
[-119.663, 47.872],
[-120.212, 47.872],
[-120.212, 47.591]
]])
boolean isCovered = polygon1.covers(polygon2)
println isCovered
true
false
Check whether a PreparedGeometry crosses another Geometry.
PreparedGeometry line1 = new PreparedGeometry(new LineString([[-122.387, 47.613], [-121.750, 47.353]]))
LineString line2 = new LineString([[-122.255, 47.368], [-121.882, 47.746]])
LineString line3 = new LineString([[-122.486, 47.256], [-121.695, 46.822]])
boolean doesCross12 = line1.crosses(line2)
println doesCross12
boolean doesCross13 = line1.crosses(line3)
println doesCross13
true false
Check whether a PreparedGeometry is disjoint from another Geometry.
PreparedGeometry polygon1 = new PreparedGeometry(new Polygon([[
[-121.915, 47.390],
[-122.640, 46.995],
[-121.739, 46.308],
[-121.168, 46.777],
[-120.981, 47.316],
[-121.409, 47.413],
[-121.915, 47.390]
]]))
Polygon polygon2 = new Polygon([[
[-120.794, 46.664],
[-121.541, 46.995],
[-122.200, 46.536],
[-121.937, 45.890],
[-120.959, 46.096],
[-120.794, 46.664]
]])
Polygon polygon3 = new Polygon([[
[-120.541, 47.376],
[-120.695, 47.047],
[-119.794, 46.830],
[-119.586, 47.331],
[-120.102, 47.509],
[-120.541, 47.376]
]])
boolean isDisjoint12 = polygon1.disjoint(polygon2)
println isDisjoint12
boolean isDisjoint13 = polygon1.disjoint(polygon3)
println isDisjoint13
false true
Check whether a PreparedGeometry intersects another Geometry.
PreparedGeometry polygon1 = new PreparedGeometry(new Polygon([[
[-121.915, 47.390],
[-122.640, 46.995],
[-121.739, 46.308],
[-121.168, 46.777],
[-120.981, 47.316],
[-121.409, 47.413],
[-121.915, 47.390]
]]))
Polygon polygon2 = new Polygon([[
[-120.794, 46.664],
[-121.541, 46.995],
[-122.200, 46.536],
[-121.937, 45.890],
[-120.959, 46.096],
[-120.794, 46.664]
]])
Polygon polygon3 = new Polygon([[
[-120.541, 47.376],
[-120.695, 47.047],
[-119.794, 46.830],
[-119.586, 47.331],
[-120.102, 47.509],
[-120.541, 47.376]
]])
boolean does1intersect2 = polygon1.intersects(polygon2)
println does1intersect2
boolean does1intersect3 = polygon1.intersects(polygon3)
println does1intersect3
true false
Check whether a PreparedGeometry overlaps another Geometry.
PreparedGeometry polygon1 = new PreparedGeometry(new Polygon([[
[-121.915, 47.390],
[-122.640, 46.995],
[-121.739, 46.308],
[-121.168, 46.777],
[-120.981, 47.316],
[-121.409, 47.413],
[-121.915, 47.390]
]]))
Polygon polygon2 = new Polygon([[
[-120.794, 46.664],
[-121.541, 46.995],
[-122.200, 46.536],
[-121.937, 45.890],
[-120.959, 46.096],
[-120.794, 46.664]
]])
Polygon polygon3 = new Polygon([[
[-120.541, 47.376],
[-120.695, 47.047],
[-119.794, 46.830],
[-119.586, 47.331],
[-120.102, 47.509],
[-120.541, 47.376]
]])
boolean does1overlap2 = polygon1.overlaps(polygon2)
println does1overlap2
boolean does1overlap3 = polygon1.overlaps(polygon3)
println does1overlap3
true false
Check whether a PreparedGeometry touches another Geometry.
PreparedGeometry line1 = new PreparedGeometry(new LineString([
[-122.38651514053345, 47.58219978280006],
[-122.38651514053345, 47.58020234903306]
]))
LineString line2 = new LineString([
[-122.38651514053345, 47.58124449789785],
[-122.38333940505981, 47.58124449789785]
])
boolean touches = line1.touches(line2)
true
LineString line3 = new LineString([
[-122.386257648468, 47.58183793450921],
[-122.38348960876465, 47.5818668824645]
])
touches = line1.touches(line3)
false
Check whether a PreparedGeometry is within another Geometry.
PreparedGeometry polygon1 = new PreparedGeometry(new Polygon([[
[-120.212, 47.591],
[-119.663, 47.591],
[-119.663, 47.872],
[-120.212, 47.872],
[-120.212, 47.591]
]]))
Polygon polygon2 = new Polygon([[
[-120.739, 48.151],
[-121.003, 47.070],
[-119.465, 47.137],
[-119.553, 46.581],
[-121.267, 46.513],
[-121.168, 45.706],
[-118.476, 45.951],
[-118.762, 48.195],
[-120.739, 48.151]
]])
boolean within = polygon1.within(polygon2)
println within
true
Polygon polygon3 = new Polygon([[
[-120.563, 46.739],
[-119.948, 46.739],
[-119.948, 46.965],
[-120.563, 46.965],
[-120.563, 46.739]
]])
within = polygon1.within(polygon3)
println within
false
Reading and Writing Geometries
The geoscript.geom.io package has several Readers and Writers for converting geoscript.geom.Geometry to and from strings.
Readers and Writers
Find all Geometry Readers
List<Reader> readers = Readers.list()
readers.each { Reader reader ->
println reader.class.simpleName
}GeobufReader GeoJSONReader GeoRSSReader Gml2Reader Gml3Reader GpxReader KmlReader WkbReader WktReader GeoPackageReader GooglePolylineEncoder TWkbReader
Find a Geometry Reader
String wkt = "POINT (-123.15 46.237)"
Reader reader = Readers.find("wkt")
Geometry geometry = reader.read(wkt)
Find all Geometry Writers
List<Writer> writers = Writers.list()
writers.each { Writer writer ->
println writer.class.simpleName
}GeobufWriter GeoJSONWriter GeoRSSWriter Gml2Writer Gml3Writer GpxWriter KmlWriter WkbWriter WktWriter GeoPackageWriter GooglePolylineEncoder
Find a Geometry Writer
Geometry geometry = new Point(-122.45, 43.21)
Writer writer = Writers.find("geojson")
String geojson = writer.write(geometry)
println geojson{"type":"Point","coordinates":[-122.45,43.21]}
Create a Geometry from a String. The string will be parse by each Geometry Reader.
Geometry geom1 = Geometry.fromString('POINT (-123.15 46.237)')
println geom1
Geometry geom2 = Geometry.fromString('{"type":"LineString","coordinates":[[3.198,43.164],[6.713,49.755],[9.702,42.592],[15.32,53.798]]}')
println geom2
Geometry geom3 = Geometry.fromString('<Point><coordinates>-123.15,46.237</coordinates></Point>')
println geom3POINT (-123.15 46.237) LINESTRING (3.198 43.164, 6.713 49.755, 9.702 42.592, 15.32 53.798) POINT (-123.15 46.237)
WKB
Read a Geometry from WKB using the WkbReader
String wkb = "0000000001C05EC9999999999A40471E5604189375"
WkbReader reader = new WkbReader()
Geometry geometry = reader.read(wkb)
Read a Geometry from WKB using the Geometry.fromWKB() static method
String wkb = "000000000200000004400995810624DD2F404594FDF3B645A2401ADA1CAC0831274048E0A3D70A3D714023676C8B43958140454BC6A7EF9DB2402EA3D70A3D70A4404AE624DD2F1AA0"
Geometry geometry = Geometry.fromWKB(wkb)
Get the WKB of a Geometry
Geometry geometry = new Point(-123.15, 46.237)
String wkb = geometry.wkb
println wkb0000000001C05EC9999999999A40471E5604189375
Write a Geometry to WKB using the WkbWriter
Geometry geometry = new LineString(
[3.198, 43.164],
[6.713, 49.755],
[9.702, 42.592],
[15.32, 53.798]
)
WkbWriter writer = new WkbWriter()
String wkb = writer.write(geometry)
println wkb000000000200000004400995810624DD2F404594FDF3B645A2401ADA1CAC0831274048E0A3D70A3D714023676C8B43958140454BC6A7EF9DB2402EA3D70A3D70A4404AE624DD2F1AA0
WKT
Read a Geometry from WKT using the WktReader
String wkt = "POINT (-123.15 46.237)"
WktReader reader = new WktReader()
Geometry geometry = reader.read(wkt)
Read a Geometry from WKT using the Geometry.fromWKT() static method
String wkt = "LINESTRING (3.198 43.164, 6.7138 49.755, 9.702 42.592, 15.327 53.798)"
Geometry geometry = Geometry.fromWKT(wkt)
Get the WKT of a Geometry
Geometry geometry = new Point(-123.15, 46.237)
String wkt = geometry.wkt
println wktPOINT (-123.15 46.237)
Write a Geometry to WKT using the WktWriter
Geometry geometry = new LineString(
[3.198, 43.164],
[6.713, 49.755],
[9.702, 42.592],
[15.32, 53.798]
)
WktWriter writer = new WktWriter()
String wkt = writer.write(geometry)
println wktLINESTRING (3.198 43.164, 6.713 49.755, 9.702 42.592, 15.32 53.798)
TWKB
Read a Geometry from TWKB hex encoded String
TWkbReader reader = new TWkbReader()
Geometry geometry = reader.read("01000204")
println geometry.wktPOINT (1 2)
GeoJSON
Read a Geometry from GeoJSON using the GeoJSONReader
String json = '{"type":"Point","coordinates":[-123.15,46.237]}'
GeoJSONReader reader = new GeoJSONReader()
Geometry geometry = reader.read(json)
Read a Geometry from GeoJSON using the Geometry.fromGeoJSON() static method
String json = '{"type":"LineString","coordinates":[[3.198,43.164],[6.713,49.755],[9.702,42.592],[15.32,53.798]]}'
Geometry geometry = Geometry.fromGeoJSON(json)
Get the GeoJSON of a Geometry
Geometry geometry = new Point(-123.15, 46.237)
String json = geometry.geoJSON
println json{"type":"Point","coordinates":[-123.15,46.237]}
Write a Geometry to GeoJSON using the GeoJSONWriter
Geometry geometry = new LineString(
[3.198, 43.164],
[6.713, 49.755],
[9.702, 42.592],
[15.32, 53.798]
)
GeoJSONWriter writer = new GeoJSONWriter()
String json = writer.write(geometry)
println json{"type":"LineString","coordinates":[[3.198,43.164],[6.713,49.755],[9.702,42.592],[15.32,53.798]]}
GeoPackage
Read a Geometry from GeoPackage hex encoded string using the GeoPackageReader
String str = "4750000200000000c05ec9999999999ac05ec9999999999a40471e560418937540471e56041893750000000001c05ec9999999999a40471e5604189375"
GeoPackageReader reader = new GeoPackageReader()
Geometry geometry = reader.read(str)
Read a Geometry from GeoPackage bytes using the GeoPackageReader
byte[] bytes = "4750000200000000c05ec9999999999ac05ec9999999999a40471e560418937540471e56041893750000000001c05ec9999999999a40471e5604189375".decodeHex()
GeoPackageReader reader = new GeoPackageReader()
Geometry geometry = reader.read(bytes)
Write a Geometry to a GeoPackage hex encoded string
Geometry geometry = new Point(-123.15, 46.237)
GeoPackageWriter writer = new GeoPackageWriter()
String str = writer.write(geometry)
println str4750000200000000c05ec9999999999ac05ec9999999999a40471e560418937540471e56041893750000000001c05ec9999999999a40471e5604189375
Write a Geometry to a GeoPackage byte array
Geometry geometry = new Point(-123.15, 46.237)
GeoPackageWriter writer = new GeoPackageWriter()
byte[] bytes = writer.writeBytes(geometry)
println bytes.encodeHex()4750000200000000c05ec9999999999ac05ec9999999999a40471e560418937540471e56041893750000000001c05ec9999999999a40471e5604189375
KML
Read a Geometry from KML using the KmlReader
String kml = "<Point><coordinates>-123.15,46.237</coordinates></Point>"
KmlReader reader = new KmlReader()
Geometry geometry = reader.read(kml)
Read a Geometry from KML using the Geometry.fromKml() static method
String kml = "<LineString><coordinates>3.198,43.164 6.713,49.755 9.702,42.592 15.32,53.798</coordinates></LineString>"
Geometry geometry = Geometry.fromKml(kml)
Get the KML of a Geometry
Geometry geometry = new Point(-123.15, 46.237)
String kml = geometry.kml
println kml<Point><coordinates>-123.15,46.237</coordinates></Point>
Write a Geometry to KML using the KmlWriter
Geometry geometry = new LineString(
[3.198, 43.164],
[6.713, 49.755],
[9.702, 42.592],
[15.32, 53.798]
)
KmlWriter writer = new KmlWriter()
String kml = writer.write(geometry)
println kml<LineString><coordinates>3.198,43.164 6.713,49.755 9.702,42.592 15.32,53.798</coordinates></LineString>
Geobuf
Read a Geometry from Geobuf using the GeobufReader
String geobuf = "10021806320c08001a08dffab87590958c2c"
GeobufReader reader = new GeobufReader()
Geometry geometry = reader.read(geobuf)
Read a Geometry from Geobuf using the Geometry.fromGeobuf() static method
String geobuf = "10021806322408021a20e0b08603c0859529f089ad03b0c8a40690efec02efb1ea06a0e5ad05e0f5d70a"
Geometry geometry = Geometry.fromGeobuf(geobuf)
Get the Geobuf of a Geometry
Geometry geometry = new Point(-123.15, 46.237)
String geobuf = geometry.geobuf
println geobuf10021806320c08001a08dffab87590958c2c
Write a Geometry to Geobuf using the GeobufWriter
Geometry geometry = new LineString(
[3.198, 43.164],
[6.713, 49.755],
[9.702, 42.592],
[15.32, 53.798]
)
GeobufWriter writer = new GeobufWriter()
String geobuf = writer.write(geometry)
println geobuf10021806322408021a20e0b08603c0859529f089ad03b0c8a40690efec02efb1ea06a0e5ad05e0f5d70a
GML 2
Read a Geometry from GML2 using the Gml2Reader
String gml2 = "<gml:Point><gml:coordinates>-123.15,46.237</gml:coordinates></gml:Point>"
Gml2Reader reader = new Gml2Reader()
Geometry geometry = reader.read(gml2)
Read a Geometry from GML2 using the Geometry.fromGML2() static method
String gml2 = "<gml:LineString><gml:coordinates>3.198,43.164 6.713,49.755 9.702,42.592 15.32,53.798</gml:coordinates></gml:LineString>"
Geometry geometry = Geometry.fromGML2(gml2)
Get the GML2 of a Geometry
Geometry geometry = new Point(-123.15, 46.237)
String gml2 = geometry.gml2
println gml2<gml:Point><gml:coordinates>-123.15,46.237</gml:coordinates></gml:Point>
Write a Geometry to GML2 using the Gml2Writer
Geometry geometry = new LineString(
[3.198, 43.164],
[6.713, 49.755],
[9.702, 42.592],
[15.32, 53.798]
)
Gml2Writer writer = new Gml2Writer()
String gml2 = writer.write(geometry)
println gml2<gml:LineString><gml:coordinates>3.198,43.164 6.713,49.755 9.702,42.592 15.32,53.798</gml:coordinates></gml:LineString>
GML 3
Read a Geometry from GML3 using the Gml3Reader
String gml3 = "<gml:Point><gml:pos>-123.15 46.237</gml:pos></gml:Point>"
Gml3Reader reader = new Gml3Reader()
Geometry geometry = reader.read(gml3)
Read a Geometry from GML3 using the Geometry.fromGML3() static method
String gml3 = "<gml:LineString><gml:posList>3.198 43.164 6.713 49.755 9.702 42.592 15.32 53.798</gml:posList></gml:LineString>"
Geometry geometry = Geometry.fromGML3(gml3)
Get the GML3 of a Geometry
Geometry geometry = new Point(-123.15, 46.237)
String gml3 = geometry.gml3
println gml3<gml:Point><gml:pos>-123.15 46.237</gml:pos></gml:Point>
Write a Geometry to GML3 using the Gml3Writer
Geometry geometry = new LineString(
[3.198, 43.164],
[6.713, 49.755],
[9.702, 42.592],
[15.32, 53.798]
)
Gml3Writer writer = new Gml3Writer()
String gml3 = writer.write(geometry)
println gml3<gml:LineString><gml:posList>3.198 43.164 6.713 49.755 9.702 42.592 15.32 53.798</gml:posList></gml:LineString>
GPX
Read a Geometry from GPX using the GpxReader
String gpx = "<wpt lat='46.237' lon='-123.15'/>"
GpxReader reader = new GpxReader()
Geometry geometry = reader.read(gpx)
Read a Geometry from GPX using the Geometry.fromGPX() static method
String gpx = "<rte><rtept lat='43.164' lon='3.198' /><rtept lat='49.755' lon='6.713' /><rtept lat='42.592' lon='9.702' /><rtept lat='53.798' lon='15.32' /></rte>"
Geometry geometry = Geometry.fromGpx(gpx)
Get the GPX of a Geometry
Geometry geometry = new Point(-123.15, 46.237)
String gpx = geometry.gpx
println gpx<wpt lat='46.237' lon='-123.15'/>
Write a Geometry to GPX using the GpxWriter
Geometry geometry = new LineString(
[3.198, 43.164],
[6.713, 49.755],
[9.702, 42.592],
[15.32, 53.798]
)
GpxWriter writer = new GpxWriter()
String gpx = writer.write(geometry)
println gpx<rte><rtept lat='43.164' lon='3.198' /><rtept lat='49.755' lon='6.713' /><rtept lat='42.592' lon='9.702' /><rtept lat='53.798' lon='15.32' /></rte>
GeoRSS
Read a Geometry from GeoRSS using the GeoRSSReader
String georss = "<georss:point>46.237 -123.15</georss:point>"
GeoRSSReader reader = new GeoRSSReader()
Geometry geometry = reader.read(georss)
Write a Geometry to GeoRSS using the GeoRSSWriter
Geometry geometry = new LineString(
[3.198, 43.164],
[6.713, 49.755],
[9.702, 42.592],
[15.32, 53.798]
)
GeoRSSWriter writer = new GeoRSSWriter()
String georss = writer.write(geometry)
println georss<georss:line>43.164 3.198 49.755 6.713 42.592 9.702 53.798 15.32</georss:line>
Google Polyline
Read a Geometry from a Google Polyline Encoded String using the GeoRSSReader
String str = "_p~iF~ps|U_ulLnnqC_mqNvxq`@"
GooglePolylineEncoder encoder = new GooglePolylineEncoder()
Geometry geometry = encoder.read(str)
Write a Geometry to a Google Polyline Encoded String using the GeoRSSWriter
Geometry geometry = new LineString(
[3.198, 43.164],
[6.713, 49.755],
[9.702, 42.592],
[15.32, 53.798]
)
GooglePolylineEncoder encoder = new GooglePolylineEncoder()
String str = encoder.write(geometry)
println str_nmfGoroRwhfg@womTv_vj@gxfQotkcAogha@
Bounds Recipes
The Bounds class is in the geoscript.geom package.
Creating Bounds
Create a Bounds from four coordinates (minx, miny, maxx, maxy) and a projection.
Bounds bounds = new Bounds(-127.265, 43.068, -113.554, 50.289, "EPSG:4326")
Create a Bounds from four coordinates (minx, miny, maxx, maxy) without a projection. The projection can be set later.
Bounds bounds = new Bounds(-127.265, 43.068, -113.554, 50.289)
bounds.proj = new Projection("EPSG:4326")
Create a Bounds from a string with commas delimiting minx, miny, maxx, maxy and projection values.
Bounds bounds = Bounds.fromString("-127.265,43.068,-113.554,50.289,EPSG:4326")
Create a Bounds from a string with spaces delimiting minx, miny, maxx, maxy and projection values.
Bounds bounds = Bounds.fromString("12.919921874999998 40.84706035607122 15.99609375 41.77131167976407 EPSG:4326")
Getting Bounds Properties
Create a Bounds and view it’s string representation
Bounds bounds = new Bounds(-127.265, 43.068, -113.554, 50.289, "EPSG:4326")
String boundsStr = bounds.toString()
println boundsStr(-127.265,43.068,-113.554,50.289,EPSG:4326)
Get the minimum x coordinate
double minX = bounds.minX
println minX-127.265
Get the minimum y coordinate
double minY = bounds.minY
println minY43.068
Get the maximum x coordinate
double maxX = bounds.maxX
println maxX-113.554
Get the maximum y coordinate
double maxY = bounds.maxY
println maxY50.289
Get the Projection
Projection proj = bounds.proj
println proj.idEPSG:4326
Get the area
double area = bounds.area
println area99.00713100000004
Get the width
double width = bounds.width
println width13.710999999999999
Get the height
double height = bounds.height
println height7.221000000000004
Get the aspect ratio
double aspect = bounds.aspect
println aspect1.8987674837280144
A Bounds is not a Geometry but you can get a Geometry from a Bounds
Bounds bounds = new Bounds(-122.485, 47.246, -122.452, 47.267, "EPSG:4326")
Geometry geometry = bounds.geometry
You can also get a Polygon from a Bounds
Bounds bounds = new Bounds(-122.485, 47.246, -122.452, 47.267, "EPSG:4326")
Polygon polygon = bounds.polygon
Get the four corners from a Bounds as a List of Points
Bounds bounds = new Bounds(-122.485, 47.246, -122.452, 47.267, "EPSG:4326")
List<Point> points = bounds.corners
Processing Bounds
Reproject a Bounds from one Projection to another.
Bounds bounds = new Bounds(-122.485, 47.246, -122.452, 47.267, "EPSG:4326")
println bounds(-122.485,47.246,-122.452,47.267,EPSG:4326)
Bounds reprojectedBounds = bounds.reproject("EPSG:2927")
println reprojectedBounds(1147444.7684517875,703506.2231641772,1155828.1202425088,711367.9403610165,EPSG:2927)
Expand a Bounds by a given distance
Bounds bounds1 = new Bounds(-127.265, 43.068, -113.554, 50.289, "EPSG:4326")
Bounds bounds2 = new Bounds(-127.265, 43.068, -113.554, 50.289, "EPSG:4326")
bounds2.expandBy(10.1)
Expand a Bounds to include another Bounds
Bounds bounds1 = new Bounds(8.4375, 37.996162679728116, 19.6875, 46.07323062540835, "EPSG:4326")
Bounds bounds2 = new Bounds(22.5, 31.952162238024975, 30.937499999999996, 37.43997405227057, "EPSG:4326")
bounds1.expand(bounds2)
Scale an existing Bounds some distance to create a new Bounds
Bounds bounds1 = new Bounds(-127.265, 43.068, -113.554, 50.289, "EPSG:4326")
Bounds bounds2 = bounds1.scale(2)
Divide a Bounds into smaller tiles or Bounds
Bounds bounds = new Bounds(-122.485, 47.246, -122.452, 47.267, "EPSG:4326")
List<Bounds> subBounds = bounds.tile(0.25)
Calculate a quad tree for this Bounds between the start and stop levels. A Closure is called for each new Bounds generated.
Bounds bounds = new Bounds(-180, -90, 180, 90, "EPSG:4326")
bounds.quadTree(0,2) { Bounds b ->
println b
}(-180.0,-90.0,180.0,90.0,EPSG:4326) (-180.0,-90.0,0.0,0.0,EPSG:4326) (-180.0,0.0,0.0,90.0,EPSG:4326) (0.0,-90.0,180.0,0.0,EPSG:4326) (0.0,0.0,180.0,90.0,EPSG:4326)
Determine whether a Bounds is empty or not. A Bounds is empty if it is null or it’s area is 0.
Bounds bounds = new Bounds(0,10,10,20)
println bounds.isEmpty()false
Bounds emptyBounds = new Bounds(0,10,10,10)
println emptyBounds.isEmpty()true
Determine if a Bounds contains another Bounds
Bounds bounds1 = new Bounds(-107.226, 34.597, -92.812, 43.068)
Bounds bounds2 = new Bounds(-104.326, 37.857, -98.349, 40.913)
println bounds1.contains(bounds2)
true
Bounds bounds3 = new Bounds(-112.412, 36.809, -99.316, 44.777)
println bounds1.contains(bounds3)
false
Determine if a Bounds contains a Point
Bounds bounds = new Bounds(-107.226, 34.597, -92.812, 43.068)
Point point1 = new Point(-95.976, 39.639)
println bounds.contains(point1)
true
Point point2 = new Point(-89.384, 38.959)
println bounds.contains(point2)
true
Determine if two Bounds intersect
Bounds bounds1 = new Bounds(-95.885, 46.765, -95.788, 46.811)
Bounds bounds2 = new Bounds(-95.847, 46.818, -95.810, 46.839)
println bounds1.intersects(bounds2)
false
Bounds bounds3 = new Bounds(-95.904, 46.747, -95.839, 46.792)
println bounds1.intersects(bounds3)
true
Calculate the intersection between two Bounds
Bounds bounds1 = new Bounds(-95.885, 46.765, -95.788, 46.811)
Bounds bounds2 = new Bounds(-95.904, 46.747, -95.839, 46.792)
Bounds bounds3 = bounds1.intersection(bounds2)
Generate a grid from a Bounds with a given number of columns and rows and the polygon shape. Other shapes include: polygon, point, circle/ellipse, hexagon, hexagon-inv).
Bounds bounds = new Bounds(-180,-90,180,90,"EPSG:4326")
Geometry geometry = bounds.getGrid(5,4,"polygon")
Generate a grid from a Bounds with a given number of columns and rows and a point shape. A Closure that is called with a geometry, column, and row for each grid cell that is created.
Bounds bounds = new Bounds(-180,-90,180,90,"EPSG:4326")
List geometries = []
Geometry geometry = bounds.generateGrid(10,8,"point") { Geometry g, int col, int row ->
geometries.add(g)
}
Generate a grid from a Bounds with a given cell width and height and a circle/ellipse shape.
Bounds bounds = new Bounds(-180,-90,180,90,"EPSG:4326")
Geometry geometry = bounds.getGrid(72.0,72.0,"circle")
Generate a grid from a Bounds with a given cell width and height and a hexagon shape. A Closure is called with a geometry, column, and row for each grid cell generated.
Bounds bounds = new Bounds(-180,-90,180,90,"EPSG:4326")
List geometries = []
Geometry geometry = bounds.generateGrid(72.0,72.0,"hexagon") { Geometry g, int col, int row ->
geometries.add(g)
}
Generate a grid from a Bounds with a given cell width and height and an inverted hexagon shape.
Bounds bounds = new Bounds(-180,-90,180,90,"EPSG:4326")
Geometry geometry = bounds.getGrid(5,5,"hexagon-inv")
Generate a grid from a Bounds with a given cell width and height and a triangle shape.
Bounds bounds = new Bounds(-180,-90,180,90,"EPSG:4326")
Geometry geometry = bounds.getGrid(5,5,"triangle")
Create a rectangle from a Bounds with a given number of Points and a rotation angle in radians.
Bounds bounds = new Bounds(0,0,20,20)
Polygon polygon = bounds.createRectangle(20,Math.toRadians(45))
Create an ellipse from a Bounds. The default number of points is 20 and the default rotation angle in radians is 0.
Bounds bounds = new Bounds(0,0,20,20)
Polygon polygon = bounds.createEllipse()
Create a squircle from a Bounds. The default number of points is 20 and the default rotation angle in radians is 0.
Bounds bounds = new Bounds(0,0,20,20)
Polygon polygon = bounds.createSquircle()
Create a super circle from a Bounds with a given power. The default number of points is 20 and the default rotation angle in radians is 0.
Bounds bounds = new Bounds(0,0,20,20)
Polygon polygon = bounds.createSuperCircle(1.75)
Create an arc from a Bounds with a start angle and angle extent. The default number of points is 20 and the default rotation angle in radians is 0.
Bounds bounds = new Bounds(0,0,20,20)
LineString lineString = bounds.createArc(Math.toRadians(45), Math.toRadians(90))
Create an arc polygon from a Bounds with a start angle and angle extent. The default number of points is 20 and the default rotation angle in radians is 0.
Bounds bounds = new Bounds(0,0,20,20)
Polygon polygon = bounds.createArcPolygon(Math.toRadians(45), Math.toRadians(90))
Create a sine star from a Bounds with a number of arms and an arm length ratio. The default number of points is 20 and the default rotation angle in radians is 0.
Bounds bounds = new Bounds(0,0,20,20)
Polygon polygon = bounds.createSineStar(5, 2.3)
Create a hexagon from a Bounds that is either inverted (false) or not (true).
Bounds bounds = new Bounds(0,0,20,20)
Polygon polygon = bounds.createHexagon(false)
Projection Recipes
The Projection classes are in the geoscript.proj package.
Creating Projections
Create a Projection from an EPSG Code
Projection proj = new Projection("EPSG:4326")
println proj.wktGEOGCS["WGS 84",
DATUM["World Geodetic System 1984",
SPHEROID["WGS 84", 6378137.0, 298.257223563, AUTHORITY["EPSG","7030"]],
AUTHORITY["EPSG","6326"]],
PRIMEM["Greenwich", 0.0, AUTHORITY["EPSG","8901"]],
UNIT["degree", 0.017453292519943295],
AXIS["Geodetic longitude", EAST],
AXIS["Geodetic latitude", NORTH],
AUTHORITY["EPSG","4326"]]
Create a Projection from a WKT Projection String
Projection proj = new Projection("""GEOGCS["WGS 84",
DATUM["World Geodetic System 1984",
SPHEROID["WGS 84", 6378137.0, 298.257223563, AUTHORITY["EPSG","7030"]],
AUTHORITY["EPSG","6326"]],
PRIMEM["Greenwich", 0.0, AUTHORITY["EPSG","8901"]],
UNIT["degree", 0.017453292519943295],
AXIS["Geodetic longitude", EAST],
AXIS["Geodetic latitude", NORTH],
AUTHORITY["EPSG","4326"]]""")GEOGCS["WGS 84",
DATUM["World Geodetic System 1984",
SPHEROID["WGS 84", 6378137.0, 298.257223563, AUTHORITY["EPSG","7030"]],
AUTHORITY["EPSG","6326"]],
PRIMEM["Greenwich", 0.0, AUTHORITY["EPSG","8901"]],
UNIT["degree", 0.017453292519943295],
AXIS["Geodetic longitude", EAST],
AXIS["Geodetic latitude", NORTH],
AUTHORITY["EPSG","4326"]]
Create a Projection from well known name
Projection proj = new Projection("Mollweide")
println proj.wktPROJCS["Mollweide",
GEOGCS["WGS84",
DATUM["WGS84",
SPHEROID["WGS84", 6378137.0, 298.257223563]],
PRIMEM["Greenwich", 0.0],
UNIT["degree", 0.017453292519943295],
AXIS["Longitude", EAST],
AXIS["Latitude", NORTH]],
PROJECTION["Mollweide"],
PARAMETER["semi-minor axis", 6378137.0],
PARAMETER["False easting", 0.0],
PARAMETER["False northing", 0.0],
PARAMETER["Longitude of natural origin", 0.0],
UNIT["m", 1.0],
AXIS["Easting", EAST],
AXIS["Northing", NORTH]]
Get a List of all supported Projections (this is really slow)
List<Projection> projections = Projection.projections()EPSG:4326 EPSG:4269 EPSG:26918 EPSG:2263 EPSG:2927 ...
Getting Projection Properties
Get the id
Projection proj = new Projection("EPSG:4326")
String id = proj.idEPSG:4326
Get the srs
String srs = proj.srsEPSG:4326
Get the epsg code
int epsg = proj.epsg4326
Get the WKT
String wkt = proj.wktGEOGCS["WGS 84",
DATUM["World Geodetic System 1984",
SPHEROID["WGS 84", 6378137.0, 298.257223563, AUTHORITY["EPSG","7030"]],
AUTHORITY["EPSG","6326"]],
PRIMEM["Greenwich", 0.0, AUTHORITY["EPSG","8901"]],
UNIT["degree", 0.017453292519943295],
AXIS["Geodetic longitude", EAST],
AXIS["Geodetic latitude", NORTH],
AUTHORITY["EPSG","4326"]]
Get the Bounds in the native Projection
Bounds bounds = proj.bounds(-180.0,-90.0,180.0,90.0,EPSG:4326)
Get the Bounds in the EPSG:4326
Bounds geoBounds = proj.geoBounds(-180.0,-90.0,180.0,90.0,EPSG:4326)
Using Projections
Transform a Geometry from one projection to another using the Projection static method with strings
Geometry epsg4326Geom = new Point(-122.440, 47.245)
Geometry epsg2927Geom = Projection.transform(epsg4326Geom, "EPSG:4326", "EPSG:2927")
println epsg2927GeomPOINT (1158609.2040371667 703068.0661327888)
Transform a Geometry from one projection to another using the Projection static method with Projections
Projection epsg4326 = new Projection("EPSG:4326")
Projection epsg2927 = new Projection("EPSG:2927")
Geometry epsg4326Geom = new Point(-122.440, 47.245)
Geometry epsg2927Geom = Projection.transform(epsg4326Geom, epsg4326, epsg2927)
println epsg2927GeomPOINT (1158609.2040371667 703068.0661327888)
Transform a Geometry from one projection to another using two Projections
Projection fromProj = new Projection("EPSG:4326")
Projection toProj = new Projection("EPSG:2927")
Geometry geom = new Point(-122.440, 47.245)
Geometry projectedGeom = fromProj.transform(geom, toProj)
println projectedGeomPOINT (1158609.2040371667 703068.0661327888)
Transform a Geometry from one projection to another using a Projections and a String
Projection fromProj = new Projection("EPSG:4326")
Geometry geom = new Point(-122.440, 47.245)
Geometry projectedGeom = fromProj.transform(geom, "EPSG:2927")
println projectedGeomPOINT (1158609.2040371667 703068.0661327888)
Using Geodetic
Create a Geodetic object with an ellipsoid
Geodetic geodetic = new Geodetic("wgs84")
println geodeticGeodetic [SPHEROID["WGS 84", 6378137.0, 298.257223563]]
Calculate the forward and back azimuth and distance between the given two Points.
Geodetic geodetic = new Geodetic("clrk66")
Point bostonPoint = new Point(-71.117, 42.25)
Point portlandPoint = new Point(-123.683, 45.52)
Map results = geodetic.inverse(bostonPoint, portlandPoint)
double forwardAzimuth = results.forwardAzimuth
println forwardAzimuth-66.52547810974724
double backAzimuth = results.backAzimuth
println backAzimuth75.6581745719509
double distance = results.distance
println distance4164050.459880065
Calculate a new Point and back azimuth given the starting Point, azimuth, and distance.
Geodetic geodetic = new Geodetic("clrk66")
Point bostonPoint = new Point(-71.117, 42.25)
Map results = geodetic.forward(bostonPoint, -66.531, 4164192.708)
Point point = results.point
println pointPOINT (-123.6835797667373 45.516427795897236)
double azimuth = results.backAzimuth
println azimuth75.65337425050724
Place the given number of points between starting and ending Points
Geodetic geodetic = new Geodetic("clrk66")
Point bostonPoint = new Point(-71.117, 42.25)
Point portlandPoint = new Point(-123.683, 45.52)
List<Point> points = geodetic.placePoints(bostonPoint, portlandPoint, 10)
points.each { Point point ->
println point.wkt
}POINT (-75.41357382496236 43.52791689304305) POINT (-79.8828640042499 44.63747566950249) POINT (-84.51118758826816 45.565540142641) POINT (-89.27793446221685 46.300124344169255) POINT (-94.15564606698499 46.83102721803566) POINT (-99.11079892605703 47.15045006457598) POINT (-104.10532353179985 47.25351783423774) POINT (-109.09873812691619 47.13862709798195) POINT (-114.05062990603696 46.80756425557423) POINT (-118.92312608779855 46.26537395700513)
Using Decimal Degrees
Create a new DecimalDegrees from a longitude and latitude
DecimalDegrees decimalDegrees = new DecimalDegrees(-122.525619, 47.212023)
println decimalDegrees-122° 31' 32.2284" W, 47° 12' 43.2828" N
Create a new DecimalDegrees from a Point
DecimalDegrees decimalDegrees = new DecimalDegrees(new Point(-122.525619,47.212023))
println decimalDegreesPOINT (-122.52561944444444 47.212022222222224)
Create a new DecimalDegrees from a Longitude and Latitude string
DecimalDegrees decimalDegrees = new DecimalDegrees("-122.525619, 47.212023")
println decimalDegrees-122° 31' 32.2284" W, 47° 12' 43.2828" N
Create a new DecimalDegrees from two strings with glyphs
DecimalDegrees decimalDegrees = new DecimalDegrees("122\u00B0 31' 32.23\" W", "47\u00B0 12' 43.28\" N")
println decimalDegrees-122° 31' 32.2300" W, 47° 12' 43.2800" N
Create a new DecimalDegrees from two strings
DecimalDegrees decimalDegrees = new DecimalDegrees("122d 31m 32.23s W", "47d 12m 43.28s N")
println decimalDegrees-122° 31' 32.2300" W, 47° 12' 43.2800" N
Create a new DecimalDegrees from a single Degrees Minutes Seconds formatted string
DecimalDegrees decimalDegrees = new DecimalDegrees("122d 31m 32.23s W, 47d 12m 43.28s N")
println decimalDegrees-122° 31' 32.2300" W, 47° 12' 43.2800" N
Create a new DecimalDegrees from a single Decimal Degree Minutes formatted string with glyphs
DecimalDegrees decimalDegrees = new DecimalDegrees("122\u00B0 31.5372' W, 47\u00B0 12.7213' N")
println decimalDegrees-122° 31' 32.2320" W, 47° 12' 43.2780" N
Create a new DecimalDegrees from a single Decimal Degree Minutes formatted string
DecimalDegrees decimalDegrees = new DecimalDegrees("122d 31.5372m W, 47d 12.7213m N")
println decimalDegrees-122° 31' 32.2320" W, 47° 12' 43.2780" N
Get degrees minutes seconds from a DecimalDegrees object
DecimalDegrees decimalDegrees = new DecimalDegrees("122d 31m 32.23s W", "47d 12m 43.28s N")
Map dms = decimalDegrees.dms
println "Degrees: ${dms.longitude.degrees}"
println "Minutes: ${dms.longitude.minutes}"
println "Seconds: ${dms.longitude.seconds}"Degrees: -122 Minutes: 31 Seconds: 32.22999999998388
println "Degrees: ${dms.latitude.degrees}"
println "Minutes: ${dms.latitude.minutes}"
println "Seconds: ${dms.latitude.seconds}"Degrees: 47 Minutes: 12 Seconds: 43.280000000006396
Convert a DecimalDegrees object to a DMS String with glyphs
DecimalDegrees decimalDegrees = new DecimalDegrees("122d 31m 32.23s W", "47d 12m 43.28s N")
println decimalDegrees.toDms(true)-122° 31' 32.2300" W, 47° 12' 43.2800" N
Convert a DecimalDegrees object to a DMS String without glyphs
println decimalDegrees.toDms(false)-122d 31m 32.2300s W, 47d 12m 43.2800s N
Get degrees minutes from a DecimalDegrees object
DecimalDegrees decimalDegrees = new DecimalDegrees("122d 31m 32.23s W", "47d 12m 43.28s N")
Map dms = decimalDegrees.ddm
println "Degrees: ${dms.longitude.degrees}"
println "Minutes: ${dms.longitude.minutes}"Degrees: -122 Minutes: 31.537166666666398
println "Degrees: ${dms.latitude.degrees}"
println "Minutes: ${dms.latitude.minutes}"Degrees: 47 Minutes: 12.72133333333344
Convert a DecimalDegrees object to a DDM String with glyphs
DecimalDegrees decimalDegrees = new DecimalDegrees("122d 31m 32.23s W", "47d 12m 43.28s N")
println decimalDegrees.toDdm(true)-122° 31.5372' W, 47° 12.7213' N
Convert a DecimalDegrees object to a DDM String without glyphs
println decimalDegrees.toDdm(false)-122d 31.5372m W, 47d 12.7213m N
Get a Point from a DecimalDegrees object
DecimalDegrees decimalDegrees = new DecimalDegrees("122d 31m 32.23s W", "47d 12m 43.28s N")
Point point = decimalDegrees.pointPOINT (-122.52561944444444 47.212022222222224)
Spatial Index Recipes
The Index classes are in the geoscript.index package.
Using STRtree
Create a STRtree spatial index
STRtree index = new STRtree()Insert Geometries and their Bounds
index.insert(new Bounds(0,0,10,10), new Point(5,5))
index.insert(new Bounds(2,2,6,6), new Point(4,4))
index.insert(new Bounds(20,20,60,60), new Point(30,30))
index.insert(new Bounds(22,22,44,44), new Point(32,32))Get the size of the index
int size = index.size
println size4
Query the index
List results = index.query(new Bounds(1,1,5,5))
results.each { Geometry geometry ->
println geometry
}POINT (4 4) POINT (5 5)
Using Quadtree
Create a Quadtree spatial index
Quadtree index = new Quadtree()Insert Geometries and their Bounds
index.insert(new Bounds(0,0,10,10), new Point(5,5))
index.insert(new Bounds(2,2,6,6), new Point(4,4))
index.insert(new Bounds(20,20,60,60), new Point(30,30))
index.insert(new Bounds(22,22,44,44), new Point(32,32))Get the size of the index
int size = index.size
println size4
Query the index with a Bounds
List results = index.query(new Bounds(1,1,5,5))
results.each { Geometry geometry ->
println geometry
}POINT (30 30) POINT (32 32) POINT (5 5) POINT (4 4)
Query the entire index
List allResults = index.queryAll()
allResults.each { Geometry geometry ->
println geometry
}POINT (30 30) POINT (32 32) POINT (5 5) POINT (4 4)
Remove an item from the index
Geometry itemToRemove = allResults[0]
boolean removed = index.remove(itemToRemove.bounds, itemToRemove)
println "Removed? ${removed}"
println "Size = ${index.size}"Removed = true Size = 3
Using GeoHash
Encode a Point as a String
GeoHash geohash = new GeoHash()
Point point = new Point(112.5584, 37.8324)
String hash = geohash.encode(point)
println hashww8p1r4t8
Decode a Point from a String
GeoHash geohash = new GeoHash()
Point point = geohash.decode("ww8p1r4t8")
println pointPOINT (112.55838632583618 37.83238649368286)
Encode a Point as a Long
GeoHash geohash = new GeoHash()
Point point = new Point(112.5584, 37.8324)
long hash = geohash.encodeLong(point)
println long4064984913515641
Decode a Point from a Long
GeoHash geohash = new GeoHash()
Point point = geohash.decode(4064984913515641)
println pointPOINT (112.55839973688126 37.83240124583244)
Decode a Bounds from a String
GeoHash geohash = new GeoHash()
Bounds bounds = geohash.decodeBounds("ww8p1r4t8")
println bounds(112.55836486816406,37.83236503601074,112.5584077835083,37.83240795135498)
Decode a Bounds from a Long
GeoHash geohash = new GeoHash()
Bounds bounds = geohash.decodeBounds(4064984913515641)
println bounds(112.55836486816406,37.83236503601074,112.5584077835083,37.83240795135498)
Find neighboring geohash strings
GeoHash geohash = new GeoHash()
String hash = "dqcjq"
String north = geohash.neighbor(hash, GeoHash.Direction.NORTH)
String northwest = geohash.neighbor(hash, GeoHash.Direction.NORTHWEST)
String west = geohash.neighbor(hash, GeoHash.Direction.WEST)
String southwest = geohash.neighbor(hash, GeoHash.Direction.SOUTHWEST)
String south = geohash.neighbor(hash, GeoHash.Direction.SOUTH)
String southeast = geohash.neighbor(hash, GeoHash.Direction.SOUTHEAST)
String east = geohash.neighbor(hash, GeoHash.Direction.EAST)
String northeast = geohash.neighbor(hash, GeoHash.Direction.NORTHEAST)
String str = """
| ${northwest} ${north} ${northeast}
| ${west} ${hash} ${east}
| ${southwest} ${south} ${southeast}
|""".stripMargin()
println strdqcjt dqcjw dqcjx dqcjm dqcjq dqcjr dqcjj dqcjn dqcjp
Find neighboring geohash longs
GeoHash geohash = new GeoHash()
long hash = 1702789509
long north = geohash.neighbor(hash, GeoHash.Direction.NORTH)
long northwest = geohash.neighbor(hash, GeoHash.Direction.NORTHWEST)
long west = geohash.neighbor(hash, GeoHash.Direction.WEST)
long southwest = geohash.neighbor(hash, GeoHash.Direction.SOUTHWEST)
long south = geohash.neighbor(hash, GeoHash.Direction.SOUTH)
long southeast = geohash.neighbor(hash, GeoHash.Direction.SOUTHEAST)
long east = geohash.neighbor(hash, GeoHash.Direction.EAST)
long northeast = geohash.neighbor(hash, GeoHash.Direction.NORTHEAST)
String str = """
| ${northwest} ${north} ${northeast}
| ${west} ${hash} ${east}
| ${southwest} ${south} ${southeast}
|""".stripMargin()
println str1702789434 1702789520 1702789522 1702789423 1702789509 1702789511 1702789422 1702789508 1702789510
Find all neighboring geohash strings
GeoHash geohash = new GeoHash()
String hash = "dqcjq"
Map neighbors = geohash.neighbors(hash)
String north = neighbors[GeoHash.Direction.NORTH]
String northwest = neighbors[GeoHash.Direction.NORTHWEST]
String west = neighbors[GeoHash.Direction.WEST]
String southwest = neighbors[GeoHash.Direction.SOUTHWEST]
String south = neighbors[GeoHash.Direction.SOUTH]
String southeast = neighbors[GeoHash.Direction.SOUTHEAST]
String east = neighbors[GeoHash.Direction.EAST]
String northeast = neighbors[GeoHash.Direction.NORTHEAST]
String str = """
| ${northwest} ${north} ${northeast}
| ${west} ${hash} ${east}
| ${southwest} ${south} ${southeast}
|""".stripMargin()
println strdqcjt dqcjw dqcjx dqcjm dqcjq dqcjr dqcjj dqcjn dqcjp
Find all neighboring geohash longs
GeoHash geohash = new GeoHash()
long hash = 1702789509
Map neighbors = geohash.neighbors(hash)
long north = neighbors[GeoHash.Direction.NORTH]
long northwest = neighbors[GeoHash.Direction.NORTHWEST]
long west = neighbors[GeoHash.Direction.WEST]
long southwest = neighbors[GeoHash.Direction.SOUTHWEST]
long south = neighbors[GeoHash.Direction.SOUTH]
long southeast = neighbors[GeoHash.Direction.SOUTHEAST]
long east = neighbors[GeoHash.Direction.EAST]
long northeast = neighbors[GeoHash.Direction.NORTHEAST]
String str = """
| ${northwest} ${north} ${northeast}
| ${west} ${hash} ${east}
| ${southwest} ${south} ${southeast}
|""".stripMargin()
println str1702789434 1702789520 1702789522 1702789423 1702789509 1702789511 1702789422 1702789508 1702789510
Find all geohashes as strings within a Bounds
GeoHash geohash = new GeoHash()
List<String> bboxes = geohash.bboxes(new Bounds(120, 30, 120.0001, 30.0001), 8)
bboxes.each { String hash ->
println hash
}wtm6dtm6 wtm6dtm7
Find all geohashes as longs within a Bounds
GeoHash geohash = new GeoHash()
List<Long> bboxes = geohash.bboxesLong(new Bounds(120, 30, 120.0001, 30.0001), 40)
bboxes.each { long hash ->
println hash
}989560464998 989560464999
Viewer Recipes
The Viewer classes are in the geoscript.viewer package.
Drawing geometries
Draw a geometry in a simple GUI
Polygon polygon = new Polygon([[
[-101.35986328125, 47.754097979680026],
[-101.5576171875, 46.93526088057719],
[-100.12939453125, 46.51351558059737],
[-99.77783203125, 47.44294999517949],
[-100.45898437499999, 47.88688085106901],
[-101.35986328125, 47.754097979680026]
]])
Viewer.draw(polygon)
Draw a geometry to an image
Polygon polygon = new Polygon([[
[-101.35986328125, 47.754097979680026],
[-101.5576171875, 46.93526088057719],
[-100.12939453125, 46.51351558059737],
[-99.77783203125, 47.44294999517949],
[-100.45898437499999, 47.88688085106901],
[-101.35986328125, 47.754097979680026]
]])
BufferedImage image = Viewer.drawToImage(polygon)
Draw a geometry to an image with options
Polygon polygon = new Polygon([[
[-101.35986328125, 47.754097979680026],
[-101.5576171875, 46.93526088057719],
[-100.12939453125, 46.51351558059737],
[-99.77783203125, 47.44294999517949],
[-100.45898437499999, 47.88688085106901],
[-101.35986328125, 47.754097979680026]
]])
BufferedImage image = Viewer.drawToImage(
polygon,
size: [200,200],
drawCoords: true,
fillCoords: true,
fillPolys: true
)
Draw a List of geometries to an image
Point point = new Point(-123.11, 47.23)
Geometry buffer = point.buffer(4)
Geometry bounds = buffer.bounds.geometry
BufferedImage image = Viewer.drawToImage(
[bounds, buffer, point],
size: [200,200],
drawCoords: true,
fillCoords: true,
fillPolys: true
)
Draw a List of Geometries to a File
Point point = new Point(-123.11, 47.23)
Geometry buffer = point.buffer(4)
File file = new File("geometry.png")
Viewer.drawToFile([buffer, point], file, size: [200,200])
Plotting geometries
Plot a geometry in a simple GUI
Polygon polygon = new Polygon([[
[-101.35986328125, 47.754097979680026],
[-101.5576171875, 46.93526088057719],
[-100.12939453125, 46.51351558059737],
[-99.77783203125, 47.44294999517949],
[-100.45898437499999, 47.88688085106901],
[-101.35986328125, 47.754097979680026]
]])
Viewer.plot(polygon)
Plot a Geometry to an image
Polygon polygon = new Polygon([[
[-101.35986328125, 47.754097979680026],
[-101.5576171875, 46.93526088057719],
[-100.12939453125, 46.51351558059737],
[-99.77783203125, 47.44294999517949],
[-100.45898437499999, 47.88688085106901],
[-101.35986328125, 47.754097979680026]
]])
BufferedImage image = Viewer.plotToImage(polygon)
Plot a List of Geometries to an image
Point point = new Point(-123.11, 47.23)
Geometry buffer = point.buffer(4)
Geometry bounds = buffer.bounds.geometry
BufferedImage image = Viewer.plotToImage(
[bounds, buffer, point],
size: [300,300],
drawCoords: true,
fillCoords: true,
fillPolys: true
)
Plot a Geometry to a File
Point point = new Point(-123.11, 47.23)
Geometry buffer = point.buffer(4)
File file = new File("geometry.png")
Viewer.plotToFile([buffer, point], file, size: [300,300])
Plot Recipes
The Plot classes are in the geoscript.plot package.
Processing Charts
Show a chart in a GUI
List data = [
[1,10],[45,12],[23,3],[5,20]
]
Chart chart = Bar.xy(data)
Get an image from a chart
Map data = [
"A":20,"B":45,"C":2,"D":14
]
Chart chart = Pie.pie(data)
BufferedImage image = chart.image
Save a chart to a file
Map data = [
"A":[1,10,20],
"B":[45,39,10],
"C":[40,30,20],
"D":[14,25,19]
]
Chart chart = Box.box(data)
File file = new File("chart.png")
chart.save(file)
Overlay multiple charts
List data = [
[1,10],[45,12],[23,3],[5,20]
]
Chart chart1 = Bar.xy(data)
Chart chart2 = Curve.curve(data)
Chart chart3 = Regression.linear(data)
chart1.overlay([chart2,chart3])
Creating Bar Charts
Create a basic bar chart
List data = [
[1,10],[45,12],[23,3],[5,20]
]
Chart chart = Bar.xy(data)
Create a bar chart with categories
Map data = [
"A":20,"B":45,"C":2,"D":14
]
Chart chart = Bar.category(data)
Create a stacked bar chart with two series of data
Map data = [
"A": ["B":50,"C":25,"D":25],
"F": ["G":75,"H":10,"I":15]
]
Chart chart = Bar.category(data, stacked: true)
Create a 3D bar chart with categories
Map data = [
"A":20,"B":45,"C":2,"D":14
]
Chart chart = Bar.category(data, trid: true)
Creating Pie Charts
Create a pie chart
Map data = [
"A":20,"B":45,"C":2,"D":14
]
Chart chart = Pie.pie(data)
Create a 3D pie chart
Map data = [
"A":20,"B":45,"C":2,"D":14
]
Chart chart = Pie.pie(data, trid: true)
Creating Box Charts
Create a box chart
Map data = [
"A":[1,10,20],
"B":[45,39,10],
"C":[40,30,20],
"D":[14,25,19]
]
Chart chart = Box.box(data)
Creating Curve Charts
Create a curve chart
List data = [
[1,10],[45,12],[23,3],[5,20]
]
Chart chart = Curve.curve(data)
Create a smooth curve chart
List data = [
[1,10],[45,12],[23,3],[5,20]
]
Chart chart = Curve.curve(data, smooth: true)
Create a 3D curve chart
List data = [
[1,10],[45,12],[23,3],[5,20]
]
Chart chart = Curve.curve(data, trid: true)
Creating Regression Charts
Create a linear regression chart
MultiPoint mulitPoint = Geometry.createRandomPoints(new Bounds(0,0,100,100).geometry, 10)
List data = mulitPoint.geometries.collect{ Point pt ->
[pt.x, pt.y]
}
Chart chart = Regression.linear(data)
Create a power regression chart
MultiPoint mulitPoint = Geometry.createRandomPoints(new Bounds(0,0,100,100).geometry, 10)
List data = mulitPoint.geometries.collect{ Point pt ->
[pt.x, pt.y]
}
Chart chart = Regression.power(data)
Creating Scatter Plot Charts
Create a scatter plot chart
MultiPoint mulitPoint = Geometry.createRandomPoints(new Bounds(0,0,100,100).geometry, 10)
List data = mulitPoint.geometries.collect{ Point pt ->
[pt.x, pt.y]
}
Chart chart = Scatter.scatterplot(data)
Create a scatter plot chart with options
MultiPoint mulitPoint = Geometry.createRandomPoints(new Bounds(0,0,100,100).geometry, 10)
List data = mulitPoint.geometries.collect{ Point pt ->
[pt.x, pt.y]
}
Chart chart = Scatter.scatterplot(data, legend: false, xLabel: "X Coordinates", yLabel: "Y Coordinates")
Feature Recipes
The Feature classes are in the geoscript.feature package.
Creating Fields
Create a Field with a name and a type
Field field = new Field("name", "String")
println fieldname: String
Create a Geometry Field with a name and a geometry type and an optional projection
Field field = new Field("geom", "Point", "EPSG:4326")
println fieldgeom: Point(EPSG:4326)
Create a Field with a List of Strings (name, type, projection)
Field field = new Field(["geom", "Polygon", "EPSG:4326"])
println fieldgeom: Polygon(EPSG:4326)
Create a Field from a Map where keys are name, type, proj
Field field = new Field([
"name": "geom",
"type": "LineString",
"proj": new Projection("EPSG:4326")
])
println fieldgeom: LineString(EPSG:4326)
Access a Field’s properties
Field field = new Field("geom", "Point", "EPSG:4326")
println "Name = ${field.name}"
println "Type = ${field.typ}"
println "Projection = ${field.proj}"
println "Is Geometry = ${field.geometry}"Name = geom Type = Point Projection = "EPSG:4326 Is Geometry = true
Creating Schemas
Create a Schema from a list of Fields
Schema schema = new Schema("cities", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String")
])
println schemacities geom: Point(EPSG:4326), id: Integer, name: String
Create a Schema from a list of Lists
Schema schema = new Schema("cities", [
["geom", "Point", "EPSG:4326"],
["id", "Integer"],
["name", "String"]
])
println schemacities geom: Point(EPSG:4326), id: Integer, name: String
Create a Schema from a list of Maps
Schema schema = new Schema("cities", [
[name: "geom", type: "Point", proj: "EPSG:4326"],
[name: "id", type: "Integer"],
[name: "name", type: "String"]
])
println schemacities geom: Point(EPSG:4326), id: Integer, name: String
Create a Schema from a string
Schema schema = new Schema("cities", "geom:Point:srid=4326,id:Integer,name:String")
println schemacities geom: Point(EPSG:4326), id: Integer, name: String
Getting Schema Properties
Get the Schema’s name
Schema schema = new Schema("cities", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String")
], "https://github.com/jericks/geoscript-groovy-cookbook")
String name = schema.name
println namecities
Get the Schema’s geometry Field
Field geomField = schema.geom
println geomFieldgeom: Point(EPSG:4326)
Get the Schema’s Projection
Projection proj = schema.proj
println projEPSG:4326
Get the Schema’s URI
String uri = schema.uri
println urihttps://github.com/jericks/geoscript-groovy-cookbook
Get the Schema’s specification string
String spec = schema.spec
println specgeom:Point:srid=4326,id:Integer,name:String
Getting Schema Fields
Get the Schema’s Fields
Schema schema = new Schema("cities", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String")
])
List<Field> fields = schema.fields
fields.each { Field field ->
println field
}geom: Point(EPSG:4326) id: Integer name: String
Get a Field
Field nameField = schema.field("name")
println nameFieldname: String
Get a Field
Field idField = schema.get("id")
println idFieldid: Integer
Check if a Schema has a Field
boolean hasArea = schema.has("area")
println "Has area Field? ${hasArea}"
boolean hasGeom = schema.has("geom")
println "Has geom Field? ${hasGeom}"false true
Modifying Schemas
Change the projection of a Schema
Schema schema = new Schema("cities", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String")
])
Schema reprojectedSchema = schema.reproject("EPSG:2927", "cities_spws")cities_spws geom: Point(EPSG:2927), id: Integer, name: String
Change the geometry type of a Schema
Schema schema = new Schema("cities", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String")
])
Schema polyognSchema = schema.changeGeometryType("Polygon", "cities_buffer")cities_buffer geom: Polygon(EPSG:4326), id: Integer, name: String
Change a Field definition of a Schema
Schema schema = new Schema("cities", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String")
])
Schema guidSchema = schema.changeField(schema.field('id'), new Field('guid','String'), 'cities_guid')cities_guid geom: Point(EPSG:4326), guid: String, name: String
Change Field definitions of a Schema
Schema schema = new Schema("cities", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String")
])
Schema updatedSchema = schema.changeFields(
[
(schema.field('id')) : new Field('guid','String'),
(schema.field('name')) : new Field('description','String')
], 'cities_updated')cities_updated geom: Point(EPSG:4326), guid: String, description: String
Add a Field to a Schema
Schema schema = new Schema("countries", [
new Field("geom", "Polygon", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String")
])
Schema updatedSchema = schema.addField(new Field("area", "Double"), "countries_area")countries_area geom: Polygon(EPSG:4326), id: Integer, name: String, area: Double
Add a List of Fields to a Schema
Schema schema = new Schema("countries", [
new Field("geom", "Polygon", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String")
])
Schema updatedSchema = schema.addFields([
new Field("area", "Double"),
new Field("perimeter", "Double"),
], "countries_areaperimeter")countries_areaperimeter geom: Polygon(EPSG:4326), id: Integer, name: String, area: Double, perimeter: Double
Remove a Field from a Schema
Schema schema = new Schema("countries", [
new Field("geom", "Polygon", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String"),
new Field("area", "Double")
])
Schema updatedSchema = schema.removeField(schema.field("area"), "countries_updated")countries_updated geom: Polygon(EPSG:4326), id: Integer, name: String
Remove a List of Fields from a Schema
Schema schema = new Schema("countries", [
new Field("geom", "Polygon", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String"),
new Field("area", "Double")
])
Schema updatedSchema = schema.removeFields([
schema.field("area"),
schema.field("name")
], "countries_updated")countries_updated geom: Polygon(EPSG:4326), id: Integer
Create a new Schema from an existing Schema but only including a subset of Fields
Schema schema = new Schema("countries", [
new Field("geom", "Polygon", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String"),
new Field("area", "Double")
])
Schema updatedSchema = schema.removeFields([
schema.field("area"),
schema.field("name")
], "countries_updated")countries_updated geom: Polygon(EPSG:4326), name: String
Combining Schemas
Combining two Schemas results in a Map with two values: schema and fields. The schema property contains the new Schema. The fields property is List of two Maps which both contain a mapping between the fields of the original Schema and the newly created Schema.
Optional arguments to the Schema.addSchema method are:
-
postfixAll: Whether to postfix all field names (true) or not (false). If true, all Fields from the this current Schema will have '1' at the end of their name while the other Schema’s Fields will have '2'. Defaults to false.
-
includeDuplicates: Whether or not to include duplicate fields names. Defaults to false. If a duplicate is found a '2' will be added.
-
maxFieldNameLength: The maximum new Field name length (mostly to support shapefiles where Field names can’t be longer than 10 characters
-
firstPostfix: The postfix string (default is '1') for Fields from the current Schema. Only applicable when postfixAll or includeDuplicates is true.
-
secondPostfix: The postfix string (default is '2') for Fields from the other Schema. Only applicable when postfixAll or includeDuplicates is true.
Combine two Schemas with no duplicate fields and no postfixes to field names
Schema shopSchema = new Schema("shops", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String")
])
Schema cafeSchema = new Schema("cafes", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String"),
new Field("address", "String")
])
Map result = shopSchema.addSchema(cafeSchema, "business")
Schema combinedSchema = result.schema
println combinedSchemabusiness geom: Point(EPSG:4326), id: Integer, name: String, address: String
Map<String,String> shopSchemaFieldMapping = result.fields[0]
println shopSchemaFieldMapping[geom:geom, id:id, name:name]
Map<String,String> cafeSchemaSchemaFieldMapping = result.fields[1]
println cafeSchemaSchemaFieldMapping[address:address]
Combine two Schemas with no duplicate fields and postfixes
Schema shopSchema = new Schema("shops", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String")
])
Schema cafeSchema = new Schema("cafes", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String"),
new Field("address", "String")
])
Map result = shopSchema.addSchema(cafeSchema, "business", postfixAll: true, includeDuplicates: false)
Schema combinedSchema = result.schema
println combinedSchemabusiness geom: Point(EPSG:4326), id1: Integer, name1: String, id2: Integer, name2: String, address2: String
Map<String,String> shopSchemaFieldMapping = result.fields[0]
println shopSchemaFieldMapping[geom:geom, id:id1, name:name1]
Map<String,String> cafeSchemaSchemaFieldMapping = result.fields[1]
println cafeSchemaSchemaFieldMapping[id:id2, name:name2, address:address2]
Creating Features from a Schema
Create a Feature from a Schema with a Map of values
Schema schema = new Schema("cities", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String")
])
Feature feature = schema.feature([
id: 1,
name: 'Seattle',
geom: new Point( -122.3204, 47.6024)
], "city.1")
println featurecities.city.1 geom: POINT (-122.3204 47.6024), id: 1, name: Seattle
Create a Feature from a Schema with a List of values. The order of the values must match the order of the Fields.
Schema schema = new Schema("cities", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String")
])
Feature feature = schema.feature([
new Point( -122.3204, 47.6024),
1,
'Seattle'
], "city.1")
println featurecities.city.1 geom: POINT (-122.3204 47.6024), id: 1, name: Seattle
Create a Feature from a Schema with another Feature.
Schema schema = new Schema("cities", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String")
])
Feature feature1 = new Feature([
id: 1,
name: 'Seattle',
geom: new Point( -122.3204, 47.6024)
], "city.1", schema)
println feature1
Feature feature2 = schema.feature(feature1)
println feature2cities.city.1 geom: POINT (-122.3204 47.6024), id: 1, name: Seattle cities.city.1 geom: POINT (-122.3204 47.6024), id: 1, name: Seattle
Create an empty Feature from a Schema.
Schema schema = new Schema("cities", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String")
])
Feature feature = schema.feature()
println featurecities.fid-34d9214a_16d54d1675c_-7ffc geom: null, id: null, name: null
Reading and Writing Schemas
The Schema IO classes are in the geoscript.feature.io package.
Finding Schema Writer and Readers
List all Schema Writers
List<SchemaWriter> writers = SchemaWriters.list()
writers.each { SchemaWriter writer ->
println writer.class.simpleName
}JsonSchemaWriter StringSchemaWriter XmlSchemaWriter
Find a Schema Writer
Schema schema = new Schema("cities", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String")
])
SchemaWriter writer = SchemaWriters.find("string")
String schemaStr = writer.write(schema)
println schemaStrgeom:Point:srid=4326,id:Integer,name:String
List all Schema Readers
List<SchemaReader> readers = SchemaReaders.list()
readers.each { SchemaReader reader ->
println reader.class.simpleName
}JsonSchemaReader StringSchemaReader XmlSchemaReader
Find a Schema Reader
SchemaReader reader = SchemaReaders.find("string")
Schema schema = reader.read("geom:Point:srid=4326,id:Integer,name:String")
println schemalayer geom: Point(EPSG:4326), id: Integer, name: String
String
Read a Schema from a String
StringSchemaReader reader = new StringSchemaReader()
Schema schema = reader.read("geom:Point:srid=4326,id:Integer,name:String", name: "points")
println schemapoints geom: Point(EPSG:4326), id: Integer, name: String
Write a Schema to a String
Schema schema = new Schema("cities", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String")
])
StringSchemaWriter writer = new StringSchemaWriter()
String schemaStr = writer.write(schema)
println schemaStrgeom:Point:srid=4326,id:Integer,name:String
JSON
Read a Schema from a JSON
JsonSchemaReader reader = new JsonSchemaReader()
Schema schema = reader.read("""{
"name": "cities",
"projection": "EPSG:4326",
"geometry": "geom",
"fields": [
{
"name": "geom",
"type": "Point",
"geometry": true,
"projection": "EPSG:4326"
},
{
"name": "id",
"type": "Integer"
},
{
"name": "name",
"type": "String"
}
]
}""")
println schemacities geom: Point(EPSG:4326), id: Integer, name: String
Write a Schema to a JSON
Schema schema = new Schema("cities", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String")
])
JsonSchemaWriter writer = new JsonSchemaWriter()
String schemaStr = writer.write(schema)
println schemaStr{
"name": "cities",
"projection": "EPSG:4326",
"geometry": "geom",
"fields": [
{
"name": "geom",
"type": "Point",
"geometry": true,
"projection": "EPSG:4326"
},
{
"name": "id",
"type": "Integer"
},
{
"name": "name",
"type": "String"
}
]
}
XML
Read a Schema from a XML
XmlSchemaReader reader = new XmlSchemaReader()
Schema schema = reader.read("""<schema>
<name>cities</name>
<projection>EPSG:4326</projection>
<geometry>geom</geometry>
<fields>
<field>
<name>geom</name>
<type>Point</type>
<projection>EPSG:4326</projection>
</field>
<field>
<name>id</name>
<type>Integer</type>
</field>
<field>
<name>name</name>
<type>String</type>
</field>
</fields>
</schema>""")
println schemacities geom: Point(EPSG:4326), id: Integer, name: String
Write a Schema to a XML
Schema schema = new Schema("cities", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String")
])
XmlSchemaWriter writer = new XmlSchemaWriter()
String schemaStr = writer.write(schema)
println schemaStr<schema>
<name>cities</name>
<projection>EPSG:4326</projection>
<geometry>geom</geometry>
<fields>
<field>
<name>geom</name>
<type>Point</type>
<projection>EPSG:4326</projection>
</field>
<field>
<name>id</name>
<type>Integer</type>
</field>
<field>
<name>name</name>
<type>String</type>
</field>
</fields>
</schema>
Creating Features
Create an empty Feature from a Map of values and a Schema.
Schema schema = new Schema("cities", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String")
])
Feature feature = new Feature([
id: 1,
name: "Seattle",
geom: new Point(-122.3204, 47.6024)
], "city.1", schema)
println featurecities.city.1 geom: POINT (-122.3204 47.6024), id: 1, name: Seattle
Create an empty Feature from a List of values and a Schema.
Schema schema = new Schema("cities", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String")
])
Feature feature = new Feature([
new Point(-122.3204, 47.6024),
1,
"Seattle"
], "city.1", schema)
println featurecities.city.1 geom: POINT (-122.3204 47.6024), id: 1, name: Seattle
Create an empty Feature from a Map of values. The Schema is inferred from the values.
Feature feature = new Feature([
id: 1,
name: "Seattle",
geom: new Point(-122.3204, 47.6024)
], "city.1")
println featurefeature.city.1 id: 1, name: Seattle, geom: POINT (-122.3204 47.6024)
Getting Feature Properties
Get a Feature’s ID
Schema schema = new Schema("cities", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String")
])
Feature feature = new Feature([
new Point(-122.3204, 47.6024),
1,
"Seattle"
], "city.1", schema)
String id = feature.id
println idcity.1
Get a Feature’s Geometry
Geometry geometry = feature.geom
println geometryPOINT (-122.3204 47.6024)
Get a Feature’s Bounds
Bounds bounds = feature.bounds
println bounds(-122.3204,47.6024,-122.3204,47.6024,EPSG:4326)
Get a Feature’s attributes
Map attributes = feature.attributes
println attributes[geom:POINT (-122.3204 47.6024), id:1, name:Seattle]
Getting Feature Attributes
Get an attribute from a Feature using a Field name
Schema schema = new Schema("cities", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String")
])
Feature feature = new Feature([
new Point(-122.3204, 47.6024),
1,
"Seattle"
], "city.1", schema)
int id = feature.get("id")
println id1
Get an attribute from a Feature using a Field
String name = feature.get(schema.field("name"))
println nameSeattle
Set an attribute of a Feature using a Field name and a new value
feature.set("name", "Tacoma")
println feature["name"]Tacoma
Set an attribute of a Feature using a Field and a new value
feature.set(schema.field("name"), "Mercer Island")
println feature["name"]Mercer Island
Set attributes of a Feature using a Map of new values
feature.set([id: 2])
println feature["id"]2
Set a new Geometry value
feature.geom = new Point(-122.2220, 47.5673)
println feature.geomPOINT (-122.222 47.5673)
Reading and Writing Features
The Feature IO classes are in the geoscript.feature.io package.
Finding Feature Writer and Readers
List all Feature Writers
List<Writer> writers = Writers.list()
writers.each { Writer writer ->
println writer.class.simpleName
}GeobufWriter GeoJSONWriter GeoRSSWriter GmlWriter GpxWriter KmlWriter
Find a Feature Writer
Writer writer = Writers.find("geojson")
println writer.class.simpleNameGeoJSONWriter
List all Feature Readers
List<Reader> readers = Readers.list()
readers.each { Reader reader ->
println reader.class.simpleName
}GeobufReader GeoJSONReader GeoRSSReader GmlReader GpxReader KmlReader
Find a Feature Reader
Reader reader = Readers.find("geojson")
println reader.class.simpleNameGeoJSONReader
GeoJSON
Get a GeoJSON String from a Feature
Schema schema = new Schema("cities", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String")
])
Feature feature = new Feature([
new Point(-122.3204, 47.6024),
1,
"Seattle"
], "city.1", schema)
String geojson = feature.geoJSON
println geojson{"type":"Feature","geometry":{"type":"Point","coordinates":[-122.3204,47.6024]},"properties":{"id":1,"name":"Seattle"},"id":"city.1"}
Write a Feature to GeoJSON
Schema schema = new Schema("cities", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String")
])
Feature feature = new Feature([
new Point(-122.3204, 47.6024),
1,
"Seattle"
], "city.1", schema)
GeoJSONWriter writer = new GeoJSONWriter()
String geojson = writer.write(feature)
println geojson{"type":"Feature","geometry":{"type":"Point","coordinates":[-122.3204,47.6024]},"properties":{"id":1,"name":"Seattle"},"id":"city.1"}
Get a Feature from GeoJSON
String geojson = '{"type":"Feature","geometry":{"type":"Point","coordinates":[-122.3204,47.6024]},"properties":{"id":1,"name":"Seattle"},"id":"city.1"}'
Feature feature = Feature.fromGeoJSON(geojson)
println featurefeature.city.1 id: 1, name: Seattle, geometry: POINT (-122.3204 47.6024)
Read a Feature from GeoJSON
GeoJSONReader reader = new GeoJSONReader()
String geojson = '{"type":"Feature","geometry":{"type":"Point","coordinates":[-122.3204,47.6024]},"properties":{"id":1,"name":"Seattle"},"id":"city.1"}'
Feature feature = reader.read(geojson)
println featurefeature.city.1 id: 1, name: Seattle, geometry: POINT (-122.3204 47.6024)
GeoBuf
Get a GeoBuf String from a Feature
Schema schema = new Schema("cities", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String")
])
Feature feature = new Feature([
new Point(-122.3204, 47.6024),
1,
"Seattle"
], "city.1", schema)
String geobuf = feature.geobuf
println geobuf0a0269640a046e616d65100218062a1d0a0c08001a089fd8d374c0ebb22d6a0218016a090a0753656174746c65
Get a Feature from a GeoBuf String
String geobuf = '0a0269640a046e616d65100218062a1d0a0c08001a089fd8d374c0ebb22d6a0218016a090a0753656174746c65'
Feature feature = Feature.fromGeobuf(geobuf)
println featurefeatures.0 geom: POINT (-122.3204 47.6024), id: 1, name: Seattle
Write a Feature to a GeoBuf String
Schema schema = new Schema("cities", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String")
])
Feature feature = new Feature([
new Point(-122.3204, 47.6024),
1,
"Seattle"
], "city.1", schema)
GeobufWriter writer = new GeobufWriter()
String geobuf = writer.write(feature)
println geobuf0a0269640a046e616d65100218062a1d0a0c08001a089fd8d374c0ebb22d6a0218016a090a0753656174746c65
Read a Feature from a GeoBuf String
GeobufReader reader = new GeobufReader()
String geobuf = '0a0269640a046e616d65100218062a1d0a0c08001a089fd8d374c0ebb22d6a0218016a090a0753656174746c65'
Feature feature = reader.read(geobuf)
println featurefeatures.0 geom: POINT (-122.3204 47.6024), id: 1, name: Seattle
GeoRSS
Get a GeoRSS String from a Feature
Schema schema = new Schema("cities", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String")
])
Feature feature = new Feature([
new Point(-122.3204, 47.6024),
1,
"Seattle"
], "city.1", schema)
String georss = feature.geoRSS
println georss<entry xmlns:georss='http://www.georss.org/georss' xmlns='http://www.w3.org/2005/Atom'><title>city.1</title><summary xmlns:georss='http://www.georss.org/georss' xmlns='http://www.w3.org/2005/Atom'>[geom:POINT (-122.3204 47.6024), id:1, name:Seattle]</summary><updated>Sat Sep 21 10:14:33 PDT 2019</updated><georss:point xmlns:georss='http://www.georss.org/georss' xmlns='http://www.w3.org/2005/Atom'>47.6024 -122.3204</georss:point></entry>
Get a Feature from a GeoRSS String
String georss = """<entry xmlns:georss='http://www.georss.org/georss' xmlns='http://www.w3.org/2005/Atom'>
<title>city.1</title>
<summary>[geom:POINT (-122.3204 47.6024), id:1, name:Seattle]</summary>
<updated>Sat Jan 28 15:51:47 PST 2017</updated>
<georss:point>47.6024 -122.3204</georss:point>
</entry>
"""
Feature feature = Feature.fromGeoRSS(georss)
println featuregeorss.fid-34d9214a_16d54d1675c_-8000 title: city.1, summary: [geom:POINT (-122.3204 47.6024), id:1, name:Seattle], updated: Sat Jan 28 15:51:47 PST 2017, geom: POINT (-122.3204 47.6024)
Write a Feature to a GeoRSS String
Schema schema = new Schema("cities", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String")
])
Feature feature = new Feature([
new Point(-122.3204, 47.6024),
1,
"Seattle"
], "city.1", schema)
GeoRSSWriter writer = new GeoRSSWriter()
String georss = writer.write(feature)
println georss<entry xmlns:georss='http://www.georss.org/georss' xmlns='http://www.w3.org/2005/Atom'><title>city.1</title><summary xmlns:georss='http://www.georss.org/georss' xmlns='http://www.w3.org/2005/Atom'>[geom:POINT (-122.3204 47.6024), id:1, name:Seattle]</summary><updated>Sat Sep 21 10:14:33 PDT 2019</updated><georss:point xmlns:georss='http://www.georss.org/georss' xmlns='http://www.w3.org/2005/Atom'>47.6024 -122.3204</georss:point></entry>
Read a Feature from a GeoRSS String
GeoRSSReader reader = new GeoRSSReader()
String georss = """<entry xmlns:georss='http://www.georss.org/georss' xmlns='http://www.w3.org/2005/Atom'>
<title>city.1</title>
<summary>[geom:POINT (-122.3204 47.6024), id:1, name:Seattle]</summary>
<updated>Sat Jan 28 15:51:47 PST 2017</updated>
<georss:point>47.6024 -122.3204</georss:point>
</entry>
"""
Feature feature = reader.read(georss)
println featuregeorss.fid-34d9214a_16d54d1675c_-7ffe title: city.1, summary: [geom:POINT (-122.3204 47.6024), id:1, name:Seattle], updated: Sat Jan 28 15:51:47 PST 2017, geom: POINT (-122.3204 47.6024)
GML
Get a GML String from a Feature
Schema schema = new Schema("cities", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String")
])
Feature feature = new Feature([
new Point(-122.3204, 47.6024),
1,
"Seattle"
], "city.1", schema)
String gml = feature.gml
println gml<gsf:cities xmlns:gsf="http://geoscript.org/feature" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:gml="http://www.opengis.net/gml" xmlns:xlink="http://www.w3.org/1999/xlink" fid="city.1"> <gml:name>Seattle</gml:name> <gsf:geom> <gml:Point> <gml:coord> <gml:X>-122.3204</gml:X> <gml:Y>47.6024</gml:Y> </gml:coord> </gml:Point> </gsf:geom> <gsf:id>1</gsf:id> </gsf:cities>
Get a Feature from a GML String
String gml = """<gsf:cities xmlns:gsf="http://geoscript.org/feature" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:gml="http://www.opengis.net/gml" xmlns:xlink="http://www.w3.org/1999/xlink" fid="city.1">
<gml:name>Seattle</gml:name>
<gsf:geom>
<gml:Point>
<gml:coord>
<gml:X>-122.3204</gml:X>
<gml:Y>47.6024</gml:Y>
</gml:coord>
</gml:Point>
</gsf:geom>
<gsf:id>1</gsf:id>
</gsf:cities>
"""
Feature feature = Feature.fromGml(gml)
println featurefeature.city.1 name: Seattle, id: 1, geom: POINT (-122.3204 47.6024)
Write a Feature to a GML String
Schema schema = new Schema("cities", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String")
])
Feature feature = new Feature([
new Point(-122.3204, 47.6024),
1,
"Seattle"
], "city.1", schema)
GmlWriter writer = new GmlWriter()
String gml = writer.write(feature)
println gml<gsf:cities xmlns:gsf="http://geoscript.org/feature" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:gml="http://www.opengis.net/gml" xmlns:xlink="http://www.w3.org/1999/xlink" fid="city.1"> <gml:name>Seattle</gml:name> <gsf:geom> <gml:Point> <gml:coord> <gml:X>-122.3204</gml:X> <gml:Y>47.6024</gml:Y> </gml:coord> </gml:Point> </gsf:geom> <gsf:id>1</gsf:id> </gsf:cities>
Read a Feature from a GML String
GmlReader reader = new GmlReader()
String gml = """<gsf:cities xmlns:gsf="http://geoscript.org/feature" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:gml="http://www.opengis.net/gml" xmlns:xlink="http://www.w3.org/1999/xlink" fid="city.1">
<gml:name>Seattle</gml:name>
<gsf:geom>
<gml:Point>
<gml:coord>
<gml:X>-122.3204</gml:X>
<gml:Y>47.6024</gml:Y>
</gml:coord>
</gml:Point>
</gsf:geom>
<gsf:id>1</gsf:id>
</gsf:cities>
"""
Feature feature = reader.read(gml)
println featurefeature.city.1 name: Seattle, id: 1, geom: POINT (-122.3204 47.6024)
GPX
Get a GPX String from a Feature
Schema schema = new Schema("cities", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String")
])
Feature feature = new Feature([
new Point(-122.3204, 47.6024),
1,
"Seattle"
], "city.1", schema)
String gpx = feature.gpx
println gpx<wpt lat='47.6024' lon='-122.3204' xmlns='http://www.topografix.com/GPX/1/1'><name>city.1</name></wpt>
Get a Feature from a GPX String
String gpx = "<wpt lat='47.6024' lon='-122.3204' xmlns='http://www.topografix.com/GPX/1/1'><name>city.1</name></wpt>"
Feature feature = Feature.fromGpx(gpx)
println featuregpx.fid-34d9214a_16d54d1675c_-7ffd geom: POINT (-122.3204 47.6024), name: city.1
Write a Feature to a GPX String
Schema schema = new Schema("cities", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String")
])
Feature feature = new Feature([
new Point(-122.3204, 47.6024),
1,
"Seattle"
], "city.1", schema)
GpxWriter writer = new GpxWriter()
String gpx = writer.write(feature)
println gpx<wpt lat='47.6024' lon='-122.3204' xmlns='http://www.topografix.com/GPX/1/1'><name>city.1</name></wpt>
Read a Feature from a GPX String
GpxReader reader = new GpxReader()
String gpx = "<wpt lat='47.6024' lon='-122.3204' xmlns='http://www.topografix.com/GPX/1/1'><name>city.1</name></wpt>"
Feature feature = reader.read(gpx)
println featuregpx.fid-34d9214a_16d54d1675c_-7fff geom: POINT (-122.3204 47.6024), name: city.1
KML
Get a KML String from a Feature
Schema schema = new Schema("cities", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String")
])
Feature feature = new Feature([
new Point(-122.3204, 47.6024),
1,
"Seattle"
], "city.1", schema)
String kml = feature.kml
println kml<kml:Placemark xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:kml="http://earth.google.com/kml/2.1" id="city.1"><kml:name>Seattle</kml:name><kml:Point><kml:coordinates>-122.3204,47.6024</kml:coordinates></kml:Point></kml:Placemark>
Get a Feature from a KML String
String kml = """<kml:Placemark xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:kml="http://earth.google.com/kml/2.1" id="city.1">
<kml:name>Seattle</kml:name>
<kml:Point>
<kml:coordinates>-122.3204,47.6024</kml:coordinates>
</kml:Point>
</kml:Placemark>"""
Feature feature = Feature.fromKml(kml)
println featureplacemark.city.1 name: Seattle, description: null, Geometry: POINT (-122.3204 47.6024)
Write a Feature to a KML String
Schema schema = new Schema("cities", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String")
])
Feature feature = new Feature([
new Point(-122.3204, 47.6024),
1,
"Seattle"
], "city.1", schema)
KmlWriter writer = new KmlWriter()
String kml = writer.write(feature)
println kml<kml:Placemark xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:kml="http://earth.google.com/kml/2.1" id="city.1"><kml:name>Seattle</kml:name><kml:Point><kml:coordinates>-122.3204,47.6024</kml:coordinates></kml:Point></kml:Placemark>
Read a Feature from a KML String
KmlReader reader = new KmlReader()
String kml = """<kml:Placemark xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:kml="http://earth.google.com/kml/2.1" id="city.1">
<kml:name>Seattle</kml:name>
<kml:Point>
<kml:coordinates>-122.3204,47.6024</kml:coordinates>
</kml:Point>
</kml:Placemark>"""
Feature feature = reader.read(kml)
println featureplacemark.city.1 name: Seattle, description: null, Geometry: POINT (-122.3204 47.6024)
Filter Recipes
The Filter classes are in the geoscript.filter package.
Creating Filters
Create a Filter from a CQL string
Filter filter = new Filter("name='Seattle'")
println filter.toString()[ name = Seattle ]
Create a Filter from a CQL string
Filter filter = new Filter("<filter><PropertyIsEqualTo><PropertyName>soilType</PropertyName><Literal>Mollisol</Literal></PropertyIsEqualTo></filter>")
println filter.toString()[ soilType = Mollisol ]
Create a pass Filter that return true for everything
Filter filter = Filter.PASS
println filter.toString()Filter.INCLUDE
Create a fail Filter that return false for everything
Filter filter = Filter.FAIL
println filter.toString()Filter.EXCLUDE
Create a spatial bounding box Filter from a Bounds
Filter filter = Filter.bbox(new Bounds(-102, 43.5, -100, 47.5))
println filter.toString()[ the_geom bbox ReferencedEnvelope[-102.0 : -100.0, 43.5 : 47.5] ]
Create a spatial contains Filter from a Geometry
Filter filter = Filter.contains(Geometry.fromWKT("POLYGON ((-104 45, -95 45, -95 50, -104 50, -104 45))"))
println filter.toString()[ the_geom contains POLYGON ((-104 45, -95 45, -95 50, -104 50, -104 45)) ]
Create a spatial distance within Filter from a Geometry and a distance
Filter filter = Filter.dwithin("the_geom", Geometry.fromWKT("POINT (-100 47)"), 10.2, "feet")
println filter.toString()[ the_geom dwithin POINT (-100 47), distance: 10.2 ]
Create a spatial crosses Filter from a Geometry
Filter filter = Filter.crosses("the_geom", Geometry.fromWKT("LINESTRING (-104 45, -95 45)"))
println filter.toString()[ the_geom crosses LINESTRING (-104 45, -95 45) ]
Create a spatial intersects Filter from a Geometry
Filter filter = Filter.intersects(Geometry.fromWKT("POLYGON ((-104 45, -95 45, -95 50, -104 50, -104 45))"))
println filter.toString()[ the_geom intersects POLYGON ((-104 45, -95 45, -95 50, -104 50, -104 45)) ]
Create a feature id Filter
Filter filter = Filter.id("points.1")
println filter.toString()[ points.1 ]
Create a feature ids Filter
Filter filter = Filter.ids(["points.1","points.2","points.3"])
println filter.toString()[ points.1, points.2, points.3 ]
Create an equals Filter
Filter filter = Filter.equals("name", "Washington")
println filter.toString()[ name = Washington ]
Using Filters
Get a CQL string from a Filter
Filter filter = new Filter("name='Seattle'")
String cql = filter.cql
println cqlname = 'Seattle'
Get an XML string from a Filter
String xml = filter.xml
println xml<ogc:Filter xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:gml="http://www.opengis.net/gml" xmlns:ogc="http://www.opengis.net/ogc"> <ogc:PropertyIsEqualTo> <ogc:PropertyName>name</ogc:PropertyName> <ogc:Literal>Seattle</ogc:Literal> </ogc:PropertyIsEqualTo> </ogc:Filter>
Combine Filters with and
Filter cityFilter = new Filter("city = 'Seattle'")
Filter stateFilter = new Filter("state = 'WA'")
Filter andFilter = cityFilter.and(stateFilter)
println andFilter[[ city = Seattle ] AND [ state = WA ]]
Combine Filters with and using the plus operator
Filter cityFilter = new Filter("city = 'Seattle'")
Filter stateFilter = new Filter("state = 'WA'")
Filter andFilter = cityFilter + stateFilter
println andFilter[[ city = Seattle ] AND [ state = WA ]]
Combine Filters with or
Filter seattleFilter = new Filter("city = 'Seattle'")
Filter tacomaFilter = new Filter("city = 'Tacoma'")
Filter orFilter = seattleFilter.or(tacomaFilter)
println orFilter[[ city = Seattle ] OR [ city = Tacoma ]]
Negate a Filter
Filter seattleFilter = new Filter("city = 'Seattle'")
Filter notSeattleFilter = seattleFilter.not
println notSeattleFilter[ NOT [ city = Seattle ] ]
Negate a Filter using the minus operator
Filter seattleFilter = new Filter("city = 'Seattle'")
Filter notSeattleFilter = -seattleFilter
println notSeattleFilter[ NOT [ city = Seattle ] ]
Simplify a Filter
Filter seattleFilter = new Filter("city = 'Seattle'")
Filter filter = (seattleFilter + Filter.PASS).simplify()
println filter[ city = Seattle ]
Evaluating Filters
Test to see if a Filter matches a Feature by attribute
Feature feature = new Feature([
id: 1,
name: "Seattle",
geom: new Point(-122.3204, 47.6024)
], "city.1")
Filter isNameFilter = new Filter("name='Seattle'")
boolean isName = isNameFilter.evaluate(feature)
println isNametrue
Filter isNotNameFilter = new Filter("name='Tacoma'")
boolean isNotName = isNotNameFilter.evaluate(feature)
println isNotName
false
Test to see if a Filter matches a Feature by feature id
Filter isIdFilter = Filter.id("city.1")
boolean isId = isIdFilter.evaluate(feature)
println isIdtrue
Filter isNotIdFilter = Filter.id("city.2")
boolean isNotId = isNotIdFilter.evaluate(feature)
println isNotId
false
Test to see if a Filter matches a Feature by a spatial bounding box
Filter isInBboxFilter = Filter.bbox("geom", new Bounds(-132.539, 42.811, -111.796, 52.268))
boolean isInBbox = isInBboxFilter.evaluate(feature)
println isInBboxtrue
Filter isNotInBboxFilter = Filter.bbox("geom", new Bounds(-12.656, 18.979, 5.273, 34.597))
boolean isNotInBbox = isNotInBboxFilter.evaluate(feature)
println isNotInBbox
false
Creating Literals
Create a literal Expression from a number
Expression expression = new Expression(3.56)
println expression3.56
Create a literal Expression from a string
Expression expression = new Expression("Seattle")
println expressionSeattle
Evaluating a literal Expression just gives you the value
Expression expression = new Expression(3.56)
double number = expression.evaluate()
println number3.56
Creating Properties
Create a Property from a string
Property property = new Property("name")
println propertyname
Create a Property from a Field
Field field = new Field("geom", "Polygon")
Property property = new Property(field)
println propertygeom
Evaluating Properties
Evaluate a Property to get values from a Feature. Get the id
Feature feature = new Feature([
id: 1,
name: "Seattle",
geom: new Point(-122.3204, 47.6024)
], "city.1")
Property idProperty = new Property("id")
int id = idProperty.evaluate(feature)
println id1
Get the name
Property nameProperty = new Property("name")
String name = nameProperty.evaluate(feature)
println nameSeattle
Get the geometry
Property geomProperty = new Property("geom")
Geometry geometry = geomProperty.evaluate(feature)
println geometryPOINT (-122.3204 47.6024)
Creating Functions
Create a Function from a CQL string
Function function = new Function("centroid(the_geom)")
println functioncentroid([the_geom])
Create a Function from a name and Expressions
Function function = new Function("centroid", new Property("the_geom"))
println functioncentroid([the_geom])
Create a Function from a name, a Closure, and Expressions
Function function = new Function("my_centroid", {g-> g.centroid}, new Property("the_geom"))
println functionmy_centroid([the_geom])
Create a Function from a CQL string and a Closure
Function function = new Function("my_centroid(the_geom)", {g-> g.centroid})
println functionmy_centroid([the_geom])
You can get a list of built in Functions
List<String> functionNames = Function.getFunctionNames()
println "There are ${functionNames.size()} Functions:"
functionNames.sort().subList(0,10).each { String name ->
println name
}There are 306 Functions: Area Categorize Collection_Average Collection_Bounds Collection_Count Collection_Max Collection_Median Collection_Min Collection_Nearest Collection_Sum
Evaluating Functions
Evaulate a geometry Function
Feature feature = new Feature([
id: 1,
name: "Seattle",
geom: new Point(-122.3204, 47.6024)
], "city.1")
Function bufferFunction = new Function("buffer(geom, 10)")
Geometry polygon = bufferFunction.evaluate(feature)
Evaulate a geometry Function
Function lowerCaseFunction = new Function("strToLowerCase(name)")
String lowerCaseName = lowerCaseFunction.evaluate(feature)
println lowerCaseNameseattle
Process Functions
Process Functions are a combination of Functions and Processes that can be used to create rendering transformations.
Create a Function from a Process that converts geometries in a Layer into a convexhull.
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer places = workspace.get("places")
Process process = new Process("convexhull",
"Create a convexhull around the features",
[features: geoscript.layer.Cursor],
[result: geoscript.layer.Cursor],
{ inputs ->
def geoms = new GeometryCollection(inputs.features.collect{ f -> f.geom})
def output = new Layer()
output.add([geoms.convexHull])
[result: output]
}
)
Function function = new Function(process, new Function("parameter", new Expression("features")))
Symbolizer symbolizer = new Transform(function, Transform.RENDERING) + new Fill("aqua", 0.75) + new Stroke("navy", 0.5)
places.style = symbolizer
Create a ProcessFunction from a Process that converts geometries in a Layer into a bounds.
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer places = workspace.get("places")
Process process = new Process("bounds",
"Create a bounds around the features",
[features: geoscript.layer.Cursor],
[result: geoscript.layer.Cursor],
{ inputs ->
def geoms = new GeometryCollection(inputs.features.collect{ f -> f.geom})
def output = new Layer()
output.add([geoms.bounds.geometry])
[result: output]
}
)
ProcessFunction processFunction = new ProcessFunction(process, new Function("parameter", new Expression("features")))
Symbolizer symbolizer = new Transform(processFunction, Transform.RENDERING) + new Fill("aqua", 0.75) + new Stroke("navy", 0.5)
places.style = symbolizer
Creating Colors
Create a Color from a RGB color string
Color color = new Color("0,255,0")
Create a Color from a CSS color name
Color color = new Color("silver")
Create a Color from a hexadecimal string
Color color = new Color("#0000ff")
Create a Color from a RGB List
Color color = new Color([255,0,0])
Create a Color from a RGB Map
Color color = new Color([r: 5, g: 35, b:45])
Create a Color from a RGB function string
Color color = new Color("rgb(0,128,128)")
Create a Color from a HLS Map
Color color = new Color([h: 0, s: 1.0, l: 0.5])
Create a Color from a HSL function string
Color color = new Color("hsl(0,1,0.5)")
Get a Random Color
Color color = Color.getRandom()
Get a Random Pastel Color
Color color = Color.getRandomPastel()
Get a darker Color
Color color = new Color("lightblue")
Color darkerColor = color.darker()
Get a brighter Color
Color color = new Color("purple")
Color brigtherColor = color.brighter()
Getting Color Formats
Create a Color
Color color = new Color("wheat")
Get Hex
String hex = color.hex
println hex#f5deb3
Get RGB
List rgb = color.rgb
println rgb[245, 222, 179]
Get HSL
List hsl = color.hsl
println hsl[0.10858585256755147, 0.7674419030001307, 0.8313725489999999]
Get the java.awt.Color
java.awt.Color awtColor = color.asColor()
println awtColorjava.awt.Color[r=245,g=222,b=179]
Displaying Colors
Draw a List of Colors to a BufferedImage
Color color = new Color("pink")
BufferedImage image = Color.drawToImage(
[color.brighter(), color, color.darker()],
"vertical",
40
)
Draw a List of Colors to a simple GUI
List<Color> colors = Color.getPaletteColors("YlOrBr")
Color.draw(colors, "horizontal", 50)
Using Color Palettes
Get all color palettes
List<String> allPalettes = Color.getPaletteNames("all")
allPalettes.each { String name ->
println name
}YlOrRd PRGn PuOr RdGy Spectral Grays PuBuGn RdPu BuPu YlOrBr Greens BuGn Accents GnBu PuRd Purples RdYlGn Paired Blues RdBu Oranges RdYlBu PuBu OrRd Set3 Set2 Set1 Reds PiYG Dark2 YlGn BrBG YlGnBu Pastel2 Pastel1 BlueToOrange GreenToOrange BlueToRed GreenToRedOrange Sunset Green YellowToRedHeatMap BlueToYellowToRedHeatMap DarkRedToYellowWhiteHeatMap LightPurpleToDarkPurpleHeatMap BoldLandUse MutedTerrain BoldLandUse MutedTerrain
Get diverging color palettes
List<String> divergingPalettes = Color.getPaletteNames("diverging")
divergingPalettes.each { String name ->
println name
}PRGn PuOr RdGy Spectral RdYlGn RdBu RdYlBu PiYG BrBG BlueToOrange GreenToOrange BlueToRed GreenToRedOrange
Get sequential color palettes
List<String> sequentialPalettes = Color.getPaletteNames("sequential")
sequentialPalettes.each { String name ->
println name
}YlOrRd Grays PuBuGn RdPu BuPu YlOrBr Greens BuGn GnBu PuRd Purples Blues Oranges PuBu OrRd Reds YlGn YlGnBu Sunset Green YellowToRedHeatMap BlueToYellowToRedHeatMap DarkRedToYellowWhiteHeatMap LightPurpleToDarkPurpleHeatMap BoldLandUse MutedTerrain
Get qualitative color palettes
List<String> qualitativePalettes = Color.getPaletteNames("qualitative")
qualitativePalettes.each { String name ->
println name
}Accents Paired Set3 Set2 Set1 Dark2 Pastel2 Pastel1 BoldLandUse MutedTerrain
Get a Blue Green Color Palette
List colors = Color.getPaletteColors("BuGn")
Get a Purple Color Palette with only four colors
colors = Color.getPaletteColors("Purples", 4)
Get a Blue Green Color Palette
colors = Color.getPaletteColors("MutedTerrain")
Get a Blue Green Color Palette
colors = Color.getPaletteColors("BlueToYellowToRedHeatMap")
Create a Color palette by interpolating between two colors
Color startColor = new Color("red")
Color endColor = new Color("green")
List<Color> colors = startColor.interpolate(endColor, 10)
Create a Color palette by interpolating between two colors
Color startColor = new Color("wheat")
Color endColor = new Color("lightblue")
List<Color> colors = Color.interpolate(startColor, endColor, 8)
Creating Expressions from CQL
Create a literal number Expression from a CQL String
Expression expression = Expression.fromCQL("12")
println expression12
Create a literal string Expression from a CQL String
Expression expression = Expression.fromCQL("'Washington'")
println expressionWashington
Create a Property from a CQL String
Property property = Expression.fromCQL("NAME")
println propertyNAME
Create a Function from a CQL String
Function function = Expression.fromCQL("centroid(the_geom)")
println functioncentroid([the_geom])
Create Expression from static imports
You can import short helper methods from the Expressions class.
import static geoscript.filter.Expressions.*Create a literal
Expression literal = expression(1.2)Create a Color
Expression color = color("wheat")Create a Property
Expression property = property("ID")Create a Function
Expression function = function("max(10,22)")Process Recipes
The Process classes are in the geoscript.process package.
Execute a built-in Process
Create a Process from a built-in process by name
Process process = new Process("vec:Bounds")
String name = process.name
println namevec:Bounds
Get the title
String title = process.title
println titleBounds
Get the description
String description = process.description
println descriptionComputes the bounding box of the input features.
Get the version
String version = process.version
println version1.0.0
Get the input parameters
Map parameters = process.parameters
println parameters[features:class geoscript.layer.Cursor]
Get the output parameters
Map results = process.results
println results[bounds:class geoscript.geom.Bounds]
Execute the Process to calculate the bounding box of all Features in a Layer
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer layer = workspace.get("places")
Map executeResults = process.execute([features: layer])
Bounds bounds = executeResults.bounds
Listing built-in Processes
Get the names of all built-in Processes
List<String> processes = Process.processNames
processes.each { String name ->
println name
}vec:Aggregate vec:BarnesSurface vec:Bounds vec:BufferFeatureCollection vec:Centroid vec:ClassifyByRange vec:Clip vec:CollectGeometries vec:Count vec:Feature vec:FeatureClassStats vec:Grid vec:Heatmap vec:InclusionFeatureCollection vec:IntersectionFeatureCollection vec:LRSGeocode vec:LRSMeasure vec:LRSSegment vec:Nearest vec:PointBuffers vec:PointStacker vec:Query vec:RectangularClip vec:Reproject vec:Simplify vec:Snap vec:Transform vec:UnionFeatureCollection vec:Unique vec:VectorToRaster vec:VectorZonalStatistics geo:length geo:isEmpty geo:contains geo:disjoint geo:intersects geo:area geo:numGeometries geo:isClosed geo:buffer geo:difference geo:boundary geo:splitPolygon geo:within geo:touches geo:convexHull geo:crosses geo:symDifference geo:distance geo:centroid geo:interiorPoint geo:getGeometryN geo:overlaps geo:isSimple geo:isWithinDistance geo:relate geo:densify geo:simplify geo:startPoint geo:numPoints geo:reproject geo:dimension geo:exteriorRing geo:numInteriorRing geo:geometryType geo:envelope geo:isRing geo:polygonize geo:endPoint geo:equalsExact geo:isValid geo:union geo:intersection geo:getX geo:getY geo:pointN geo:interiorRingN geo:relatePattern geo:equalsExactTolerance polygonlabelprocess:PolyLabeller ras:AddCoverages ras:Affine ras:AreaGrid ras:BandMerge ras:BandSelect ras:Contour ras:ConvolveCoverage ras:CoverageClassStats ras:CropCoverage ras:Jiffle ras:MultiplyCoverages ras:NormalizeCoverage ras:PolygonExtraction ras:RangeLookup ras:RasterAsPointCollection ras:RasterZonalStatistics ras:RasterZonalStatistics2 ras:ScaleCoverage ras:StyleCoverage ras:TransparencyFill geoscript:convexhull geoscript:bounds
Executing a new Process
Create a Process using a Groovy Closure
Process process = new Process("convexhull",
"Create a convexhull around the features",
[features: geoscript.layer.Cursor],
[result: geoscript.layer.Cursor],
{ inputs ->
def geoms = new GeometryCollection(inputs.features.collect{f -> f.geom})
def output = new Layer()
output.add([geoms.convexHull])
[result: output]
}
)
String name = process.name
println namegeoscript:convexhull
Get the title
String title = process.title
println titleconvexhull
Get the description
String description = process.description
println descriptionCreate a convexhull around the features
Get the version
String version = process.version
println version1.0.0
Get the input parameters
Map parameters = process.parameters
println parameters[features:class geoscript.layer.Cursor]
Get the output parameters
Map results = process.results
println results[result:class geoscript.layer.Cursor]
Execute the Process created from a Groovy Closure
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer layer = workspace.get("places")
Map executeResults = process.execute([features: layer.cursor])
Cursor convexHullCursor = executeResults.result
Process Functions
Process Functions are a combination of Functions and Processes that can be used to create rendering transformations.
Create a Function from a Process that converts geometries in a Layer into a convexhull.
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer places = workspace.get("places")
Process process = new Process("convexhull",
"Create a convexhull around the features",
[features: geoscript.layer.Cursor],
[result: geoscript.layer.Cursor],
{ inputs ->
def geoms = new GeometryCollection(inputs.features.collect{ f -> f.geom})
def output = new Layer()
output.add([geoms.convexHull])
[result: output]
}
)
Function function = new Function(process, new Function("parameter", new Expression("features")))
Symbolizer symbolizer = new Transform(function, Transform.RENDERING) + new Fill("aqua", 0.75) + new Stroke("navy", 0.5)
places.style = symbolizer
Create a ProcessFunction from a Process that converts geometries in a Layer into a bounds.
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer places = workspace.get("places")
Process process = new Process("bounds",
"Create a bounds around the features",
[features: geoscript.layer.Cursor],
[result: geoscript.layer.Cursor],
{ inputs ->
def geoms = new GeometryCollection(inputs.features.collect{ f -> f.geom})
def output = new Layer()
output.add([geoms.bounds.geometry])
[result: output]
}
)
ProcessFunction processFunction = new ProcessFunction(process, new Function("parameter", new Expression("features")))
Symbolizer symbolizer = new Transform(processFunction, Transform.RENDERING) + new Fill("aqua", 0.75) + new Stroke("navy", 0.5)
places.style = symbolizer
Render Recipes
The Render classes are in the geoscript.render package.
Creating Maps
Create a Map with Layers and render to a File.
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
countries.style = new Fill("#ffffff") + new Stroke("#b2b2b2", 0.5)
Layer ocean = workspace.get("ocean")
ocean.style = new Fill("#a5bfdd")
Map map = new Map(
width: 800,
height: 300,
layers: [ocean, countries]
)
File file = new File("map.png")
map.render(file)
Create a Map with Layers and render to a file name.
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
countries.style = new Fill("#ffffff") + new Stroke("#b2b2b2", 0.5)
Layer ocean = workspace.get("ocean")
ocean.style = new Fill("#a5bfdd")
Map map = new Map(
width: 800,
height: 300,
layers: [ocean, countries]
)
map.render("map.png")
Create a Map with Layers and render to an OutputStream.
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
countries.style = new Fill("#ffffff") + new Stroke("#b2b2b2", 0.5)
Layer ocean = workspace.get("ocean")
ocean.style = new Fill("#a5bfdd")
Map map = new Map(
width: 800,
height: 300,
layers: [ocean, countries]
)
File file = new File("map.png")
file.withOutputStream { OutputStream outputStream ->
map.render(outputStream)
}
Create a Map with Layers and render to an BufferedImage.
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
countries.style = new Fill("#ffffff") + new Stroke("#b2b2b2", 0.5)
Layer ocean = workspace.get("ocean")
ocean.style = new Fill("#a5bfdd")
Map map = new Map(
width: 800,
height: 300,
layers: [ocean, countries]
)
BufferedImage image = map.renderToImage()
Create a Map with Layers and render to a Graphics2D object.
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
countries.style = new Fill("#ffffff") + new Stroke("#b2b2b2", 0.5)
Layer ocean = workspace.get("ocean")
ocean.style = new Fill("#a5bfdd")
Map map = new Map(
width: 800,
height: 300,
layers: [ocean, countries]
)
BufferedImage image = new BufferedImage(800, 300, BufferedImage.TYPE_INT_ARGB)
Graphics2D graphics = image.graphics
map.render(graphics)
graphics.dispose()
Create a Map with Layers and display in a simple UI.
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
countries.style = new Fill("#ffffff") + new Stroke("#b2b2b2", 0.5)
Layer ocean = workspace.get("ocean")
ocean.style = new Fill("#a5bfdd")
Map map = new Map(
width: 800,
height: 300,
layers: [ocean, countries]
)
map.display()
Map Properties
Get Map properties
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
countries.style = new Fill("#ffffff") + new Stroke("#b2b2b2", 0.5)
Map map = new Map(
width: 600,
height: 600,
backgroundColor: "#a5bfdd",
layers: [countries],
type: "png",
proj: "EPSG:3857",
bounds: new Bounds(-180,-85,180,85, "EPSG:4326").reproject("EPSG:3857"),
fixAspectRatio: false
)
File file = new File("map.png")
map.render(file)
Get width and height
int width = map.width
int height = map.height
println "Width and Height = ${width} x ${height}"Width and Height = 600 x 600
Get the Bounds
Bounds bounds = map.bounds
println "Bounds = ${bounds}"Bounds = (-2.0037508342789244E7,-1.9971868880408555E7,2.0037508342789244E7,1.9971868880408563E7,EPSG:3857)
Get the Projection
Projection projection = map.proj
println "Projeciton = ${projection}"Projeciton = EPSG:3857
Get the Layers
List<Layer> layers = map.layers
println "Layers:"
layers.each { Layer layer ->
println " ${layer.name}"
}Layers: countries
Get the renderer type
String type = map.type
println "Type = ${type}"Type = png
Get whether we are fixing the aspect ration or not.
boolean shouldFixAspectRation = map.fixAspectRatio
println "Fix Aspect Ratio = ${shouldFixAspectRation}"Fix Aspect Ratio = false
Get the background color
String backgroundColor = map.backgroundColor
println "Background Color = ${backgroundColor}"Background Color = #a5bfdd
Get the scale
double scale = map.scaleDenominator
println "Scale = ${scale}"Scale = 2.385417659855862E8
Advanced Properties
You can set the scale computation to be accurate (the default) or ogc compliant.
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
countries.style = new Fill("#ffffff") + new Stroke("#b2b2b2", 0.5)
Layer ocean = workspace.get("ocean")
ocean.style = new Fill("#a5bfdd")
Map map = new Map(
width: 400,
height: 300,
layers: [ocean, countries],
bounds: new Bounds(-162.070313,9.968851,-35.507813,58.995311, "EPSG:4326")
)
map.setScaleComputation("accurate")
File accurateFile = new File("map_accurate.png")
map.render(accurateFile)
map.setScaleComputation("ogc")
File ogcFile = new File("map_ogc.png")
map.render(ogcFile)Accurate
OGC
You can set whether to use advanced projection handling or not. By default this is set to true.
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
countries.style = new Fill("#ffffff") + new Stroke("#b2b2b2", 0.5)
Layer ocean = workspace.get("ocean")
ocean.style = new Fill("#a5bfdd")
Map map = new Map(
width: 400,
height: 300,
layers: [ocean, countries],
bounds: new Bounds(-162.070313,9.968851,-35.507813,58.995311, "EPSG:4326")
)
map.setAdvancedProjectionHandling(true)
File trueFile = new File("map_advancedproj_true.png")
map.render(trueFile)
map.setAdvancedProjectionHandling(false)
File falseFile = new File("map_advancedproj_false.png")
map.render(falseFile)Yes
No
You can set whether to use continuous map wrapping. The default is true.
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
countries.style = new Fill("#ffffff") + new Stroke("#b2b2b2", 0.5)
Layer ocean = workspace.get("ocean")
ocean.style = new Fill("#a5bfdd")
Map map = new Map(
width: 800,
height: 200,
layers: [ocean, countries]
)
map.setContinuousMapWrapping(true)
File trueFile = new File("map_continuouswrapping_true.png")
map.render(trueFile)
map.setContinuousMapWrapping(false)
File falseFile = new File("map_continuouswrapping_false.png")
map.render(falseFile)Yes
No
Map Cubes
Create a map cube to a file
Workspace workspace = new Directory("src/main/resources/shapefiles")
Layer countries = workspace.get("countries")
Layer ocean = workspace.get("ocean")
countries.style = new Fill("#ffffff") + new Stroke("#b2b2b2", 0.5)
ocean.style = new Fill("#a5bfdd")
MapCube mapCube = new MapCube(
drawOutline: true,
drawTabs: true,
tabSize: 30,
title: "World Cube",
source: "Nartual Earth",
imageType: "png"
)
File file = new File("map_cube_file.png")
mapCube.render([ocean, countries], file)
Create a map cube to a byte array
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
countries.style = new Fill("#ffffff") + new Stroke("#b2b2b2", 0.5)
Layer ocean = workspace.get("ocean")
ocean.style = new Fill("#a5bfdd")
MapCube mapCube = new MapCube()
byte[] bytes = mapCube.render([ocean, countries])
Create a map cube to a byte array
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
countries.style = new Fill("#ffffff") + new Stroke("#b2b2b2", 0.5)
Layer ocean = workspace.get("ocean")
ocean.style = new Fill("#a5bfdd")
MapCube mapCube = new MapCube()
File file = new File("map_cube_stream.png")
file.withOutputStream { OutputStream outputStream ->
mapCube.render([ocean, countries], outputStream)
}
Rendering Maps
Finding Renderers
Get all Renderers
List<Renderer> renderers = Renderers.list()
renderers.each { Renderer renderer ->
println renderer.class.simpleName
}ASCII Base64 GeoTIFF GIF JPEG Pdf PNG Svg
Get a Renderer
Renderer renderer = Renderers.find("png")
println renderer.class.simpleNamePNG
Image
Render a Map to an image using an Image Renderer
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
countries.style = new Fill("#ffffff") + new Stroke("#b2b2b2", 0.5)
Layer ocean = workspace.get("ocean")
ocean.style = new Fill("#a5bfdd")
Map map = new Map(
width: 800,
height: 300,
layers: [ocean, countries]
)
Image png = new Image("png")
BufferedImage image = png.render(map)
Render a Map to an OutputStream using the Image Renderer
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
countries.style = new Fill("#ffffff") + new Stroke("#b2b2b2", 0.5)
Layer ocean = workspace.get("ocean")
ocean.style = new Fill("#a5bfdd")
Map map = new Map(
width: 800,
height: 300,
layers: [ocean, countries]
)
Image jpeg = new Image("jpeg")
File file = new File("map.jpeg")
FileOutputStream out = new FileOutputStream(file)
jpeg.render(map, out)
out.close()
PNG
Render a Map to an Image using the PNG Renderer
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
countries.style = new Fill("#ffffff") + new Stroke("#b2b2b2", 0.5)
Layer ocean = workspace.get("ocean")
ocean.style = new Fill("#a5bfdd")
Map map = new Map(
width: 800,
height: 300,
layers: [ocean, countries]
)
PNG png = new PNG()
BufferedImage image = png.render(map)
Render a Map to an OutputStream using the PNG Renderer
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
countries.style = new Fill("#ffffff") + new Stroke("#b2b2b2", 0.5)
Layer ocean = workspace.get("ocean")
ocean.style = new Fill("#a5bfdd")
Map map = new Map(
width: 800,
height: 300,
layers: [ocean, countries]
)
PNG png = new PNG()
File file = new File("map.png")
FileOutputStream out = new FileOutputStream(file)
png.render(map, out)
out.close()
JPEG
Render a Map to an Image using the JPEG Renderer
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
countries.style = new Fill("#ffffff") + new Stroke("#b2b2b2", 0.5)
Layer ocean = workspace.get("ocean")
ocean.style = new Fill("#a5bfdd")
Map map = new Map(
width: 800,
height: 300,
layers: [ocean, countries]
)
JPEG jpeg = new JPEG()
BufferedImage image = jpeg.render(map)
Render a Map to an OutputStream using the JPEG Renderer
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
countries.style = new Fill("#ffffff") + new Stroke("#b2b2b2", 0.5)
Layer ocean = workspace.get("ocean")
ocean.style = new Fill("#a5bfdd")
Map map = new Map(
width: 800,
height: 300,
layers: [ocean, countries]
)
JPEG jpeg = new JPEG()
File file = new File("map.jpeg")
FileOutputStream out = new FileOutputStream(file)
jpeg.render(map, out)
out.close()
GIF
Render a Map to an Image using the GIF Renderer
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
countries.style = new Fill("#ffffff") + new Stroke("#b2b2b2", 0.5)
Layer ocean = workspace.get("ocean")
ocean.style = new Fill("#a5bfdd")
Map map = new Map(
width: 800,
height: 300,
layers: [ocean, countries]
)
GIF gif = new GIF()
BufferedImage image = gif.render(map)
Render a Map to an OutputStream using the GIF Renderer
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
countries.style = new Fill("#ffffff") + new Stroke("#b2b2b2", 0.5)
Layer ocean = workspace.get("ocean")
ocean.style = new Fill("#a5bfdd")
Map map = new Map(
width: 800,
height: 300,
layers: [ocean, countries]
)
GIF gif = new GIF()
File file = new File("map.gif")
gif.render(map, new FileOutputStream(file))
Render a Map to an animated GIF using the GIF Renderer
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer states = workspace.get("states")
states.style = new Fill("") + new Stroke("black", 1.0)
Layer countries = workspace.get("countries")
countries.style = new Fill("#ffffff") + new Stroke("#b2b2b2", 0.5)
Layer ocean = workspace.get("ocean")
ocean.style = new Fill("#a5bfdd")
Map map = new Map(
width: 800,
height: 300,
layers: [ocean, countries, states]
)
GIF gif = new GIF()
List images = ["Washington","Oregon","California"].collect { String state ->
map.bounds = states.getFeatures("NAME_1 = '${state}'")[0].bounds
def image = gif.render(map)
image
}
File file = new File("states.gif")
gif.renderAnimated(images, file, 500, true)
Render a Map to an animated GIF to a byte array using the GIF Renderer
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer states = workspace.get("states")
states.style = new Fill("") + new Stroke("black", 1.0)
Layer countries = workspace.get("countries")
countries.style = new Fill("#ffffff") + new Stroke("#b2b2b2", 0.5)
Layer ocean = workspace.get("ocean")
ocean.style = new Fill("#a5bfdd")
Map map = new Map(
width: 800,
height: 300,
layers: [ocean, countries, states]
)
GIF gif = new GIF()
List images = ["Washington","Oregon","California"].collect { String state ->
map.bounds = states.getFeatures("NAME_1 = '${state}'")[0].bounds
def image = gif.render(map)
image
}
File file = new File("states.gif")
byte[] bytes = gif.renderAnimated(images, 500, true)
file.bytes = bytes
GeoTIFF
Render a Map to an Image using the GeoTIFF Renderer
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
countries.style = new Fill("#ffffff") + new Stroke("#b2b2b2", 0.5)
Layer ocean = workspace.get("ocean")
ocean.style = new Fill("#a5bfdd")
Map map = new Map(
width: 800,
height: 300,
layers: [ocean, countries]
)
GeoTIFF geotiff = new GeoTIFF()
BufferedImage image = geotiff.render(map)
Render a Map to an OutputStream using the GeoTIFF Renderer
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
countries.style = new Fill("#ffffff") + new Stroke("#b2b2b2", 0.5)
Layer ocean = workspace.get("ocean")
ocean.style = new Fill("#a5bfdd")
Map map = new Map(
width: 800,
height: 300,
layers: [ocean, countries]
)
GeoTIFF geotiff = new GeoTIFF()
File file = new File("map.tif")
geotiff.render(map, new FileOutputStream(file))
ASCII
Render a Map to an string using the ASCII Renderer
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
countries.style = new Fill("#ffffff") + new Stroke("#b2b2b2", 0.5)
Layer ocean = workspace.get("ocean")
ocean.style = new Fill("#a5bfdd")
Map map = new Map(
width: 800,
height: 300,
layers: [ocean, countries]
)
ASCII ascii = new ASCII(width: 60)
String asciiStr = ascii.render(map)
println asciiStr(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((( (((((((((((((((^(^(.(:......((((((((((((((^((((((((((((((((( .....:.(((..??^^!^!..!(^...(((((^.^((((...........:.(((..??^ .....(.((.........((.(((.((((((!(.................(.((...... (..(^((((((((^.........((((((.(..............(..(^((((((((^. .(((((((((((((^.......((((((((...!^.^!...(..:.(((((((((((((^ ((.((((((((((((.....:((((((((^^((^.?^(^^.....((.(((((((((((( ((((((((((((((((.:(((((((((((................((((((((((((((( ((((((((((^((((((.((.(((((((....:....((..^(((((((((((((^(((( ^((((((((((((((((((.((((((((^:(...(^(((.((^^(^(((((((((((((( ((((((((((((((((((((.?!((((((((.....((((((((?((((((((((((((( ((.(((((((((((((((((.....((((((?...((((((((((((.(((((((((((( (^((((((((((((((((((.....(((((((.(.(((((((((((^((((((((((((( ....(((((((((((((((((?...(((((((.((((((((((((....((((((((((( ....(((((((((((((((((...(((((((((:((((((((((.....((((((((((( (((.(((((((((((((((((..(((((((((((((((((((((((((.((((((((((( (((((((((((((((((((((.(((((((((((((((((((((((((((((((((((((( (((((((((((((((((((((^(((((((((((((((((((((((((((((((((((((( (((((((((((((((((((((((((((((((((((((((((((((((((((((((((((( ....^((((((((((((((((?(((((((((((((....(.........^(((((((((( .....^((((...........(((((........................^((((..... ............................................................
Render a Map to an text file using the ASCII Renderer
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
countries.style = new Fill("#ffffff") + new Stroke("#b2b2b2", 0.5)
Layer ocean = workspace.get("ocean")
ocean.style = new Fill("#a5bfdd")
Map map = new Map(
width: 800,
height: 300,
layers: [ocean, countries]
)
ASCII ascii = new ASCII(width: 60)
File file = new File("map.txt")
FileOutputStream out = new FileOutputStream(file)
ascii.render(map, out)
out.close()(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((( (((((((((((((((^(^(.(:......((((((((((((((^((((((((((((((((( .....:.(((..??^^!^!..!(^...(((((^.^((((...........:.(((..??^ .....(.((.........((.(((.((((((!(.................(.((...... (..(^((((((((^.........((((((.(..............(..(^((((((((^. .(((((((((((((^.......((((((((...!^.^!...(..:.(((((((((((((^ ((.((((((((((((.....:((((((((^^((^.?^(^^.....((.(((((((((((( ((((((((((((((((.:(((((((((((................((((((((((((((( ((((((((((^((((((.((.(((((((....:....((..^(((((((((((((^(((( ^((((((((((((((((((.((((((((^:(...(^(((.((^^(^(((((((((((((( ((((((((((((((((((((.?!((((((((.....((((((((?((((((((((((((( ((.(((((((((((((((((.....((((((?...((((((((((((.(((((((((((( (^((((((((((((((((((.....(((((((.(.(((((((((((^((((((((((((( ....(((((((((((((((((?...(((((((.((((((((((((....((((((((((( ....(((((((((((((((((...(((((((((:((((((((((.....((((((((((( (((.(((((((((((((((((..(((((((((((((((((((((((((.((((((((((( (((((((((((((((((((((.(((((((((((((((((((((((((((((((((((((( (((((((((((((((((((((^(((((((((((((((((((((((((((((((((((((( (((((((((((((((((((((((((((((((((((((((((((((((((((((((((((( ....^((((((((((((((((?(((((((((((((....(.........^(((((((((( .....^((((...........(((((........................^((((..... ............................................................
Base64
Render a Map to an string using the Base64 Renderer
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
countries.style = new Fill("#ffffff") + new Stroke("#b2b2b2", 0.5)
Layer ocean = workspace.get("ocean")
ocean.style = new Fill("#a5bfdd")
Map map = new Map(
width: 800,
height: 300,
layers: [ocean, countries]
)
Base64 base64 = new Base64()
String base64Str = base64.render(map)
println base64Strimage/png;base64,iVBORw0KGgoAAAANSUhEUgAAAyAAAAEsC...
Render a Map to an text file using the Base64 Renderer
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
countries.style = new Fill("#ffffff") + new Stroke("#b2b2b2", 0.5)
Layer ocean = workspace.get("ocean")
ocean.style = new Fill("#a5bfdd")
Map map = new Map(
width: 800,
height: 300,
layers: [ocean, countries]
)
Base64 base64 = new Base64()
File file = new File("map.txt")
base64.render(map, new FileOutputStream(file))iVBORw0KGgoAAAANSUhEUgAAAyAAAAEsCAYAAAA7Ldc6AACAAE...
Render a Map to a PDF Document using the PDF Renderer
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
countries.style = new Fill("#ffffff") + new Stroke("#b2b2b2", 0.5)
Layer ocean = workspace.get("ocean")
ocean.style = new Fill("#a5bfdd")
Map map = new Map(
width: 800,
height: 300,
layers: [ocean, countries]
)
Pdf pdf = new Pdf()
com.lowagie.text.Document document = pdf.render(map)
Render a Map to a PDF file using the PDF Renderer
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
countries.style = new Fill("#ffffff") + new Stroke("#b2b2b2", 0.5)
Layer ocean = workspace.get("ocean")
ocean.style = new Fill("#a5bfdd")
Map map = new Map(
width: 800,
height: 300,
layers: [ocean, countries]
)
Pdf pdf = new Pdf()
File file = new File("map.pdf")
pdf.render(map, new FileOutputStream(file))SVG
Render a Map to a SVG Document using the SVG Renderer
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
countries.style = new Fill("#ffffff") + new Stroke("#b2b2b2", 0.5)
Layer ocean = workspace.get("ocean")
ocean.style = new Fill("#a5bfdd")
Map map = new Map(
width: 800,
height: 300,
layers: [ocean, countries]
)
Svg svg = new Svg()
org.w3c.dom.Document document = svg.render(map)
Render a Map to a SVG file using the SVG Renderer
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
countries.style = new Fill("#ffffff") + new Stroke("#b2b2b2", 0.5)
Layer ocean = workspace.get("ocean")
ocean.style = new Fill("#a5bfdd")
Map map = new Map(
width: 800,
height: 300,
layers: [ocean, countries]
)
Svg svg = new Svg()
File file = new File("map.svg")
FileOutputStream out = new FileOutputStream(file)
svg.render(map, out)
out.close()Displaying Maps
Finding Displayers
Get all Displayers
List<Displayer> displayers = Displayers.list()
displayers.each { Displayer displayer ->
println displayer.class.simpleName
}MapWindow Window
Get a Displayer
Displayer displayer = Displayers.find("window")
println displayer.class.simpleNameWindow
Window
Display a Map in a simple GUI
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
countries.style = new Fill("#ffffff") + new Stroke("#b2b2b2", 0.5)
Layer ocean = workspace.get("ocean")
ocean.style = new Fill("#a5bfdd")
Map map = new Map(
width: 800,
height: 300,
layers: [ocean, countries]
)
Window window = new Window()
window.display(map)
MapWindow
Display a Map in a interactive GUI
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
countries.style = new Fill("#ffffff") + new Stroke("#b2b2b2", 0.5)
Layer ocean = workspace.get("ocean")
ocean.style = new Fill("#a5bfdd")
Map map = new Map(
width: 800,
height: 300,
layers: [ocean, countries]
)
MapWindow window = new MapWindow()
window.display(map)
Drawing
The Draw class is an easy way to quickly render a Geometry, a List of Geometries, a Feature, or a Layer to an Image, a File, an OutputStream, or a GUI.
Drawing to a File or GUI
All of the draw methods take a single required parameter but can also take the following optional parameters:
-
style = A Style
-
bounds = The Bounds
-
size = The size of the canvas ([400,350])
-
out = The OutputStream, File, or File name. If null (which is the default) a GUI will be opened.
-
format = The format ("jpeg", "png", "gif")
-
proj = The Projection
Draw a Geometry to a File
File file = new File("geometry.png")
Geometry geometry = new Point(-122.376, 47.587).buffer(0.5)
Draw.draw(geometry,
style: new Fill("#ffffff") + new Stroke("#b2b2b2", 0.5),
bounds: new Bounds(-122.876,47.087,-121.876,48.087),
size: [400,400],
format: "png",
proj: "EPSG:4326",
backgroundColor: "#a5bfdd",
out: file
)
Draw a List of Geometries to an OuputStream
Point point = new Point(-122.376, 47.587)
List geometries = [1.5, 1.0, 0.5].collect { double distance ->
point.buffer(distance)
}
File file = new File("geometries.png")
OutputStream outputStream = new FileOutputStream(file)
Draw.draw(geometries, out: outputStream, format: "png")
outputStream.flush()
outputStream.close()
Draw a Feature to a file name
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer layer = workspace.get("states")
Feature feature = layer.first(filter: "NAME_1='Washington'")
Draw.draw(feature, bounds: feature.bounds, out: "feature.png")
Draw a Layer to a GUI
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer layer = workspace.get("states")
layer.style = new Fill("LightSteelBlue") + new Stroke("LightSlateGrey", 0.25)
Draw.draw(layer, bounds: layer.bounds)
Draw a Raster to a File
File file = new File("earth.png")
Raster raster = new geoscript.layer.GeoTIFF(new File('src/main/resources/earth.tif')).read()
Draw.draw(raster, bounds: raster.bounds, size: [400,200], out: file)
Drawing to an Image
All of the drawToImage methods take a single required parameter but can also take the following optional parameters:
-
style = A Style
-
bounds = The Bounds
-
size = The size of the canvas ([400,350])
-
imageType = The format ("jpeg", "png", "gif")
-
proj = The Projection
Draw a Geometry to an Image
Geometry geometry = new Point(-122.376, 47.587).buffer(0.5)
BufferedImage image = Draw.drawToImage(geometry,
style: new Fill("#ffffff") + new Stroke("#b2b2b2", 0.5),
bounds: new Bounds(-122.876,47.087,-121.876,48.087),
size: [400,400],
imageType: "png",
proj: "EPSG:4326",
backgroundColor: "#a5bfdd"
)
Draw a List of Geometries to an Image
Point point = new Point(-122.376, 47.587)
List geometries = [1.5, 1.0, 0.5].collect { double distance ->
point.buffer(distance)
}
BufferedImage image = Draw.drawToImage(geometries)
Draw a Feature to an Image
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer layer = workspace.get("states")
Feature feature = layer.first(filter: "NAME_1='Washington'")
BufferedImage image = Draw.drawToImage(feature, bounds: feature.bounds)
Draw a Layer to an Image
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer layer = workspace.get("states")
layer.style = new Fill("LightSteelBlue") + new Stroke("LightSlateGrey", 0.25)
BufferedImage image = Draw.drawToImage(layer, bounds: layer.bounds)
Draw a Raster to an Image
Raster raster = new geoscript.layer.GeoTIFF(new File('src/main/resources/earth.tif')).read()
BufferedImage image = Draw.drawToImage(raster, bounds: raster.bounds, size: [400,200])
Plotting
Plotting to a File or GUI
The Plot module can plot a Geometry, a list of Geometries, a Feature, or a Layer to a File, a File name, an OutputStream, or a simple GUI.
Plot a Geometry to a File
File file = new File("geometry.png")
Geometry geometry = new Point(-122.376, 47.587).buffer(0.5)
Plot.plot(geometry, out: file)
Plot a List of Geometries to an OutputStream
Point point = new Point(-122.376, 47.587)
List geometries = [1.5, 1.0, 0.5].collect { double distance ->
point.buffer(distance)
}
File file = new File("geometries.png")
OutputStream outputStream = new FileOutputStream(file)
Plot.plot(geometries, out: outputStream)
outputStream.flush()
outputStream.close()
Plot a Feature to a File name
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer layer = workspace.get("states")
Feature feature = layer.first(filter: "NAME_1='Washington'")
Plot.plot(feature, out: "feature.png")
Plot a Layer to a GUI
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer layer = workspace.get("states")
Plot.plot(layer)
Plotting to an Image
The Plot module can plot a Geometry, a list of Geometries, a Feature, or a Layer to an image.
Plot a Geometry to an Image
Geometry geometry = new Point(-122.376, 47.587).buffer(0.5)
BufferedImage image = Plot.plotToImage(geometry, size: [400,400],)
Plot a List of Geometries to an Image
Point point = new Point(-122.376, 47.587)
List geometries = [1.5, 1.0, 0.5].collect { double distance ->
point.buffer(distance)
}
BufferedImage image = Plot.plotToImage(geometries)
Plot a Feature to an Image
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer layer = workspace.get("states")
Feature feature = layer.first(filter: "NAME_1='Washington'")
BufferedImage image = Plot.plotToImage(feature, bounds: feature.bounds)
Plot a Layer to an Image
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer layer = workspace.get("states")
BufferedImage image = Plot.plotToImage(layer, bounds: layer.bounds)
Style Recipes
Styles are found in the geoscript.style package.
Styles are made up Symbolizers and Composites. A Symbolizer is a particular style like Stroke or Fill. Symbolizers also have methods for controlling the drawing order (zindex), the min and max scale (range), and filtering (where).
Creating Basic Styles
Fill fill = new Fill("#6B8E23")
A Composite is simply two or more Symbolizers. So, a Composite would be a combination of a Stroke symbolizer (to style the boundary) and a Fill Symbolizer (to style the interior).
Composite composite = new Fill("#6B8E23") + new Stroke("black", 0.75)
A Symbolizer can use the where method to restrict which features are styled.
Symbolizer symbolizer = new Fill("#ffffcc").where("PEOPLE < 4504128.33") +
new Fill("#41b6c4").where("PEOPLE BETWEEN 4504128.33 AND 16639804.33") +
new Fill("#253494").where("PEOPLE > 16639804.33")
The zindex method is used to order Symbolizers on top of each other. In this recipe we use it to create line casings.
Symbolizer symbolizer = new Stroke("black", 2.0).zindex(0) + new Stroke("white", 0.1).zindex(1)
The scale method is used to create Symbolizers that are dependent on map scale.
Symbolizer symbolizer = (new Fill("white") + new Stroke("black", 0.1)) + new Label("NAME_1")
.point(anchor: [0.5,0.5])
.polygonAlign("mbr")
.range(max: 16000000)
Creating Strokes
Create a Stroke Symbolizer with a Color
Stroke stroke = new Stroke("#1E90FF")
Create a Stroke Symbolizer with a Color and Width
Stroke stroke = new Stroke("#1E90FF", 0.5)
Create a Stroke Symbolizer with casing
Symbolizer stroke = new Stroke(color: "#333333", width: 5, cap: "round").zindex(0) +
new Stroke(color: "#6699FF", width: 3, cap: "round").zindex(1)
Create a Stroke Symbolizer with Dashes
Stroke stroke = new Stroke("#1E90FF", 0.75, [5,5], "round", "bevel")
Create a Stroke Symbolizer with railroad Hatching
Symbolizer stroke = new Stroke("#1E90FF", 1) + new Hatch("vertline", new Stroke("#1E90FF", 0.5), 6).zindex(1)
Create a Stroke Symbolizer with spaced Shape symbols
Symbolizer stroke = new Stroke(width: 0, dash: [4, 4]).shape(new Shape("#1E90FF", 6, "circle").stroke("navy", 0.75))
Create a Stroke Symbolizer with alternating spaced Shape symbols
Symbolizer stroke = new Stroke("#0000FF", 1, [10,10]).zindex(0) + new Stroke(null, 0, [[5,15],7.5])
.shape(new Shape(null, 5, "circle").stroke("#000033",1)).zindex(1)
Creating Fills
Create a Fill Symbolizer with a Color
Fill fill = new Fill("#6B8E23")
Create a Fill Symbolizer with a Color and a Stroke
Symbolizer symbolizer = new Fill("#6B8E23") + new Stroke("black", 0.1)
Create a Fill Symbolizer with a Color and Opacity
Fill fill = new Fill("#6B8E23", 0.35)
Create a Fill Symbolizer from named parameters
Fill fill = new Fill(color: "wheat", opacity: 0.75)
Create a Fill Symbolizer with an Icon
Fill fill = new Fill("green").icon('src/main/resources/trees.png', 'image/png')
Create a Fill Symbolizer with a Hatch
Fill fill = new Fill("green").hatch("slash", new Stroke("green", 0.25), 8)
Create a Fill Symbolizer with a random fill
Symbolizer symbolizer = new Fill("white").hatch("circle", new Fill("black"), 2).random(
random: "free",
seed: 0,
symbolCount: 50,
tileSize: 50,
rotation: "none"
) + new Stroke("black", 0.25)
Creating Shapes
Create a Shape Symbolizer with a Color
Shape shape = new Shape("navy")
Create a Shape Symbolizer with a color, size, type, opacity and angle
Shape shape = new Shape("#9370DB", 8, "triangle", 0.75, 45)
Create a Shape Symbolizer with named parameters
Shape shape = new Shape(color: "#8B4513", size: 10, type: "star", opacity: 1.0, rotation: 0)
Create a Shape Symbolizer with Stroke outline
Symbolizer symbolizer = new Shape("white", 10).stroke("navy", 0.5)
Creating Icons
Create an Icon Symbolizer
Symbolizer symbolizer = new Icon("src/main/resources/place.png", "image/png", 12)
Create an Icon Symbolizer
Symbolizer symbolizer = new Icon(url: "src/main/resources/place.png", format: "image/png", size: 10)
Creating Labels
Create a Label for a Point Layer
Symbolizer symbolizer = new Shape("blue", 6).stroke("navy", 0.5) + new Label("NAME").point(
[0.5,0.5], (1)
[0, 5.0], (2)
0 (3)
)| 1 | anchor |
| 2 | displacement |
| 3 | rotation |
Create a Label for a Point Layer with a Font
Symbolizer symbolizer = new Shape("blue", 6).stroke("navy", 0.5) + new Label("NAME").point(
[0.5,0.5],
[0, 5.0],
0
) + new Font(
"normal", (1)
"bold", (2)
12, (3)
"Arial" (4)
)| 1 | style (normal, italic, oblique) |
| 2 | weight (normal, bold) |
| 3 | size (8,12,16,ect..) |
| 4 | family (serif, arial, verdana) |
Create a Label for a Point Layer with Halo
Symbolizer symbolizer = new Shape("blue", 6).stroke("navy", 0.5) + new Label("NAME").point(
[0.5,0.5],
[0, 5.0],
0
).fill(new Fill("white")) + new Halo(new Fill("navy"), 2.5)
Create a Label for a Polygon Layer
Symbolizer symbolizer = new Fill("white") + new Stroke("black", 0.1) + new Label("NAME_1")
.point(anchor: [0.5,0.5])
.polygonAlign("mbr")
Create a Label for a Polygon Layer using an Expression
Symbolizer symbolizer = new Fill("white") + new Stroke("black", 0.1) + new Label(Expression.fromCQL("strToLowerCase(NAME_1)"))
.point(anchor: [0.5,0.5])
.polygonAlign("mbr")
Create a Label for a Polygon Layer using an Expression that concatenates properties and strings.
Expression expression = Expression.fromCQL("Concatenate(z, '/', x, '/', y)")
Symbolizer symbolizer = new Stroke("black", 1.0) + new Label(expression)
Create a Label for a Polygon Layer with strike through style.
Symbolizer symbolizer = new Fill("white") + new Stroke("black", 0.1) + new Label("NAME_1")
.point(anchor: [0.5,0.5])
.polygonAlign("mbr")
.strikethrough(true)
Create a Label for a Polygon Layer with word and character spacing.
Symbolizer symbolizer = new Fill("white") + new Stroke("black", 0.1) + new Label("NAME_1")
.point(anchor: [0.5,0.5])
.polygonAlign("mbr")
.wordSpacing(8)
.characterSpacing(5)
Create a Label for a Polygon Layer with underlining.
Symbolizer symbolizer = new Fill("white") + new Stroke("black", 0.1) + new Label("NAME_1")
.point(anchor: [0.5,0.5])
.polygonAlign("mbr")
.underline(true)
Create a Label for a Line Layer
Symbolizer symbolizer = new Stroke("blue", 0.75) + new Label("name")
.fill(new Fill("navy"))
.linear(follow: true, offset: 50, displacement: 200, repeat: 150).maxDisplacement(400).maxAngleDelta(90)
.halo(new Fill("white"), 2.5)
.font(new Font(size: 10, weight: "bold"))
Creating Transforms
Create a normal Transform symbolizer that styles a polygon as a point by calculating it’s centroid
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
Symbolizer symbolizer = new Transform("centroid(the_geom)") +
new Shape(color: "red", size: 10, type: "star")
countries.style = symbolizer
Create a rendering Transform symbolizer that styles a point layer by calculating the convex hull
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer places = workspace.get("places")
Process process = new Process("convexhull",
"Create a convexhull around the features",
[features: geoscript.layer.Cursor],
[result: geoscript.layer.Cursor],
{ inputs ->
def geoms = new GeometryCollection(inputs.features.collect{ f -> f.geom})
def output = new Layer()
output.add([geoms.convexHull])
[result: output]
}
)
Function function = new Function(process, new Function("parameter", new Expression("features")))
Symbolizer symbolizer = new Transform(function, Transform.RENDERING) + new Fill("aqua", 0.75) + new Stroke("navy", 0.5)
places.style = symbolizer
Creating Gradients
Create a Gradient Symbolizer from a Layer’s Field using quantile method
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
Gradient gradient = new Gradient(countries, "PEOPLE", "quantile", 8, "Greens")
countries.style = gradient
Create a Gradient Symbolizer from a Layer’s Field using equal interval method
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
Gradient gradient = new Gradient(countries, "PEOPLE", "equalinterval", 3, "Reds")
countries.style = gradient
Create a custom Gradient Symbolizer between Symbolizers and values
Gradient gradient = new Gradient(
new Property("POP2020"),
[0, 10000, 20000, 30000],
[
new Shape("white", 4).stroke("black", 0.5),
new Shape("#b0d2e8", 8).stroke("black", 0.5),
new Shape("#3e8ec4", 16).stroke("black", 0.5),
new Shape("#08306b", 24).stroke("black", 0.5)
],
5,
"linear"
)
Creating Unique Values
Create a Unique Values Symbolizer from a Layer’s Field
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
UniqueValues uniqueValues = new UniqueValues(countries, "NAME")
countries.style = uniqueValues
Create a Unique Values Symbolizer from a Layer’s Field and a Closure
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
UniqueValues uniqueValues = new UniqueValues(countries, "NAME", {int index, String value -> Color.getRandom()})
countries.style = uniqueValues
Create a Unique Values Symbolizer from a Layer’s Field and a color palette
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
UniqueValues uniqueValues = new UniqueValues(countries, "NAME", "LightPurpleToDarkPurpleHeatMap")
countries.style = uniqueValues
Create a Unique Values Symbolizer from a File with a color per value
Workspace workspace = new Directory("src/main/resources/mars")
Layer marsGeology = workspace.get("geo_units_oc_dd")
File uniqueValuesFile = new File("src/main/resources/mars/I1802ABC_geo_units_RGBlut.txt")
UniqueValuesReader styleReader = new UniqueValuesReader("UnitSymbol", "polygon")
Symbolizer symbolizer = styleReader.read(uniqueValuesFile)Unit,R,G,B AHa,175,0,111 AHat,192,54,22 AHcf,150,70,72 AHh,109,13,60 AHpe,232,226,82 AHt,99,0,95 AHt3,233,94,94 Aa1,255,236,207 Aa2,145,73,76 Aa3,254,212,164 Aa4,212,109,19 Aa5,175,66,28
Creating Color Maps
Create a ColorMap Symbolizer for a Raster using a list of Colors
Format format = new GeoTIFF(new File('src/main/resources/pc.tif'))
Raster raster = format.read()
ColorMap colorMap = new ColorMap([
[color: "#9fd182", quantity:25],
[color: "#3e7f3c", quantity:470],
[color: "#133912", quantity:920],
[color: "#08306b", quantity:1370],
[color: "#fffff5", quantity:1820],
])
raster.style = colorMap
Create a ColorMap Symbolizer for a Raster using a list of Colors with opacity
Format format = new GeoTIFF(new File('src/main/resources/pc.tif'))
Raster raster = format.read()
ColorMap colorMap = new ColorMap([
[color: "#9fd182", quantity:25],
[color: "#3e7f3c", quantity:470],
[color: "#133912", quantity:920],
[color: "#08306b", quantity:1370],
[color: "#fffff5", quantity:1820],
]).opacity(0.25)
raster.style = colorMap
Create a ColorMap Symbolizer for a Raster using a color palette
Format format = new GeoTIFF(new File('src/main/resources/pc.tif'))
Raster raster = format.read()
ColorMap colorMap = new ColorMap(
25, (1)
1820, (2)
"MutedTerrain", (3)
5 (4)
)
println colorMap
raster.style = colorMap| 1 | min value |
| 2 | max value |
| 3 | color palette name |
| 4 | number of categories |
Create a ColorMap Symbolizer with intervals for a Raster using a list of Colors
Format format = new GeoTIFF(new File('src/main/resources/pc.tif'))
Raster raster = format.read()
ColorMap colorMap = new ColorMap([
[color: "#9fd182", quantity:25],
[color: "#3e7f3c", quantity:470],
[color: "#133912", quantity:920],
[color: "#08306b", quantity:1370],
[color: "#fffff5", quantity:1820],
], "intervals", true)
raster.style = colorMap
Creating Channel Selection and Contrast Enhancement
Create a Raster Symbolizer using ChannelSelection and ContrastEnhancement using the normalize method
Format format = new GeoTIFF(new File('src/main/resources/pc.tif'))
Raster raster = format.read()
Symbolizer symbolizer = new ChannelSelection()
.gray("1", new ContrastEnhancement("normalize"))
raster.style = symbolizer
Create a Raster Symbolizer using ChannelSelection and ContrastEnhancement using the histogram method
Format format = new GeoTIFF(new File('src/main/resources/pc.tif'))
Raster raster = format.read()
Symbolizer symbolizer = new ChannelSelection()
.gray("1", new ContrastEnhancement("histogram", 0.65))
raster.style = symbolizer
Reading and Writing Styles
Style Readers and Writers are found in the geoscript.style.io package.
Finding Style Readers and Writers
List all Style Writers
List<Writer> writers = Writers.list()
writers.each { Writer writer ->
println writer.class.simpleName
}SLDWriter ColorTableWriter YSLDWriter
Find a Style Writer
Writer writer = Writers.find("sld")
println writer.class.simpleNameSLDWriter
List all Style Readers
List<Reader> readers = Readers.list()
readers.each { Reader reader ->
println reader.class.simpleName
}SLDReader CSSReader ColorTableReader YSLDReader SimpleStyleReader
Find a Style Reader
Reader reader = Readers.find("sld")
println reader.class.simpleNameSLDReader
SLD
GeoScript Groovy can read and write Style Layer Descriptor (SLD) documents.
Write a Symbolizer to SLD
Symbolizer symbolizer = new Fill("white") + new Stroke("black", 0.5)
SLDWriter writer = new SLDWriter()
String sld = writer.write(symbolizer)
println sld<?xml version="1.0" encoding="UTF-8"?><sld:StyledLayerDescriptor xmlns="http://www.opengis.net/sld" xmlns:sld="http://www.opengis.net/sld" xmlns:gml="http://www.opengis.net/gml" xmlns:ogc="http://www.opengis.net/ogc" version="1.0.0">
<sld:UserLayer>
<sld:LayerFeatureConstraints>
<sld:FeatureTypeConstraint/>
</sld:LayerFeatureConstraints>
<sld:UserStyle>
<sld:Name>Default Styler</sld:Name>
<sld:FeatureTypeStyle>
<sld:Name>name</sld:Name>
<sld:Rule>
<sld:PolygonSymbolizer>
<sld:Fill>
<sld:CssParameter name="fill">#ffffff</sld:CssParameter>
</sld:Fill>
</sld:PolygonSymbolizer>
<sld:LineSymbolizer>
<sld:Stroke>
<sld:CssParameter name="stroke-width">0.5</sld:CssParameter>
</sld:Stroke>
</sld:LineSymbolizer>
</sld:Rule>
</sld:FeatureTypeStyle>
</sld:UserStyle>
</sld:UserLayer>
</sld:StyledLayerDescriptor>
Read a Style from an SLD String
String sld = """<?xml version="1.0" encoding="UTF-8"?>
<sld:StyledLayerDescriptor xmlns="http://www.opengis.net/sld" xmlns:sld="http://www.opengis.net/sld" xmlns:ogc="http://www.opengis.net/ogc" xmlns:gml="http://www.opengis.net/gml" version="1.0.0">
<sld:UserLayer>
<sld:LayerFeatureConstraints>
<sld:FeatureTypeConstraint/>
</sld:LayerFeatureConstraints>
<sld:UserStyle>
<sld:Name>Default Styler</sld:Name>
<sld:FeatureTypeStyle>
<sld:Name>name</sld:Name>
<sld:Rule>
<sld:PolygonSymbolizer>
<sld:Fill>
<sld:CssParameter name="fill">#ffffff</sld:CssParameter>
</sld:Fill>
</sld:PolygonSymbolizer>
<sld:LineSymbolizer>
<sld:Stroke>
<sld:CssParameter name="stroke">#000000</sld:CssParameter>
<sld:CssParameter name="stroke-width">0.5</sld:CssParameter>
</sld:Stroke>
</sld:LineSymbolizer>
</sld:Rule>
</sld:FeatureTypeStyle>
</sld:UserStyle>
</sld:UserLayer>
</sld:StyledLayerDescriptor>
"""
SLDReader reader = new SLDReader()
Style style = reader.read(sld)
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
countries.style = style
CSS
GeoScript Groovy can only read CSS documents.
Read a Style from an CSS String
String css = """
* {
fill: #eeeeee;
fill-opacity: 1.0;
stroke: #000000;
stroke-width: 1.2;
}
"""
CSSReader reader = new CSSReader()
Style style = reader.read(css)
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
countries.style = style
YSLD
GeoScript Groovy can read and write YAML Style Layer Descriptors (YSLD) documents.
Write a Symbolizer to YSLD
Symbolizer symbolizer = new Fill("white") + new Stroke("black", 0.5)
YSLDWriter writer = new YSLDWriter()
String ysld = writer.write(symbolizer)
println ysldname: Default Styler
feature-styles:
- name: name
rules:
- scale: [min, max]
symbolizers:
- polygon:
fill-color: '#FFFFFF'
- line:
stroke-color: '#000000'
stroke-width: 0.5
Read a Style from an YAML Style Layer Descriptors (YSLD) String
String ysld = """
name: Default Styler
feature-styles:
- name: name
rules:
- scale: [min, max]
symbolizers:
- polygon:
fill-color: '#FFFFFF'
- line:
stroke-color: '#000000'
stroke-width: 0.5
"""
YSLDReader reader = new YSLDReader()
Style style = reader.read(ysld)
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
countries.style = style
Simple Style Reader
A SimpleStyleReader that can easily create simple Styles using Maps or Strings.
-
Fill properties: fill and fill-opacity
-
Stroke properties: stroke, stroke-width, stroke-opacity
-
Shape properties: shape, shape-size, shape-type
-
Label properties: label-size, label-style, label-weight, label-family
Read a Style with fill and stroke properties from a Simple Style String
String str = "fill=#555555 fill-opacity=0.6 stroke=#555555 stroke-width=0.5"
SimpleStyleReader reader = new SimpleStyleReader()
Style style = reader.read(str)
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
countries.style = style
Read a Style with fill, stroke, and label properties from a Simple Style String
String str = "fill=white stroke=navy label=NAME label-size=10"
SimpleStyleReader reader = new SimpleStyleReader()
Style style = reader.read(str)
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
countries.style = style
Read a Style with shape properties from a Simple Style String
String str = "shape-type=circle shape-size=8 shape=orange"
SimpleStyleReader reader = new SimpleStyleReader()
Style style = reader.read(str)
println style
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer places = workspace.get("places")
places.style = style
Read a Style with fill and stroke properties from a Simple Style Map
Map map = [
'fill': '#555555',
'fill-opacity': 0.6,
'stroke': '#555555',
'stroke-width': 0.5
]
SimpleStyleReader reader = new SimpleStyleReader()
Style style = reader.read(map)
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
countries.style = style
Color Table
GeoScript Groovy can read and write color table strings and files. This format can be used with ColorMaps to style Rasters.
Write a ColorMap to a color table string
ColorMap colorMap = new ColorMap(25, 1820, "BoldLandUse", 5)
ColorTableWriter writer = new ColorTableWriter()
String str = writer.write(colorMap)
println str25.0 178 156 195 473.75 79 142 187 922.5 143 146 56 1371.25 193 132 55 1820.0 181 214 177
Read a ColorMap from a color table string
Format format = new GeoTIFF(new File('src/main/resources/pc.tif'))
Raster raster = format.read()
ColorTableReader reader = new ColorTableReader()
ColorMap colorMap = reader.read("""25.0 178 156 195
473.75 79 142 187
922.5 143 146 56
1371.25 193 132 55
1820.0 181 214 177
""")
raster.style = colorMap
Workspace Recipes
The Workspace classes are in the geoscript.workspace package.
A Workspace is a collection of Layers. You can create, add, remove, and get Layers. There are many different kinds of Workspaces in GeoScript including Memory, PostGIS, Directory (for Shapefiles), GeoPackage, and many more.
Using Workspaces
Create a Workspace
Workspace workspace = new Workspace()Create a Layer
Schema schema = new Schema("cities", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String")
])
Layer layer = workspace.create(schema)
println layercities
Check whether a Workspace has a Layer by name
boolean hasCities = workspace.has("cities")
println hasCitiestrue
Get a Layer from a Workspace
Layer citiesLayer = workspace.get('cities')
println citiesLayercities
Add a Layer to a Workspace
Schema statesSchema = new Schema("states", [
new Field("geom", "Polygon", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String")
])
Layer statesLayer = new Layer("states", statesSchema)
workspace.add(statesLayer)
println workspace.has("states")true
Get the names of all Layers in a Workspace
List<String> names = workspace.names
names.each { String name ->
println name
}Directory of spatial files (shapefiles) PostGIS (JNDI) H2 (JNDI) SQLite PostGIS MySQL (JNDI) GeoPackage MySQL Geobuf H2 Shapefile Web Feature Server (NG) Properties
Remove a Layer from a Workspace
workspace.remove("cities")
println workspace.has('cities')false
Close the Workspace when you are done
workspace.close()Creating an in Memory Workspace
The empty Workspace constructor creates an in Memory Workspace. You can create a Layer by passing a name and a list of Fields. You can then remove the Layer by passing a reference to the Layer.
Workspace workspace = new Workspace()
Layer layer = workspace.create("cities", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String")
])
println layer
workspace.remove(layer)
println workspace.has(layer.name)cities false
Add Layer’s Features in Chunks
When adding a large Layer to a Workspace, you can add Features in chunks.
Workspace workspace = new Memory()
Layer layer = workspace.create("points", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer")
])
Bounds bounds = new Bounds(-180,-90, 180,90, "EPSG:4326")
Geometry.createRandomPoints(bounds.geometry, 500).geometries.eachWithIndex { Geometry geom, int i ->
layer.add([geom: geom, id: i])
}
println "Original Layer has ${layer.count} features."
Layer copyOfLayer = workspace.add(layer, "random points", 100)
println "Copied Layer has ${copyOfLayer.count} features."Original Layer has 500 features. Copied Layer has 500 features.
Using a Directory Workspace
A Directory Workspace is a directory of Shapefiles.
Create a Directory Workspace
Directory directory = new Directory("src/main/resources/data")
println directory.toString()Directory[/Users/jericks/Projects/geoscript-cookbook/src/main/resources/data]
View the Workspace’s format
String format = directory.format
println formatDirectory
View the Workspace’s File
File file = directory.file
println file/Users/jericks/Projects/geoscript-cookbook/src/main/resources/data
View the Workspace’s list of Layer names
List names = directory.names
names.each { String name ->
println name
}states
Get a Layer by name
Layer layer = directory.get("states")
int count = layer.count
println "Layer ${layer.name} has ${count} Features."Layer states has 49 Features.
Close the Directory when done.
directory.close()Investigating Workspaces
Get available Workspace names
List<String> names = Workspace.getWorkspaceNames()
names.each { String name ->
println name
}Directory of spatial files (shapefiles) PostGIS (JNDI) H2 (JNDI) SQLite PostGIS MySQL (JNDI) GeoPackage MySQL Geobuf H2 Shapefile Web Feature Server (NG) Properties
Get parameters for a Workspace
List<Map> parameters = Workspace.getWorkspaceParameters("GeoPackage")
parameters.each { Map param ->
println "Parameter = ${param.key} Type = ${param.type} Required? ${param.required}"
}Parameter = dbtype Type = java.lang.String Required? true Parameter = database Type = java.io.File Required? true Parameter = passwd Type = java.lang.String Required? false Parameter = namespace Type = java.lang.String Required? false Parameter = Expose primary keys Type = java.lang.Boolean Required? false Parameter = fetch size Type = java.lang.Integer Required? false Parameter = Batch insert size Type = java.lang.Integer Required? false Parameter = Primary key metadata table Type = java.lang.String Required? false Parameter = Session startup SQL Type = java.lang.String Required? false Parameter = Session close-up SQL Type = java.lang.String Required? false Parameter = Callback factory Type = java.lang.String Required? false
Creating Workspaces
Creating a Workspace from a connection string
You can create a Workspace from a connection string that contains paramters in key=value format with optional single quotes.
Create a Shapefile Workspace
String connectionString = "url='states.shp' 'create spatial index'=true"
Workspace workspace = Workspace.getWorkspace(connectionString)Create a GeoPackage Workspace
connectionString = "dbtype=geopkg database=layers.gpkg"
workspace = Workspace.getWorkspace(connectionString)Create a H2 Workspace
connectionString = "dbtype=h2 database=layers.db"
workspace = Workspace.getWorkspace(connectionString)You can use the withWorkspace method to automatically handle closing the Workspace.
Workspace.withWorkspace("dbtype=geopkg database=src/main/resources/data.gpkg") { Workspace workspace ->
println workspace.format
println "----------"
workspace.names.each { String name ->
println "${name} (${workspace.get(name).count})"
}
}GeoPackage --------- countries (177) ocean (2) places (326) rivers (460) states (52)
Creating a Workspace from a connection map
You can create a Workspace from a connection map that contains paramters.
Create a H2 Workspace
Map params = [dbtype: 'h2', database: 'test.db']
Workspace workspace = Workspace.getWorkspace(params)Create a PostGIS Workspace
params = [
dbtype: 'postgis',
database: 'postgres',
host: 'localhost',
port: 5432,
user: 'postgres',
passwd: 'postgres'
]
workspace = Workspace.getWorkspace(params)Create a GeoBuf Workspace
params = [file: 'layers.pbf', precision: 6, dimension:2]
workspace = Workspace.getWorkspace(params)You can use the withWorkspace method to automatically handle closing the Workspace.
Workspace.withWorkspace([dbtype: 'geopkg', database: 'src/main/resources/data.gpkg']) { Workspace workspace ->
println workspace.format
println "----------"
workspace.names.each { String name ->
println "${name} (${workspace.get(name).count})"
}
}GeoPackage --------- countries (177) ocean (2) places (326) rivers (460) states (52)
Creating Directory Workspaces
Create a Directory Workspace from a directory name
Workspace workspace = new Directory("src/main/resources/shapefiles")
println workspace.format
println "---------"
workspace.names.each { String name ->
println "${name} (${workspace.get(name).count})"
}Directory --------- ocean (2) countries (177)
Create a Directory Workspace from a File directory
Workspace workspace = new Directory(new File("src/main/resources/shapefiles"))
println workspace.format
println "---------"
workspace.names.each { String name ->
println "${name} (${workspace.get(name).count})"
}Directory --------- ocean (2) countries (177)
Create a Directory Workspace from a URL
Directory directory = Directory.fromURL(
new URL("http://www.naturalearthdata.com/http//www.naturalearthdata.com/download/110m/cultural/ne_110m_admin_0_countries.zip"),
new File("naturalearth")
)
println directory.format
println "---------"
directory.names.each { String name ->
println "${name} (${directory.get(name).count})"
}Directory --------- ne_110m_admin_0_countries (177)
Creating GeoPackage Workspaces
Create a GeoPackage Workspace from a file name
Workspace workspace = new GeoPackage("src/main/resources/data.gpkg")
println workspace.format
println "----------"
workspace.names.each { String name ->
println "${name} (${workspace.get(name).count})"
}GeoPackage ---------- countries (177) ocean (2) places (326) rivers (460) states (52)
Create a GeoPackage Workspace from a File
Workspace workspace = new GeoPackage(new File("src/main/resources/data.gpkg"))
println workspace.format
println "----------"
workspace.names.each { String name ->
println "${name} (${workspace.get(name).count})"
}GeoPackage ---------- countries (177) ocean (2) places (326) rivers (460) states (52)
Creating H2 Workspaces
Create a H2 Workspace from a File
Workspace workspace = new H2(new File("src/main/resources/h2/data.db"))
println workspace.format
println "--"
workspace.names.each { String name ->
println "${name} (${workspace.get(name).count})"
}H2 -- countries (177) ocean (2) places (326) states (52)
Create a H2 Workspace with basic parameters
H2 h2 = new H2(
"database", (1)
"localhost", (2)
"5421", (3)
"geo", (4)
"user", (5)
"password" (6)
)| 1 | Database name |
| 2 | Host name |
| 3 | Port |
| 4 | User name |
| 5 | Password |
Create a H2 Workspace with named parameters. Only the database name is required.
H2 h2 = new H2("database",
"host": "localhost",
"port": "5412",
"schema": "geo",
"user": "user",
"password": "secret"
)Creating Geobuf Workspaces
Create a Geobuf Workspace from a File
Workspace workspace = new Geobuf(new File("src/main/resources/geobuf"))
println workspace.format
println "------"
workspace.names.each { String name ->
println "${name} (${workspace.get(name).count})"
}Geobuf ------ countries (177) ocean (2) places (326)
Creating Property Workspaces
Create a Property Workspace from a File
Workspace workspace = new Property(new File("src/main/resources/property"))
println workspace.format
println "--------"
workspace.names.each { String name ->
println "${name} (${workspace.get(name).count})"
}Property ------ circles (10) places (10)
Creating SQLite Workspaces
Create a SQLite Workspace from a File
Workspace workspace = new Sqlite(new File("src/main/resources/data.sqlite"))
println workspace.format
println "--------"
workspace.names.each { String name ->
println "${name} (${workspace.get(name).count})"
}Sqlite ------ countries (177) ocean (2) places (326) rivers (460) states (52)
Creating PostGIS Workspaces
Create a PostGIS Workspace with basic parameters
PostGIS postgis = new PostGIS(
"database", (1)
"localhost", (2)
"5432", (3)
"public", (4)
"user", (5)
"password" (6)
)| 1 | Database name |
| 2 | Host name |
| 3 | Port |
| 4 | Schema |
| 5 | User name |
| 6 | Password |
Create a PostGIS Workspace with advanced parameters
PostGIS postgis = new PostGIS(
"database", (1)
"localhost", (2)
"5432", (3)
"public", (4)
"user", (5)
"password", (6)
true, (7)
true, (8)
"OWNER geo TABLESPACE points" (9)
)| 1 | Database name |
| 2 | Host name |
| 3 | Port |
| 4 | Schema |
| 5 | User name |
| 6 | Password |
| 7 | Estimated Extent |
| 8 | Create Database |
| 9 | Create Database Params |
Create a PostGIS Workspace with named parameters. Only the database name is required.
PostGIS postgis = new PostGIS("database",
"host": "localhost",
"port": "5432",
"schema": "public",
"user": "user",
"password": "secret",
"estimatedExtent": false,
"createDatabase": false,
"createDatabaseParams": "OWNER geo TABLESPACE points"
)Delete a PostGIS database.
PostGIS.deleteDatabase(
"database", (1)
"localhost", (2)
"5432", (3)
"user", (4)
"password" (5)
)| 1 | Database name |
| 2 | Host name |
| 3 | Port |
| 4 | User name |
| 5 | Password |
Delete a PostGIS database with named parameters. Only the database name is required.
PostGIS.deleteDatabase("database",
"host": "localhost",
"port": "5432",
"user": "user",
"password": "secret"
)Creating MySQL Workspaces
Create a MySQL Workspace with basic parameters
MySQL mysql = new MySQL(
"database", (1)
"localhost", (2)
"3306", (3)
"user", (4)
"password" (5)
)| 1 | Database name |
| 2 | Host name |
| 3 | Port |
| 4 | User name |
| 5 | Password |
Create a MySQL Workspace with named parameters. Only the database name is required.
MySQL mysql = new MySQL("database",
"host": "localhost",
"port": "3306",
"user": "user",
"password": "secret"
)Creating SpatiaLite Workspaces
The SpatiaLite Workspace requires GDAL and OGR to be installed with Java support.
Create a SpatiaLite Workspace with a File name
SpatiaLite spatialite = new SpatiaLite("db.sqlite")Create a SpatiaLite Workspace with a File
File directory = new File("databases")
File file = new File("db.sqlite")
SpatiaLite spatialite = new SpatiaLite(file)Creating WFS Workspaces
Create a WFS Workspace with a URL
WFS wfs = new WFS("http://localhost:8080/geoserver/ows?service=wfs&version=1.1.0&request=GetCapabilities")Creating OGR Workspaces
The OGR Workspace requires GDAL and OGR to be installed with Java support.
On Ubuntu, you can install GDAL and OGR with the following commands:
sudo apt-get install gdal-bin
sudo apt-get install libgdal-javaDetermine if OGR is available.
boolean isAvailable = OGR.isAvailable()Get OGR Drivers.
Set<String> drivers = OGR.driversGet a Shapefile Workspace from OGR.
File file = new File("states.shp")
OGR ogr = new OGR("ESRI Shapefile", file.absolutePath)Get a SQLite Workspace from OGR
File file = new File("states.sqlite")
OGR ogr = new OGR("SQLite", file.absolutePath)Get a GeoJSON Workspace from OGR
File file = new File("states.json")
OGR ogr = new OGR("GeoJSON", file.absolutePath)Database Workspace
SQL
Run SQL queries directly against Databse Workspace (PostGIS, MySQL, H2)
Database workspace = new H2(new File("src/main/resources/h2/data.db"))
Sql sql = workspace.sqlCount the number of results
int numberOfPlaces = sql.firstRow("SELECT COUNT(*) as count FROM \"places\"").get("count") as int
println "# of Places = ${numberOfPlaces}"# of Places = 326
Calculate statistics
GroovyRowResult result = sql.firstRow("SELECT MIN(ELEVATION) as min_elev, MAX(ELEVATION) as max_elev, AVG(ELEVATION) as avg_elev FROM \"places\"")
println "Mininum Elevation = ${result.get('min_elev')}"
println "Maximum Elevation = ${result.get('max_elev')}"
println "Average Elevation = ${result.get('avg_elev')}"Mininum Elevation = 0.0 Maximum Elevation = 2320.0 Average Elevation = 30.085889570552148
Select rows
List<String> names = []
sql.eachRow "SELECT TOP 10 \"NAME\" FROM \"places\" ORDER BY \"NAME\" DESC ", {
names.add(it["NAME"])
}
names.each { String name ->
println name
}Zürich Zibo Zhengzhou Zagreb Yerevan Yaounde Yamoussoukro Xian Wuhan Windhoek
Execute spatial sql
Workspace memory = new Memory()
Layer layer = memory.create("places_polys", [new Field("buffer", "Polygon"), new Field("name", "String")])
sql.eachRow "SELECT ST_Buffer(\"the_geom\", 10) as buffer, \"NAME\" as name FROM \"places\"", {row ->
Geometry poly = Geometry.fromWKB(row.buffer as byte[])
layer.add([buffer: poly, name: row.NAME])
}
View
Create a new Layer from a SQL View
Database workspace = new H2(new File("src/main/resources/h2/data.db"))
Layer layer = workspace.createView(
"megacities", (1)
"SELECT * FROM \"places\" WHERE \"MEGACITY\" = '%mega%'", (2)
new Field("the_geom","Point","EPSG:4326"), (3)
params: [['mega', '1']] (4)
)
boolean hasLayer1 = workspace.has("megacities")
println "Does layer exist? ${hasLayer1}"| 1 | The layer name |
| 2 | The SQL Statement |
| 3 | The Geometry Field |
| 4 | Query Parameters |
Does layer exist? true
Remove the new Layer created from a SQL View
workspace.deleteView("megacities")
boolean hasLayer2 = workspace.has("megacities")
println "Does layer exist? ${hasLayer2}"Does layer exist? false
Index
Create an Index
Database workspace = new H2(new File("src/main/resources/h2/data.db"))
workspace.createIndex("places","name_idx","NAME",true)
workspace.createIndex("places","megacity_idx","MEGACITY",false)
workspace.createIndex("places","a3_idx", ["SOV_A3", "ADM0_A3"],false)Get an Index
List<Map> indexes = workspace.getIndexes("places")
indexes.each { Map index ->
println "Index name = ${index.name}, unique = ${index.unique}, attributes = ${index.attributes}"
}Index name = PRIMARY_KEY_C, unique = true, attributes = [fid] Index name = name_idx, unique = true, attributes = [NAME] Index name = a3_idx, unique = false, attributes = [SOV_A3, ADM0_A3] Index name = megacity_idx, unique = false, attributes = [MEGACITY]
Remove an Index
workspace.deleteIndex("places", "name_idx")
workspace.deleteIndex("places", "megacity_idx")
workspace.deleteIndex("places", "a3_idx")Layer Recipes
The Layer classes are in the geoscript.layer package.
A Layer is a collection of Features.
Getting a Layer’s Properties
Get a Layer from a Workspace and it’s name
Workspace workspace = new GeoPackage("src/main/resources/data.gpkg")
Layer layer = workspace.get("countries")
String name = layer.name
println "Name: ${name}"Name: countries
The Layer’s Format
String format = layer.format
println "Format: ${format}"Format: GeoPackage
Count the number of Features
int count = layer.count
println "# of Features: ${count}"# of Features: 177
Get the Layer’s Projection
Projection proj = layer.proj
println "Projection: ${proj}"Projection: EPSG:4326
Get the Bounds of the Layer
Bounds bounds = layer.bounds
println "Bounds: ${bounds}"Bounds: (-179.99999999999997,-90.00000000000003,180.00000000000014,83.64513000000002,EPSG:4326)
Get the minimum and maximum value from a Field.
Workspace workspace = new GeoPackage("src/main/resources/data.gpkg")
Layer layer = workspace.get("places")
Map<String,Double> minMax = layer.minmax("POP2050")
println "Minimum Population in 2050 = ${minMax.min}"
println "Maximum Population in 2050 = ${minMax.max}"Minimum Population in 2050 = 0.0 Maximum Population in 2050 = 36400.0
Calculate a histogram of values for a Field.
Workspace workspace = new GeoPackage("src/main/resources/data.gpkg")
Layer layer = workspace.get("places")
List<List<Double>> values = layer.histogram("POP2050", 10)
values.each { List<Double> value ->
println "${value[0]} - ${value[1]}"
}0.0 - 3640.0 3640.0 - 7280.0 7280.0 - 10920.0 10920.0 - 14560.0 14560.0 - 18200.0 18200.0 - 21840.0 21840.0 - 25480.0 25480.0 - 29120.0 29120.0 - 32760.0 32760.0 - 36400.0
Create a List of interpolated values for a Field using a linear algorithm
Workspace workspace = new GeoPackage("src/main/resources/data.gpkg")
Layer layer = workspace.get("places")
List<Double> values = layer.interpolate(
"POP2050", (1)
10, (2)
"linear" (3)
)
values.each { Double value ->
println value
}| 1 | Field Name |
| 2 | Number of classes |
| 3 | Algorithm |
0.0 3640.0 7280.0 10920.0 14560.0 18200.0 21840.0 25480.0 29120.0 32760.0 36400.0
Create a List of interpolated values for a Field using a exponetial algorithm
values = layer.interpolate(
"POP2050", (1)
8, (2)
"exp" (3)
)
values.each { Double value ->
println value
}| 1 | Field Name |
| 2 | Number of classes |
| 3 | Algorithm |
0.0 2.7165430207384107 12.81269202499939 50.33546414312058 189.79046097748173 708.0809561693237 2634.3298787896188 9793.31686835896 36399.99999999998
Create a List of interpolated values for a Field using a logarithmic algorithm
values = layer.interpolate(
"POP2050", (1)
12, (2)
"exp" (3)
)
values.each { Double value ->
println value
}| 1 | Field Name |
| 2 | Number of classes |
| 3 | Algorithm |
0.0 1.3993454247861767 4.75685846744236 12.81269202499939 32.14141941416279 78.51771304229133 189.79046097748173 456.77221963916656 1097.3536807854464 2634.3298787896188 6322.06668747619 15170.221127213848 36399.99999999998
Getting a Layer’s Features
Each Feature
Iterate over a Layer’s Features
Workspace workspace = new GeoPackage("src/main/resources/data.gpkg")
Layer layer = workspace.get("states")
layer.eachFeature { Feature feature ->
println feature["NAME_1"]
}Minnesota Montana North Dakota Hawaii Idaho Washington Arizona California Colorado Nevada ...
Iterate over a subset of a Layer’s Features
Workspace workspace = new GeoPackage("src/main/resources/data.gpkg")
Layer layer = workspace.get("states")
layer.eachFeature("NAME_1 LIKE 'M%'") { Feature feature ->
println feature["NAME_1"]
}Minnesota Montana Missouri Massachusetts Mississippi Maryland Maine Michigan
Iterate over a Layer’s Features with parameters.
Workspace workspace = new GeoPackage("src/main/resources/data.gpkg")
Layer layer = workspace.get("states")
layer.eachFeature(sort: ["NAME_1"], start: 0, max: 5, fields: ["NAME_1"], filter: "NAME_1 LIKE 'M%'") { Feature feature ->
println feature["NAME_1"]
}Maine Maryland Massachusetts Michigan Minnesota
Parameters
-
filter: The Filter or Filter String to limit the Features. Defaults to null.
-
sort: A List of Lists that define the sort order [[Field or Field name, "ASC" or "DESC"],…]. Not all Layers support sorting!
-
max: The maximum number of Features to include
-
start: The index of the record to start the cursor at. Together with maxFeatures this simulates paging. Not all Layers support the start index and paging!
-
fields: A List of Fields or Field names to include. Used to select only a subset of Fields.
Read all Features
Read all Feature into a List
Workspace workspace = new GeoPackage("src/main/resources/data.gpkg")
Layer layer = workspace.get("states")
List<Feature> features = layer.features
println "# Features = ${features.size()}"
features.each { Feature feature ->
println feature["NAME_1"]
}# Features = 52 Minnesota Montana North Dakota Hawaii Idaho Washington Arizona California Colorado Nevada ...
Collect values
Collect values from a Layer’s Features
Workspace workspace = new GeoPackage("src/main/resources/data.gpkg")
Layer layer = workspace.get("states")
List<String> names = layer.collectFromFeature { Feature f ->
f["NAME_1"]
}.sort()
println "# Names = ${names.size()}"
names.each { String name ->
println name
}# Names = 52 Alabama Alaska Arizona Arkansas California Colorado Connecticut Delaware District of Columbia Florida ...
Collect values from a Layer’s Features with parameters.
Workspace workspace = new GeoPackage("src/main/resources/data.gpkg")
Layer layer = workspace.get("states")
List<String> names = layer.collectFromFeature(
sort: ["NAME_1"],
start: 0,
max: 5,
fields: ["NAME_1"],
filter: "NAME_1 LIKE 'M%'") { Feature f ->
f["NAME_1"]
}
println "# Names = ${names.size()}"
names.each { String name ->
println name
}# Names = 5 Maine Maryland Massachusetts Michigan Minnesota
First
Get the first Feature that matches the Filter.
Workspace workspace = new GeoPackage("src/main/resources/data.gpkg")
Layer layer = workspace.get("states")
Feature feature = layer.first(filter: "NAME_1='Washington'")
println feature.get("NAME_1")Washington
Get the first Feature sorted by name ascending and descending.
Workspace workspace = new GeoPackage("src/main/resources/data.gpkg")
Layer layer = workspace.get("states")
Feature featureAsc = layer.first(sort: "NAME_1 ASC")
println featureAsc.get("NAME_1")
Feature featureDesc = layer.first(sort: "NAME_1 DESC")
println featureDesc.get("NAME_1")Alabama Wyoming
Filter
Create a new Layer from an existing Layer with just the Features that match a Filter.
Workspace workspace = new Directory("target")
Layer layer = workspace.get("countries")
Layer disputedLayer = layer.filter("TYPE='Disputed'")
Cursor
Iterate over a Layer’s Features with a Cursor
Workspace workspace = new GeoPackage("src/main/resources/data.gpkg")
Layer layer = workspace.get("states")
Cursor cursor = layer.cursor
cursor.each { Feature feature ->
println feature["NAME_1"]
}Minnesota Montana North Dakota Hawaii Idaho Washington Arizona California Colorado Nevada ...
Iterate over a subset of a Layer’s Features with a Cursor
Workspace workspace = new GeoPackage("src/main/resources/data.gpkg")
Layer layer = workspace.get("states")
Cursor cursor = layer.getCursor(filter: "NAME_1 LIKE 'M%'")
while(cursor.hasNext()) {
Feature feature = cursor.next()
println feature["NAME_1"]
}Minnesota Montana Missouri Massachusetts Mississippi Maryland Maine Michigan
Iterate over a Layer’s Features with parameters with a Cursor
Workspace workspace = new GeoPackage("src/main/resources/data.gpkg")
Layer layer = workspace.get("states")
layer.getCursor(sort: ["NAME_1"], start: 0, max: 5, fields: ["NAME_1"], filter: "NAME_1 LIKE 'M%'").each { Feature feature ->
println feature["NAME_1"]
}Maine Maryland Massachusetts Michigan Minnesota
Parameters
-
filter: The Filter or Filter String to limit the Features. Defaults to null.
-
sort: A List of Lists that define the sort order [[Field or Field name, "ASC" or "DESC"],…]. Not all Layers support sorting!
-
max: The maximum number of Features to include
-
start: The index of the record to start the cursor at. Together with maxFeatures this simulates paging. Not all Layers support the start index and paging!
-
fields: A List of Fields or Field names to include. Used to select only a subset of Fields.
Adding, Updating, and Deleting
Add Features to a Layer
Workspace workspace = new Memory()
Schema schema = new Schema("cities", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String"),
new Field("state", "String")
])
Layer layer = workspace.create(schema)
// Add a Feature with a Map
Map attributes = [
geom: new Point(-122.333056, 47.609722),
id: 1,
name: "Seattle",
state: "WA"
]
layer.add(attributes)
// Add a Feature with a List
List values = [
new Point(-122.459444, 47.241389),
2,
"Tacoma",
"WA"
]
layer.add(values)
// Add a Feature
Feature feature = schema.feature([
id:3,
name: "Fargo",
state: "ND",
geom: new Point(-96.789444, 46.877222)
])
layer.add(feature)
// Add Features from a List of Maps
List<Map> features = [
[
geom: new Point(-100.778889, 46.813333),
id:4,
name: "Bismarck",
state: "ND"
],
[
geom: new Point(-100.891111, 46.828889),
id: 5,
name: "Mandan",
state: "ND"
]
]
layer.add(features)| id | name | state |
|---|---|---|
1 |
Seattle |
WA |
2 |
Tacoma |
WA |
3 |
Fargo |
ND |
4 |
Bismarck |
ND |
5 |
Mandan |
ND |
Update Features in a Layer
Workspace workspace = new Memory()
Schema schema = new Schema("cities", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String"),
new Field("state", "String")
])
Layer layer = workspace.create(schema)
List<Map> features = [
[
geom: new Point(-122.333056, 47.609722),
id: 1,
name: "Seattle",
state: "WA"
],
[
geom: new Point(-122.459444, 47.241389),
id: 2,
name: "Tacoma",
state: "WA"
],
[
id:3,
name: "Fargo",
state: "ND",
geom: new Point(-96.789444, 46.877222)
],
[
geom: new Point(-100.778889, 46.813333),
id:4,
name: "Bismarck",
state: "ND"
],
[
geom: new Point(-100.891111, 46.828889),
id: 5,
name: "Mandan",
state: "ND"
]
]
layer.add(features)
layer.update(layer.schema.state, "North Dakota", "state='ND'")
layer.update(layer.schema.state, "Washington", "state='WA'")| id | name | state |
|---|---|---|
1 |
Seattle |
Washington |
2 |
Tacoma |
Washington |
3 |
Fargo |
North Dakota |
4 |
Bismarck |
North Dakota |
5 |
Mandan |
North Dakota |
Update Features in a Layer by setting values
Workspace workspace = new Memory()
Schema schema = new Schema("cities", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String"),
new Field("state", "String")
])
Layer layer = workspace.create(schema)
List<Map> features = [
[
geom: new Point(-122.333056, 47.609722),
id: 1,
name: "",
state: ""
],
[
geom: new Point(-122.459444, 47.241389),
id: 2,
name: "",
state: ""
]
]
layer.add(features)
List<Feature> layerFeatures = layer.features
layerFeatures[0].set("name", "Seattle")
layerFeatures[0].set("state", "WA")
layerFeatures[1].set("name", "Tacoma")
layerFeatures[1].set("state", "WA")
layer.update()| id | name | state |
|---|---|---|
1 |
Seattle |
WA |
2 |
Tacoma |
WA |
Delete Features from a Layer
Workspace workspace = new Memory()
Schema schema = new Schema("cities", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String"),
new Field("state", "String")
])
Layer layer = workspace.create(schema)
List<Map> features = [
[
geom: new Point(-122.333056, 47.609722),
id: 1,
name: "Seattle",
state: "WA"
],
[
geom: new Point(-122.459444, 47.241389),
id: 2,
name: "Tacoma",
state: "WA"
],
[
id:3,
name: "Fargo",
state: "ND",
geom: new Point(-96.789444, 46.877222)
],
[
geom: new Point(-100.778889, 46.813333),
id:4,
name: "Bismarck",
state: "ND"
],
[
geom: new Point(-100.891111, 46.828889),
id: 5,
name: "Mandan",
state: "ND"
]
]
layer.add(features)
layer.delete("state='ND'")| id | name | state |
|---|---|---|
1 |
Seattle |
WA |
2 |
Tacoma |
WA |
Add Features to a Layer using a Writer. A Writer can add Features more effeciently because is commits batches of Features in Transactions .
Workspace workspace = new Memory()
Schema schema = new Schema("cities", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer")
])
Layer layer = workspace.create(schema)
Bounds bounds = new Bounds(-180,-90,180,90, "EPSG:4326")
MultiPoint points = Geometry.createRandomPoints(bounds.geometry, 100)
geoscript.layer.Writer writer = layer.writer
try {
points.geometries.eachWithIndex { Point point, int index ->
Feature feature = writer.newFeature
feature['id'] = index
feature['geom'] = point
writer.add(feature)
}
} finally {
writer.close()
}
Add Features to a Layer using a Writer inside of a Closure.
Workspace workspace = new Memory()
Schema schema = new Schema("cities", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer")
])
Layer layer = workspace.create(schema)
Bounds bounds = new Bounds(-180,-90,180,90, "EPSG:4326")
MultiPoint points = Geometry.createRandomPoints(bounds.geometry, 100)
layer.withWriter { geoscript.layer.Writer writer ->
points.geometries.eachWithIndex { Point point, int index ->
Feature feature = writer.newFeature
feature['id'] = index
feature['geom'] = point
writer.add(feature)
}
}
Shapefiles
Shapefiles are a very commonly used format for storing spatial data. So, instead of creating a Directory Workspace and getting the Layer from the Workspace, you can use the Shapefile class.
Read
Read existing Shapefiles
Shapefile countries = new Shapefile("src/main/resources/shapefiles/countries.shp")
println "# Features in Countries = ${countries.count}"
Shapefile ocean = new Shapefile(new File("src/main/resources/shapefiles/ocean.shp"))
println "# Features in Ocean = ${ocean.count}"# Features in Countries = 177 # Features in Ocean = 2
Create
Create a new Shapefile
Directory workspace = new Directory("target")
Schema schema = new Schema("cities", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String"),
new Field("state", "String")
])
Layer layer = workspace.create(schema)
List<Map> features = [
[
geom: new Point(-122.333056, 47.609722),
id: 1,
name: "Seattle",
state: "WA"
],
[
geom: new Point(-122.459444, 47.241389),
id: 2,
name: "Tacoma",
state: "WA"
],
[
id:3,
name: "Fargo",
state: "ND",
geom: new Point(-96.789444, 46.877222)
],
[
geom: new Point(-100.778889, 46.813333),
id:4,
name: "Bismarck",
state: "ND"
],
[
geom: new Point(-100.891111, 46.828889),
id: 5,
name: "Mandan",
state: "ND"
]
]
layer.add(features)| id | name | state |
|---|---|---|
1 |
Seattle |
WA |
2 |
Tacoma |
WA |
3 |
Fargo |
ND |
4 |
Bismarck |
ND |
5 |
Mandan |
ND |
Property
GeoScript can store spatial data in a simple plain text format. With the Property class you can access a single property file directly.
Read
Read existing Property files
geoscript.layer.Property circles = new geoscript.layer.Property("src/main/resources/property/circles.properties")
println "# Features in circles = ${circles.count}"
geoscript.layer.Property places = new geoscript.layer.Property(new File("src/main/resources/property/places.properties"))
println "# Features in places = ${places.count}"# Features in circles = 10 # Features in places = 10
Create
Create a new Property
geoscript.workspace.Property workspace = new geoscript.workspace.Property("target")
Schema schema = new Schema("cities", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String"),
new Field("state", "String")
])
Layer layer = workspace.create(schema)
List<Map> features = [
[
geom: new Point(-122.333056, 47.609722),
id: 1,
name: "Seattle",
state: "WA"
],
[
geom: new Point(-122.459444, 47.241389),
id: 2,
name: "Tacoma",
state: "WA"
],
[
id:3,
name: "Fargo",
state: "ND",
geom: new Point(-96.789444, 46.877222)
],
[
geom: new Point(-100.778889, 46.813333),
id:4,
name: "Bismarck",
state: "ND"
],
[
geom: new Point(-100.891111, 46.828889),
id: 5,
name: "Mandan",
state: "ND"
]
]
layer.add(features)| id | name | state |
|---|---|---|
1 |
Seattle |
WA |
2 |
Tacoma |
WA |
3 |
Fargo |
ND |
4 |
Bismarck |
ND |
5 |
Mandan |
ND |
Geoprocessing
Reproject
Reproject a Layer from it’s source projection to a target projection
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer states = workspace.get("states")
println "States = ${states.proj}"
Projection projection = new Projection("EPSG:3857")
Workspace outputWorkspace = new Memory()
Layer statesInWebMercator = states.reproject(projection, outputWorkspace, "states_3857")
println "Reprojected States = ${statesInWebMercator.proj}"States = EPSG:4326 Reprojected States = EPSG:3857
Buffer
Buffer a Layer of populated places
Workspace workspace = new GeoPackage(new File("src/main/resources/data.gpkg"))
Layer places = workspace.get("places")
Layer buffer = places.buffer(5)
Dissolve
Dissolve a Layer by a Field
Workspace workspace = new Directory(new File("src/main/resources/data"))
Layer states = workspace.get("states")
Layer regions = states.dissolve(states.schema.get("SUB_REGION"))
Merge
Merge two Layer together
Workspace workspace = new Directory(new File("src/main/resources/data"))
Layer states = workspace.get("states")
Feature washington = states.first(filter: "STATE_NAME='Washington'")
Feature oregon = states.first(filter: "STATE_NAME='Oregon'")
Schema waSchema = new Schema("washington",[
new Field("geom","Point","EPSG:4326"),
new Field("id","int")
])
Layer waLayer = new Memory().create(waSchema)
waLayer.withWriter { geoscript.layer.Writer writer ->
Geometry.createRandomPoints(washington.geom, 50).points.eachWithIndex { Point pt, int index ->
writer.add(waSchema.feature([geom: pt, id: index]))
}
}
println "The Washington Layer has ${waLayer.count} features"
Schema orSchema = new Schema("oregon",[
new Field("geom","Point","EPSG:4326"),
new Field("id","int")
])
Layer orLayer = new Memory().create(orSchema)
orLayer.withWriter { geoscript.layer.Writer writer ->
Geometry.createRandomPoints(oregon.geom, 50).points.eachWithIndex { Point pt, int index ->
writer.add(orSchema.feature([geom: pt, id: index]))
}
}
println "The Oregon Layer has ${orLayer.count} features"
Layer mergedLayer = orLayer.merge(waLayer)
println "The merged Layer has ${mergedLayer.count} features"The Washington Layer has 50 features The Oregon Layer has 50 features The merged Layer has 100 features
Split
Split a Layer into Layers based on the value from a Field
Workspace workspace = new GeoPackage(new File("src/main/resources/data.gpkg"))
Layer rivers = workspace.get("rivers")
Workspace outWorkspace = new Memory()
rivers.split(rivers.schema.get("scalerank"), outWorkspace)
outWorkspace.layers.each { Layer layer ->
println "${layer.name} has ${layer.count} features"
}rivers_0 has 1 features rivers_1 has 27 features rivers_2 has 35 features rivers_3 has 53 features rivers_4 has 71 features rivers_5 has 67 features rivers_6 has 206 features
Split a Layer into Layers based on another Layer
Schema schema = new Schema("grid",[
new Field("geom","Polygon","EPSG:4326"),
new Field("col","int"),
new Field("row","int"),
new Field("row_col","string")
])
Workspace gridWorkspace = new Directory("target")
Layer gridLayer = gridWorkspace.create(schema)
new Bounds(-180,-90,180,90,"EPSG:4326").generateGrid(2, 3, "polygon", {cell, col, row ->
gridLayer.add([
"geom": cell,
"col": col,
"row": row,
"row_col": "${row} ${col}"
])
})
Workspace workspace = new GeoPackage(new File("src/main/resources/data.gpkg"))
Layer countries = workspace.get("countries")
Workspace outWorkspace = new Memory()
countries.split(gridLayer,gridLayer.schema.get("row_col"),outWorkspace)
outWorkspace.layers.each { Layer layer ->
println "${layer.name} has ${layer.count} features"
}countries_1_1 has 6 features countries_1_2 has 6 features countries_2_1 has 44 features countries_2_2 has 74 features countries_3_1 has 13 features countries_3_2 has 70 features
Transform
Transform one Layer into another Layer
Workspace workspace = new Directory(new File("src/main/resources/data"))
Layer states = workspace.get("states")
Layer centroids = states.transform("centroids", [
geom: "centroid(the_geom)",
name: "strToUpperCase(STATE_NAME)",
ratio: "FEMALE / MALE"
])
centroids.eachFeature(max: 5) {Feature f ->
println "${f.geom} ${f['name']} = ${f['ratio']}"
}ILLINOIS = 1.0587396098110435 DISTRICT OF COLUMBIA = 1.1447503268897763 DELAWARE = 1.0626439771122835 WEST VIRGINIA = 1.0817203227723509 MARYLAND = 1.0621588832568312
Raster
Create a Raster from the geometry and values of a Layer
Workspace workspace = new Memory()
Layer layer = workspace.create("earthquake", [
new Field("geom", "Polygon", "EPSG:4326"),
new Field("intensity", "Double")
])
Point point = new Point(-122.387695, 47.572357)
double distance = 5.0
List<Geometry> geometries = (1..5).collect { int i ->
point.buffer(i * distance)
}
geometries.eachWithIndex { Geometry geometry, int i ->
if (i > 0) {
Geometry previousGeometry = geometries.get(i - 1)
geometry = geometry.difference(previousGeometry)
}
layer.add([
geom: geometry,
intensity: (i + 1) * 20
])
}
Raster raster = layer.getRaster(
"intensity", (1)
[400,400], (2)
layer.bounds, (3)
"intensity" (4)
)| 1 | Field for values |
| 2 | Raster size (width and height) |
| 3 | Raster bounds |
| 4 | Name |
Layer
Raster
Layer Algebra
GeoScript can do layer algebra. All of the examples below use Layer A (red) and Layer B (green).
Clip
Clip Layer A with Layer B
Workspace workspace = new GeoPackage(new File("src/main/resources/layeralgebra.gpkg"))
Layer layerA = workspace.get("a")
Layer layerB = workspace.get("b")
Layer layerC = layerA.clip(layerB)
Clip Layer B with Layer A
Workspace workspace = new GeoPackage(new File("src/main/resources/layeralgebra.gpkg"))
Layer layerA = workspace.get("a")
Layer layerB = workspace.get("b")
Workspace outWorkspace = new Directory("target")
Layer layerC = layerB.clip(layerA, outWorkspace: outWorkspace, outLayer: "ba_clip")
Erase
Erase Layer A with Layer B
Workspace workspace = new GeoPackage(new File("src/main/resources/layeralgebra.gpkg"))
Layer layerA = workspace.get("a")
Layer layerB = workspace.get("b")
Layer layerC = layerA.erase(layerB)
Erase Layer B with Layer A
Workspace workspace = new GeoPackage(new File("src/main/resources/layeralgebra.gpkg"))
Layer layerA = workspace.get("a")
Layer layerB = workspace.get("b")
Workspace outWorkspace = new Directory("target")
Layer layerC = layerB.erase(layerA, outWorkspace: outWorkspace, outLayer: "ba_erase")
Identity
Identity Layer A with Layer B
Workspace workspace = new GeoPackage(new File("src/main/resources/layeralgebra.gpkg"))
Layer layerA = workspace.get("a")
Layer layerB = workspace.get("b")
Layer layerC = layerA.identity(layerB)
Identity Layer B with Layer A
Workspace workspace = new GeoPackage(new File("src/main/resources/layeralgebra.gpkg"))
Layer layerA = workspace.get("a")
Layer layerB = workspace.get("b")
Workspace outWorkspace = new Directory("target")
Layer layerC = layerB.identity(layerA, outWorkspace: outWorkspace, outLayer: "ba_identity")
Intersection
Intersection Layer A with Layer B
Workspace workspace = new GeoPackage(new File("src/main/resources/layeralgebra.gpkg"))
Layer layerA = workspace.get("a")
Layer layerB = workspace.get("b")
Layer layerC = layerA.intersection(layerB)
Intersection Layer B with Layer A
Workspace workspace = new GeoPackage(new File("src/main/resources/layeralgebra.gpkg"))
Layer layerA = workspace.get("a")
Layer layerB = workspace.get("b")
Workspace outWorkspace = new Directory("target")
Layer layerC = layerB.intersection(layerA, outWorkspace: outWorkspace, outLayer: "ba_intersection")
Symmetric Difference
Symmetric Difference Layer A with Layer B
Workspace workspace = new GeoPackage(new File("src/main/resources/layeralgebra.gpkg"))
Layer layerA = workspace.get("a")
Layer layerB = workspace.get("b")
Layer layerC = layerA.symDifference(layerB)
Symmetric Difference Layer B with Layer A
Workspace workspace = new GeoPackage(new File("src/main/resources/layeralgebra.gpkg"))
Layer layerA = workspace.get("a")
Layer layerB = workspace.get("b")
Workspace outWorkspace = new Directory("target")
Layer layerC = layerB.symDifference(layerA, outWorkspace: outWorkspace, outLayer: "ba_symdifference")
Update
Update Layer A with Layer B
Workspace workspace = new GeoPackage(new File("src/main/resources/layeralgebra.gpkg"))
Layer layerA = workspace.get("a")
Layer layerB = workspace.get("b")
Layer layerC = layerA.update(layerB)
Update Layer B with Layer A
Workspace workspace = new GeoPackage(new File("src/main/resources/layeralgebra.gpkg"))
Layer layerA = workspace.get("a")
Layer layerB = workspace.get("b")
Workspace outWorkspace = new Directory("target")
Layer layerC = layerB.update(layerA, outWorkspace: outWorkspace, outLayer: "ba_update")
Union
Union Layer A with Layer B
Workspace workspace = new GeoPackage(new File("src/main/resources/layeralgebra.gpkg"))
Layer layerA = workspace.get("a")
Layer layerB = workspace.get("b")
Layer layerC = layerA.union(layerB)
Union Layer B with Layer A
Workspace workspace = new GeoPackage(new File("src/main/resources/layeralgebra.gpkg"))
Layer layerA = workspace.get("a")
Layer layerB = workspace.get("b")
Workspace outWorkspace = new Directory("target")
Layer layerC = layerB.union(layerA, outWorkspace: outWorkspace, outLayer: "ba_union")
Reading and Writing Layers
The Layer IO classes are in the geoscript.layer.io package.
Finding Layer Writer and Readers
List all Layer Writers
List<Writer> writers = Writers.list()
writers.each { Writer writer ->
println writer.class.simpleName
}CsvWriter GeobufWriter GeoJSONWriter GeoRSSWriter GmlWriter GpxWriter KmlWriter MvtWriter
Find a Layer Writer
Workspace workspace = new Memory()
Schema schema = new Schema("cities", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String")
])
Layer layer = workspace.create(schema)
layer.add([
geom: new Point(-122.3204, 47.6024),
id: 1,
name: "Seattle"
])
layer.add([
geom: new Point(-122.48416, 47.2619),
id: 2,
name: "Tacoma"
])
Writer writer = Writers.find("csv")
String csv = writer.write(layer)
println csv"geom:Point:EPSG:4326","id:Integer","name:String" "POINT (-122.3204 47.6024)","1","Seattle" "POINT (-122.48416 47.2619)","2","Tacoma"
List all Layer Readers
List<Reader> readers = Readers.list()
readers.each { Reader reader ->
println reader.class.simpleName
}CsvReader GeobufReader GeoJSONReader GeoRSSReader GmlReader GpxReader KmlReader MvtReader
Find a Layer Reader
Reader reader = Readers.find("csv")
Layer layer = reader.read(""""geom:Point:EPSG:4326","id:Integer","name:String"
"POINT (-122.3204 47.6024)","1","Seattle"
"POINT (-122.48416 47.2619)","2","Tacoma"
""")
println "# features = ${layer.count}"# features = 2
GeoJSON
Get GeoJSON String from a Layer
Workspace workspace = new Memory()
Schema schema = new Schema("cities", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String")
])
Layer layer = workspace.create(schema)
layer.add([
geom: new Point(-122.3204, 47.6024),
id: 1,
name: "Seattle"
])
layer.add([
geom: new Point(-122.48416, 47.2619),
id: 2,
name: "Tacoma"
])
String geojson = layer.toJSONString()
println geojson{
"type": "FeatureCollection",
"features": [
{
"type": "Feature",
"geometry": {
"type": "Point",
"coordinates": [
-122.3204,
47.6024
]
},
"properties": {
"id": 1,
"name": "Seattle"
},
"id": "fid-34d9214a_16d54d1675c_-68cc"
},
{
"type": "Feature",
"geometry": {
"type": "Point",
"coordinates": [
-122.4842,
47.2619
]
},
"properties": {
"id": 2,
"name": "Tacoma"
},
"id": "fid-34d9214a_16d54d1675c_-68ca"
}
]
}
Write a Layer to a GeoJSON String
Workspace workspace = new Memory()
Schema schema = new Schema("cities", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String")
])
Layer layer = workspace.create(schema)
layer.add([
geom: new Point(-122.3204, 47.6024),
id: 1,
name: "Seattle"
])
layer.add([
geom: new Point(-122.48416, 47.2619),
id: 2,
name: "Tacoma"
])
GeoJSONWriter writer = new GeoJSONWriter()
String geojson = writer.write(layer)
println geojson{
"type": "FeatureCollection",
"features": [
{
"type": "Feature",
"geometry": {
"type": "Point",
"coordinates": [
-122.3204,
47.6024
]
},
"properties": {
"id": 1,
"name": "Seattle"
},
"id": "fid-34d9214a_16d54d1675c_-7e12"
},
{
"type": "Feature",
"geometry": {
"type": "Point",
"coordinates": [
-122.4842,
47.2619
]
},
"properties": {
"id": 2,
"name": "Tacoma"
},
"id": "fid-34d9214a_16d54d1675c_-7e10"
}
]
}
Read a Layer from a GeoJSON String
String geoJson = """
{
"type": "FeatureCollection",
"features": [
{
"type": "Feature",
"geometry": {
"type": "Point",
"coordinates": [
-122.3204,
47.6024
]
},
"properties": {
"id": 1,
"name": "Seattle"
},
"id": "1"
},
{
"type": "Feature",
"geometry": {
"type": "Point",
"coordinates": [
-122.681944,
45.52
]
},
"properties": {
"id": 2,
"name": "Portland"
},
"id": "2"
}
]
}
"""
GeoJSONReader reader = new GeoJSONReader()
Layer layer = reader.read(geoJson)
GeoBuf
Get GeoBuf String from a Layer
Workspace workspace = new Memory()
Schema schema = new Schema("cities", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String")
])
Layer layer = workspace.create(schema)
layer.add([
geom: new Point(-122.3204, 47.6024),
id: 1,
name: "Seattle"
])
layer.add([
geom: new Point(-122.48416, 47.2619),
id: 2,
name: "Tacoma"
])
String geobuf = layer.toGeobufString()
println geobuf0a0269640a046e616d6510021806223d0a1d0a0c08001a089fd8d374c0ebb22d6a0218016a090a0753656174746c650a1c0a0c08001a08ffd6e77498a3892d6a0218026a080a065461636f6d61
Write a Layer to a GeoBuf String
Workspace workspace = new Memory()
Schema schema = new Schema("cities", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String")
])
Layer layer = workspace.create(schema)
layer.add([
geom: new Point(-122.3204, 47.6024),
id: 1,
name: "Seattle"
])
layer.add([
geom: new Point(-122.681944, 45.52),
id: 2,
name: "Portland"
])
GeobufWriter writer = new GeobufWriter()
String geobuf = writer.write(layer)
println geobuf0a0269640a046e616d6510021806223f0a1d0a0c08001a089fd8d374c0ebb22d6a0218016a090a0753656174746c650a1e0a0c08001a08afe9ff7480d2b42b6a0218026a0a0a08506f72746c616e64
Read a Layer from a GeoBuf String
String geobuf = "0a0269640a046e616d6510021806223f0a1d0a0c08001a089fd8d374c0ebb22d6a0218016a090a0753656174746c650a1e0a0c08001a08afe9ff7480d2b42b6a0218026a0a0a08506f72746c616e64"
GeobufReader reader = new GeobufReader()
Layer layer = reader.read(geobuf)
GML
Get GML String from a Layer
Workspace workspace = new Memory()
Schema schema = new Schema("cities", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String")
])
Layer layer = workspace.create(schema)
layer.add([
geom: new Point(-122.3204, 47.6024),
id: 1,
name: "Seattle"
])
layer.add([
geom: new Point(-122.48416, 47.2619),
id: 2,
name: "Tacoma"
])
String gml = layer.toGMLString()
println gml<wfs:FeatureCollection xmlns:wfs="http://www.opengis.net/wfs">
<gml:boundedBy xmlns:gml="http://www.opengis.net/gml">
<gml:Box srsName="http://www.opengis.net/gml/srs/epsg.xml#4326">
<gml:coord>
<gml:X>
-122.48416
</gml:X>
<gml:Y>
47.2619
</gml:Y>
</gml:coord>
<gml:coord>
<gml:X>
-122.3204
</gml:X>
<gml:Y>
47.6024
</gml:Y>
</gml:coord>
</gml:Box>
</gml:boundedBy>
<gml:featureMember xmlns:gml="http://www.opengis.net/gml">
<gsf:cities xmlns:gsf="http://geoscript.org/feature" fid="fid-34d9214a_16d54d1675c_-736d">
<gml:name>
Seattle
</gml:name>
<gsf:geom>
<gml:Point>
<gml:coord>
<gml:X>
-122.3204
</gml:X>
<gml:Y>
47.6024
</gml:Y>
</gml:coord>
</gml:Point>
</gsf:geom>
<gsf:id>
1
</gsf:id>
</gsf:cities>
</gml:featureMember>
<gml:featureMember xmlns:gml="http://www.opengis.net/gml">
<gsf:cities xmlns:gsf="http://geoscript.org/feature" fid="fid-34d9214a_16d54d1675c_-736b">
<gml:name>
Tacoma
</gml:name>
<gsf:geom>
<gml:Point>
<gml:coord>
<gml:X>
-122.48416
</gml:X>
<gml:Y>
47.2619
</gml:Y>
</gml:coord>
</gml:Point>
</gsf:geom>
<gsf:id>
2
</gsf:id>
</gsf:cities>
</gml:featureMember>
</wfs:FeatureCollection>
Write a Layer to a GML String
Workspace workspace = new Memory()
Schema schema = new Schema("cities", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String")
])
Layer layer = workspace.create(schema)
layer.add([
geom: new Point(-122.3204, 47.6024),
id: 1,
name: "Seattle"
])
layer.add([
geom: new Point(-122.48416, 47.2619),
id: 2,
name: "Tacoma"
])
GmlWriter writer = new GmlWriter()
String gml = writer.write(layer)
println gml<wfs:FeatureCollection xmlns:gsf="http://geoscript.org/feature" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:wfs="http://www.opengis.net/wfs" xmlns:gml="http://www.opengis.net/gml" xmlns:ogc="http://www.opengis.net/ogc"> <gml:boundedBy> <gml:Box srsName="http://www.opengis.net/gml/srs/epsg.xml#4326"> <gml:coord> <gml:X>-122.48416</gml:X> <gml:Y>47.2619</gml:Y> </gml:coord> <gml:coord> <gml:X>-122.3204</gml:X> <gml:Y>47.6024</gml:Y> </gml:coord> </gml:Box> </gml:boundedBy> <gml:featureMember> <gsf:cities fid="fid-34d9214a_16d54d1675c_-7393"> <gml:name>Seattle</gml:name> <gsf:geom> <gml:Point> <gml:coord> <gml:X>-122.3204</gml:X> <gml:Y>47.6024</gml:Y> </gml:coord> </gml:Point> </gsf:geom> <gsf:id>1</gsf:id> </gsf:cities> </gml:featureMember> <gml:featureMember> <gsf:cities fid="fid-34d9214a_16d54d1675c_-7391"> <gml:name>Tacoma</gml:name> <gsf:geom> <gml:Point> <gml:coord> <gml:X>-122.48416</gml:X> <gml:Y>47.2619</gml:Y> </gml:coord> </gml:Point> </gsf:geom> <gsf:id>2</gsf:id> </gsf:cities> </gml:featureMember> </wfs:FeatureCollection>
Read a Layer from a GML String
String gml = """
<wfs:FeatureCollection xmlns:gsf="http://geoscript.org/feature" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:wfs="http://www.opengis.net/wfs" xmlns:gml="http://www.opengis.net/gml" xmlns:ogc="http://www.opengis.net/ogc">
<gml:boundedBy>
<gml:Box srsName="http://www.opengis.net/gml/srs/epsg.xml#4326">
<gml:coord>
<gml:X>-122.48416</gml:X>
<gml:Y>47.2619</gml:Y>
</gml:coord>
<gml:coord>
<gml:X>-122.3204</gml:X>
<gml:Y>47.6024</gml:Y>
</gml:coord>
</gml:Box>
</gml:boundedBy>
<gml:featureMember>
<gsf:cities fid="fid-a7cd555_1634fc34503_-7fff">
<gml:name>Seattle</gml:name>
<gsf:geom>
<gml:Point>
<gml:coord>
<gml:X>-122.3204</gml:X>
<gml:Y>47.6024</gml:Y>
</gml:coord>
</gml:Point>
</gsf:geom>
<gsf:id>1</gsf:id>
</gsf:cities>
</gml:featureMember>
<gml:featureMember>
<gsf:cities fid="fid-a7cd555_1634fc34503_-7ffd">
<gml:name>Portland</gml:name>
<gsf:geom>
<gml:Point>
<gml:coord>
<gml:X>-122.681944</gml:X>
<gml:Y>45.52</gml:Y>
</gml:coord>
</gml:Point>
</gsf:geom>
<gsf:id>2</gsf:id>
</gsf:cities>
</gml:featureMember>
</wfs:FeatureCollection>
"""
GmlReader reader = new GmlReader()
Layer layer = reader.read(gml)
KML
Get KML String from a Layer
Workspace workspace = new Memory()
Schema schema = new Schema("cities", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String")
])
Layer layer = workspace.create(schema)
layer.add([
geom: new Point(-122.3204, 47.6024),
id: 1,
name: "Seattle"
])
layer.add([
geom: new Point(-122.48416, 47.2619),
id: 2,
name: "Tacoma"
])
String kml = layer.toKMLString()
println kml<kml:kml xmlns:kml="http://www.opengis.net/kml/2.2">
<kml:Document>
<kml:Folder>
<kml:name>
cities
</kml:name>
<kml:Schema kml:name="cities" kml:id="cities">
<kml:SimpleField kml:name="id" kml:type="Integer"/>
<kml:SimpleField kml:name="name" kml:type="String"/>
</kml:Schema>
<kml:Placemark>
<kml:name>
fid-34d9214a_16d54d1675c_-69d7
</kml:name>
<kml:Style>
<kml:IconStyle>
<kml:color>
ff0000ff
</kml:color>
</kml:IconStyle>
</kml:Style>
<kml:ExtendedData>
<kml:SchemaData kml:schemaUrl="#cities">
<kml:SimpleData kml:name="id">
1
</kml:SimpleData>
<kml:SimpleData kml:name="name">
Seattle
</kml:SimpleData>
</kml:SchemaData>
</kml:ExtendedData>
<kml:Point>
<kml:coordinates>
-122.3204,47.6024
</kml:coordinates>
</kml:Point>
</kml:Placemark>
<kml:Placemark>
<kml:name>
fid-34d9214a_16d54d1675c_-69d5
</kml:name>
<kml:Style>
<kml:IconStyle>
<kml:color>
ff0000ff
</kml:color>
</kml:IconStyle>
</kml:Style>
<kml:ExtendedData>
<kml:SchemaData kml:schemaUrl="#cities">
<kml:SimpleData kml:name="id">
2
</kml:SimpleData>
<kml:SimpleData kml:name="name">
Tacoma
</kml:SimpleData>
</kml:SchemaData>
</kml:ExtendedData>
<kml:Point>
<kml:coordinates>
-122.48416,47.2619
</kml:coordinates>
</kml:Point>
</kml:Placemark>
</kml:Folder>
</kml:Document>
</kml:kml>
Write a Layer to a KML String
Workspace workspace = new Memory()
Schema schema = new Schema("cities", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String")
])
Layer layer = workspace.create(schema)
layer.add([
geom: new Point(-122.3204, 47.6024),
id: 1,
name: "Seattle"
])
layer.add([
geom: new Point(-122.48416, 47.2619),
id: 2,
name: "Tacoma"
])
KmlWriter writer = new KmlWriter()
String kml = writer.write(layer)
println kml<kml:kml xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:kml="http://earth.google.com/kml/2.1"> <kml:Document> <kml:Placemark id="fid-34d9214a_16d54d1675c_-738b"> <kml:name>Seattle</kml:name> <kml:Point> <kml:coordinates>-122.3204,47.6024</kml:coordinates> </kml:Point> </kml:Placemark> <kml:Placemark id="fid-34d9214a_16d54d1675c_-7389"> <kml:name>Tacoma</kml:name> <kml:Point> <kml:coordinates>-122.48416,47.2619</kml:coordinates> </kml:Point> </kml:Placemark> </kml:Document> </kml:kml>
Read a Layer from a KML String
String kml = """
<kml:kml xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:kml="http://earth.google.com/kml/2.1">
<kml:Document>
<kml:Placemark id="fid-61215c1b_1634ca279f5_-7fff">
<kml:name>Seattle</kml:name>
<kml:Point>
<kml:coordinates>-122.3204,47.6024</kml:coordinates>
</kml:Point>
</kml:Placemark>
<kml:Placemark id="fid-61215c1b_1634ca279f5_-7ffd">
<kml:name>Portland</kml:name>
<kml:Point>
<kml:coordinates>-122.681944,45.52</kml:coordinates>
</kml:Point>
</kml:Placemark>
</kml:Document>
</kml:kml>
"""
KmlReader reader = new KmlReader()
Layer layer = reader.read(kml)
CSV
Write a Layer to a CSV String
Workspace workspace = new Memory()
Schema schema = new Schema("cities", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String")
])
Layer layer = workspace.create(schema)
layer.add([
geom: new Point(-122.3204, 47.6024),
id: 1,
name: "Seattle"
])
layer.add([
geom: new Point(-122.48416, 47.2619),
id: 2,
name: "Tacoma"
])
CsvWriter writer = new CsvWriter()
String csv = writer.write(layer)
println csv"geom:Point:EPSG:4326","id:Integer","name:String" "POINT (-122.3204 47.6024)","1","Seattle" "POINT (-122.48416 47.2619)","2","Tacoma"
Read a Layer from a CSV String
String csv = """"geom:Point:EPSG:4326","id:Integer","name:String"
"POINT (-122.3204 47.6024)","1","Seattle"
"POINT (-122.681944 45.52)","2","Portland"
"""
CsvReader reader = new CsvReader()
Layer layer = reader.read(csv)
GeoRSS
Write a Layer to a GeoRSS String
Workspace workspace = new Memory()
Schema schema = new Schema("cities", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String")
])
Layer layer = workspace.create(schema)
layer.add([
geom: new Point(-122.3204, 47.6024),
id: 1,
name: "Seattle"
])
layer.add([
geom: new Point(-122.48416, 47.2619),
id: 2,
name: "Tacoma"
])
GeoRSSWriter writer = new GeoRSSWriter()
String georss = writer.write(layer)
println georss<?xml version="1.0" encoding="UTF-8"?><feed xmlns:georss="http://www.georss.org/georss" xmlns="http://www.w3.org/2005/Atom"> <title>cities</title> <subtitle>cities geom: Point(EPSG:4326), id: Integer, name: String</subtitle> <link>http://geoscript.org/feature</link> <entry> <title>fid-34d9214a_16d54d1675c_-7a1b</title> <summary>[geom:POINT (-122.3204 47.6024), id:1, name:Seattle]</summary> <updated>Sat Sep 21 10:15:00 PDT 2019</updated> <georss:point>47.6024 -122.3204</georss:point> </entry> <entry> <title>fid-34d9214a_16d54d1675c_-7a19</title> <summary>[geom:POINT (-122.48416 47.2619), id:2, name:Tacoma]</summary> <updated>Sat Sep 21 10:15:00 PDT 2019</updated> <georss:point>47.2619 -122.48416</georss:point> </entry> </feed>
Read a Layer from a GeoRSS String
String georss = """<?xml version="1.0" encoding="UTF-8"?>
<feed xmlns:georss="http://www.georss.org/georss" xmlns="http://www.w3.org/2005/Atom">
<title>cities</title>
<subtitle>cities geom: Point(EPSG:4326), id: Integer, name: String</subtitle>
<link>http://geoscript.org/feature</link>
<entry>
<title>Seattle</title>
<summary>[geom:POINT (-122.3204 47.6024), id:1, name:Seattle]</summary>
<updated>Fri May 11 15:23:05 PDT 2018</updated>
<georss:point>47.6024 -122.3204</georss:point>
</entry>
<entry>
<title>Portland</title>
<summary>[geom:POINT (-122.681944 45.52), id:2, name:Portland]</summary>
<updated>Fri May 11 15:23:05 PDT 2018</updated>
<georss:point>45.52 -122.681944</georss:point>
</entry>
</feed>
"""
GeoRSSReader reader = new GeoRSSReader()
Layer layer = reader.read(georss)
GPX
Write a Layer to a GPX String
Workspace workspace = new Memory()
Schema schema = new Schema("cities", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String")
])
Layer layer = workspace.create(schema)
layer.add([
geom: new Point(-122.3204, 47.6024),
id: 1,
name: "Seattle"
])
layer.add([
geom: new Point(-122.48416, 47.2619),
id: 2,
name: "Tacoma"
])
GpxWriter writer = new GpxWriter()
String gpx = writer.write(layer)
println gpx<?xml version="1.0" encoding="UTF-8"?><gpx xmlns="http://www.topografix.com/GPX/1/1" version="1.1" creator="geoscript"> <wpt lat="47.6024" lon="-122.3204"> <name>fid-34d9214a_16d54d1675c_-738f</name> </wpt> <wpt lat="47.2619" lon="-122.48416"> <name>fid-34d9214a_16d54d1675c_-738d</name> </wpt> </gpx>
Read a Layer from a GPX String
String gpx = """<?xml version="1.0" encoding="UTF-8"?>
<gpx xmlns="http://www.topografix.com/GPX/1/1" version="1.1" creator="geoscript">
<wpt lat="47.6024" lon="-122.3204">
<name>Seattle</name>
</wpt>
<wpt lat="45.52" lon="-122.681944">
<name>Portland</name>
</wpt>
</gpx>
"""
GpxReader reader = new GpxReader()
Layer layer = reader.read(gpx)
MVT
Write a Layer to a MVT String
Workspace workspace = new Memory()
Schema schema = new Schema("cities", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String")
])
Layer layer = workspace.create(schema)
layer.add([
geom: new Point(-122.3204, 47.6024),
id: 1,
name: "Seattle"
])
layer.add([
geom: new Point(-122.48416, 47.2619),
id: 2,
name: "Tacoma"
])
MvtWriter writer = new MvtWriter()
String mvt = writer.write(layer.reproject(new Projection("EPSG:3857")))
println mvtiU1WVAAAAGF4nGNgYGBiYGAQBWIGxoOZPw5M6bBa6xjOnRDd8rIcKCZZrZSZomRlqKOUl5ibqmSlFJyaWFKSk6pUi9CVxbjcy9Mh0zHsygrWwt2vgGISEF1GcF0hicn5uYlKtQBZLx7y
Read a Layer from a MVT String
String mvt = "iU1WVAAAAGF4nGNgYGBiYGAQBWIGxoOZPw5M6bBa6xjOnRDd8rIcKCZZrZSZomRlqKOUl5ibqmSlFJyaWFKSk6pUi9CVxbjcy9Mh0zHsygrWwt2vgGISEF1GcF0hicn5uYlKtQBZLx7y="
MvtReader reader = new MvtReader()
Layer layer = reader.read(mvt)
PBF
Write a Layer to PBF bytes
Workspace workspace = new Memory()
Schema schema = new Schema("cities", [
new Field("geom", "Point", "EPSG:4326"),
new Field("id", "Integer"),
new Field("name", "String")
])
Layer layer = workspace.create(schema)
layer.add([
geom: new Point(-122.3204, 47.6024),
id: 1,
name: "Seattle"
])
layer.add([
geom: new Point(-122.48416, 47.2619),
id: 2,
name: "Tacoma"
])
Pyramid pyramid = Pyramid.createGlobalMercatorPyramid(origin: Pyramid.Origin.TOP_LEFT)
Tile tile = new Tile(4,2,5)
Bounds bounds = pyramid.bounds(tile)
byte[] bytes = Pbf.write([layer], bounds)
println bytes.encodeBase64()GlYKBmNpdGllcxIPEgQAAAEBGAEiBQmGJNIlEg8SBAACAQMYASIFCcojiicaAmlkGgRuYW1lIgIwAiIJCgdTZWF0dGxlIgIwBCIICgZUYWNvbWEogCB4Ag==
Read a Layer from a PBF Base64 encoded String
byte[] bytes = "GlYKBmNpdGllcxIPEgQAAAEBGAEiBQmGJNIlEg8SBAACAQMYASIFCcojiicaAmlkGgRuYW1lIgIwAiIJCgdTZWF0dGxlIgIwBCIICgZUYWNvbWEogCB4Ag".decodeBase64()
Pyramid pyramid = Pyramid.createGlobalMercatorPyramid(origin: Pyramid.Origin.TOP_LEFT)
Tile tile = new Tile(4,2,5)
Bounds bounds = pyramid.bounds(tile)
List<Layer> layers = Pbf.read(bytes, bounds)
Graticules
Square
Create a square graticules Layer
Bounds bounds = new Bounds(-180,-90,180,90,"EPSG:4326")
double length = 20
double spacing = 5
Layer layer = Graticule.createSquares(bounds, length, spacing)
Create a square graticules Shapefile Layer
Bounds bounds = new Bounds(-180,-90,180,90,"EPSG:4326")
double length = 30
double spacing = -1
Workspace workspace = new Directory("target")
Layer layer = Graticule.createSquares(bounds, length, spacing, workspace: workspace, layer: "squares")
Hexagon
Create a flat hexagon graticules Layer
Bounds bounds = new Bounds(-180,-90,180,90,"EPSG:4326")
double length = 20
double spacing = 5
String orientation = "flat"
Layer layer = Graticule.createHexagons(bounds, length, spacing, orientation)
Create a angled hexagon graticules Layer
Bounds bounds = new Bounds(-180,-90,180,90,"EPSG:4326")
double length = 10
double spacing = 5
String orientation = "angled"
Layer layer = Graticule.createHexagons(bounds, length, spacing, orientation)
Create a hexagon graticules Layer intersecting Washington States
Layer states = new Shapefile("src/main/resources/data/states.shp")
Feature feature = states.first(filter: "STATE_NAME = 'Washington'")
Layer layer = Graticule.createHexagons(feature.bounds.expandBy(1.0), 0.2, -1.0, "flat", createFeature: { GridElement e ->
new Point(e.center.x, e.center.y).buffer(0.2).intersects(feature.geom)
})
Create a hexagon graticules Layer with a custom schema
Layer states = new Shapefile("src/main/resources/data/states.shp")
Schema schema = new Schema("hexagon", [
new Field("geom", "Polygon"),
new Field("color", "java.awt.Color")
])
Bounds b = states.bounds.expandBy(1)
Layer layer = Graticule.createHexagons(b, 2.0, -1.0, "flat", schema: schema, setAttributes: { GridElement e, Map attributes ->
attributes["color"] = Color.randomPastel.asColor()
})
layer.style = new Fill(new Property("color"), 0.5)
Line
Create a line graticules Layer
Bounds bounds = new Bounds(-180,-90,180,90,"EPSG:4326")
Layer layer = Graticule.createLines(bounds, [
[orientation: 'vertical', level: 2, spacing: 20],
[orientation: 'vertical', level: 1, spacing: 10 ],
[orientation: 'horizontal', level: 2, spacing: 20],
[orientation: 'horizontal', level: 1, spacing: 10 ]
], 2.0)
Format Recipes
The Format classes are in the geoscript.layer package.
A Format is a collection of Rasters.
Get a Format
Get a Format from a File
File file = new File("src/main/resources/earth.tif")
Format format = Format.getFormat(file)
println format.nameGeoTIFF
Get Names
Get names of the Rasters in a Format. Some Formats can contain more than one Raster.
File file = new File("src/main/resources/earth.tif")
Format format = Format.getFormat(file)
List<String> names = format.names
names.each { String name ->
println name
}earth
Read a Raster
Read a Raster from a File
File file = new File("src/main/resources/earth.tif")
Format format = Format.getFormat(file)
Raster raster = format.read("earth")
Write a Raster
Write a Raster to a File
File file = new File("src/main/resources/earth.tif")
Format format = Format.getFormat(file)
Raster raster = format.read("earth")
File outFile = new File("target/earth.png")
Format outFormat = Format.getFormat(outFile)
outFormat.write(raster)
Raster outRaster = outFormat.read("earth")
Check for a Raster
Check to see if the Format has a Raster
File file = new File("src/main/resources/earth.tif")
Format format = Format.getFormat(file)
boolean hasEarth = format.has("earth")
println "Has raster named earth? ${hasEarth}"
boolean hasWorld = format.has("world")
println "Has raster named world? ${hasWorld}"Has raster named earth? true Has raster named world? false
GeoTIFF
Read
Read a GeoTIFF Raster from a File
File file = new File("src/main/resources/earth.tif")
GeoTIFF geotiff = new GeoTIFF(file)
Raster raster = geotiff.read("earth")
Write
Write a GeoTIFF Raster to an ArcGrid Raster
File file = new File("src/main/resources/earth.tif")
GeoTIFF geotiff = new GeoTIFF(file)
Raster raster = geotiff.read("earth")
File arcGridFile = new File("target/earth.asc")
ArcGrid arcGrid = new ArcGrid(arcGridFile)
arcGrid.write(raster)
Raster arcGridRaster = arcGrid.read("earth")
ArcGrid
Read
Read an ArcGrid Raster from a File
File file = new File("src/main/resources/raster.asc")
ArcGrid arcGrid = new ArcGrid(file)
Raster raster = arcGrid.read("raster")Read a Grass ArcGrid Raster from a File
File file = new File("src/main/resources/grass.arx")
ArcGrid arcGrid = new ArcGrid(file)
Raster raster = arcGrid.read("grass")Raster Recipes
The Raster classes are in the geoscript.layer package.
Raster Properties
Read a Raster from a File
File file = new File("src/main/resources/earth.tif")
Format format = Format.getFormat(file)
Raster raster = format.read("earth")
Get the Raster’s Bounds.
Bounds bounds = raster.bounds
println "Bounds: ${bounds}"Bounds: (-179.99999999999997,-89.99999999998205,179.99999999996405,90.0,EPSG:4326)
Get the Raster’s Projection.
Projection projection = raster.proj
println "Projection: ${projection}"Projection: EPSG:4326
Get the Raster’s Size.
List size = raster.size
println "Size: ${size[0]}x${size[1]}"Size: 800x400
Get the Raster’s number of columns and rows.
int cols = raster.cols
int rows = raster.rows
println "Columns: ${cols} Rows: ${rows}"Columns: 800 Rows: 400
Get the Raster’s Bands.
List<Band> bands = raster.bands
println "Bands:"
bands.each { Band band ->
println " ${band}"
}Band: RED_BAND GREEN_BAND BLUE_BAND
Get the Raster’s block size.
List blockSize = raster.blockSize
println "Block size: ${blockSize[0]}x${blockSize[1]}"Block size: 800x8
Get the Raster’s pixel size.
List pixelSize = raster.pixelSize
println "Pixel size: ${pixelSize[0]}x${pixelSize[1]}"Pixel size: 0.44999999999995505x0.4499999999999551
Get more information about a Raster’s Bounds.
File file = new File("src/main/resources/earth.tif")
Format format = Format.getFormat(file)
Raster raster = format.read("earth")
List<Band> bands = raster.bands
bands.each { Band band ->
println "${band}"
println " Min = ${band.min}"
println " Max = ${band.max}"
println " No Data = ${band.noData}"
println " Is No Data = ${band.isNoData(12.45)}"
println " Unit = ${band.unit}"
println " Scale = ${band.scale}"
println " Offset = ${band.offset}"
println " Type = ${band.type}"
}RED_BAND Min = 0.0 Max = 255.0 No Data = [0.0] Is No Data = false Unit = null Scale = 1.0 Offset = 0.0 Type = byte GREEN_BAND Min = 0.0 Max = 255.0 No Data = [0.0] Is No Data = false Unit = null Scale = 1.0 Offset = 0.0 Type = byte BLUE_BAND Min = 0.0 Max = 255.0 No Data = [0.0] Is No Data = false Unit = null Scale = 1.0 Offset = 0.0 Type = byte
Get the minimum and maximum values from a Raster for a band
double minValue = raster.getMinValue(0)
double maxValue = raster.getMaxValue(0)
println "Min values: ${minValue} Max values: ${maxValue}"Min values: 56.0 Max values: 255.0
Get the minimum and maximum values from a Raster for each band
Map extrema = raster.extrema
println "Min values: ${extrema.min} Max values: ${extrema.max}"Min value: [56.0, 84.0, 91.0] Max value: [255.0, 255.0, 255.0]
Get a Point at the given pixel location.
Point point = raster.getPoint(7,9)
println "Geographic location at pixel 7,9 is ${point}"Geographic location at pixel 7,9 is POINT (-176.625 85.7249984741211)
Get a Pixel location at the given Point.
List pixel = raster.getPixel(new Point(-176.625, 85.72499))
println "Pixel coordinates at POINT (-176.625 85.7249984741211) is ${pixel[0]}, ${pixel[1]}"Pixel coordinates at POINT (-176.625 85.7249984741211) is 7.0, 9.0
Determine whether the Raster covers the given Point.
boolean containsPoint = raster.contains(new Point(-180, -90))
println "Does raster cover point? ${containsPoint}"Does raster cover point? true
Determine whether the Raster covers the given Pixel.
boolean containsPixel = raster.contains(500,600)
println "Does raster cover pixel? ${containsPixel}"Does raster cover pixel? false
Get a RenderedImage from the Raster
RenderedImage image = raster.image
Dispose of the Raster when you are done
raster.dispose()Raster Bands
Create a Band
Band band = new Band(
"red", (1)
0, (2)
255 (3)
)
println "Band = ${band.toString()} Min = ${band.min} Max = ${band.max}"| 1 | Description |
| 2 | Minimum value |
| 3 | Maximum value |
Band = red Min = 0.0 Max = 255.0
Create a Band with a no data value
Band band = new Band(
"red", (1)
0, (2)
255, (3)
255 (4)
)
println "Band = ${band.toString()} Min = ${band.min} Max = ${band.max} No Data = ${band.noData[0]}"| 1 | Description |
| 2 | Minimum value |
| 3 | Maximum value |
| 4 | No data value |
Band = red Min = 0.0 Max = 255.0 No Data = 255.0
Create a new Raster from Bands and set values to a random color.
Raster raster = new Raster(
new Bounds(-180,-90,180,90,"EPSG:4326"),
400,300,
[
new Band("red", 0, 255, 256),
new Band("green", 0, 255, 256),
new Band("blue", 0, 255, 256)
]
)
// Set values of each pixel
raster.eachCell { double value, double x, double y ->
Color color = Color.randomPastel
raster.setValue([x,y], color.rgb[0], 0)
raster.setValue([x,y], color.rgb[1], 1)
raster.setValue([x,y], color.rgb[2], 2)
}
Raster Values
Get values from a Raster
File file = new File("src/main/resources/pc.tif")
Format format = Format.getFormat(file)
Raster raster = format.read("pc")
Get values from a Raster with a Point.
double elevation = raster.getValue(new Point(-121.799927,46.867703))
println elevation3069.0
Get values from a Raster with a Pixel Location.
List pixel = [100,200]
elevation = raster.getValue(pixel)
println elevation288.0
Get neighboring values from a Raster with a Point Location.
Map neighborsOfPoint = raster.getNeighbors(new Point(-176.625, 85.72499), 0)
println "Values neighboring POINT (-176.625 85.7249984741211) = ${neighborsOfPoint}"Values neighboring POINT (-176.625 85.7249984741211) = [nw:103.0, n:104.0, ne:109.0, e:109.0, se:111.0, s:110.0, sw:110.0, w:108.0]
Get neighboring values from a Raster with a Pixel Location.
Map neighborsOfPixel = raster.getNeighbors([7,9], 0)
println "Values neighboring pixel 7,9 = ${neighborsOfPixel}"Values neighboring pixel 7,9 = [nw:103.0, n:104.0, ne:109.0, e:109.0, se:111.0, s:110.0, sw:110.0, w:108.0]
Get values from a Raster for a range of pixels in a list of lists.
int x = 10
int y = 8
int w = 5
int h = 6
int band = 0
List values = raster.getValues(x, y, w, h, band, false)
println values[[1032, 1186, 1340, 1435, 1301], [1143, 1143, 1193, 1224, 1313], [942, 938, 966, 982, 1129], [746, 835, 912, 949, 1028], [723, 948, 1130, 1244, 1211], [673, 890, 1100, 1133, 1024]]
Get values from a Raster for a range of pixels in a flat list.
List flatValues = raster.getValues(x, y, w, h, band, true)
println flatValues[1032, 1186, 1340, 1435, 1301, 1143, 1143, 1193, 1224, 1313, 942, 938, 966, 982, 1129, 746, 835, 912, 949, 1028, 723, 948, 1130, 1244, 1211, 673, 890, 1100, 1133, 1024]
Get values from a Raster for a range of pixels as a pretty printed string.
String valuesAsString = raster.getValuesAsString(x, y, w, h, band, prettyPrint: true)
println valuesAsString--------------------------------------------------- | 1032.00 | 1186.00 | 1340.00 | 1435.00 | 1301.00 | --------------------------------------------------- | 1143.00 | 1143.00 | 1193.00 | 1224.00 | 1313.00 | --------------------------------------------------- | 942.00 | 938.00 | 966.00 | 982.00 | 1129.00 | --------------------------------------------------- | 746.00 | 835.00 | 912.00 | 949.00 | 1028.00 | --------------------------------------------------- | 723.00 | 948.00 | 1130.00 | 1244.00 | 1211.00 | --------------------------------------------------- | 673.00 | 890.00 | 1100.00 | 1133.00 | 1024.00 | ---------------------------------------------------
Iterate over the cells in a Raster.
raster.eachCell(bounds: [0,0,5,5]) { double value, double pixelX, double pixelY ->
println "${pixelX},${pixelY} = ${value}"
}0.0,0.0 = 1061.0 1.0,0.0 = 996.0 2.0,0.0 = 945.0 3.0,0.0 = 960.0 4.0,0.0 = 904.0 0.0,1.0 = 1167.0 1.0,1.0 = 1149.0 2.0,1.0 = 1085.0 3.0,1.0 = 966.0 4.0,1.0 = 862.0 0.0,2.0 = 1112.0 1.0,2.0 = 998.0 2.0,2.0 = 882.0 3.0,2.0 = 775.0 4.0,2.0 = 700.0 0.0,3.0 = 990.0 1.0,3.0 = 850.0 2.0,3.0 = 715.0 3.0,3.0 = 638.0 4.0,3.0 = 654.0 0.0,4.0 = 833.0 1.0,4.0 = 706.0 2.0,4.0 = 611.0 3.0,4.0 = 681.0 4.0,4.0 = 841.0
Iterate over a window of cells in a Raster.
raster.eachWindow (bounds: [0,0,8,8], window: [2,2]) { Number[][] windowsValues, double pixelX, double pixelY ->
println "${pixelX},${pixelY} = ${windowsValues}"
}0.0,0.0 = [[1061, 996], [1167, 1149]] 1.0,0.0 = [[996, 945], [1149, 1085]] 2.0,0.0 = [[945, 960], [1085, 966]] 3.0,0.0 = [[960, 904], [966, 862]] 4.0,0.0 = [[904, 727], [862, 696]] 5.0,0.0 = [[727, 744], [696, 748]] 6.0,0.0 = [[744, 934], [748, 900]] 7.0,0.0 = [[934, 1099], [900, 1042]] 0.0,1.0 = [[1167, 1149], [1112, 998]] 1.0,1.0 = [[1149, 1085], [998, 882]] 2.0,1.0 = [[1085, 966], [882, 775]] 3.0,1.0 = [[966, 862], [775, 700]] 4.0,1.0 = [[862, 696], [700, 661]] 5.0,1.0 = [[696, 748], [661, 818]] 6.0,1.0 = [[748, 900], [818, 995]] 7.0,1.0 = [[900, 1042], [995, 1125]] 0.0,2.0 = [[1112, 998], [990, 850]] 1.0,2.0 = [[998, 882], [850, 715]] 2.0,2.0 = [[882, 775], [715, 638]] 3.0,2.0 = [[775, 700], [638, 654]] 4.0,2.0 = [[700, 661], [654, 826]] 5.0,2.0 = [[661, 818], [826, 945]] 6.0,2.0 = [[818, 995], [945, 922]] 7.0,2.0 = [[995, 1125], [922, 1078]] 0.0,3.0 = [[990, 850], [833, 706]] 1.0,3.0 = [[850, 715], [706, 611]] 2.0,3.0 = [[715, 638], [611, 681]] 3.0,3.0 = [[638, 654], [681, 841]] 4.0,3.0 = [[654, 826], [841, 949]] 5.0,3.0 = [[826, 945], [949, 1084]] 6.0,3.0 = [[945, 922], [1084, 1054]] 7.0,3.0 = [[922, 1078], [1054, 1093]] 0.0,4.0 = [[833, 706], [652, 618]] 1.0,4.0 = [[706, 611], [618, 548]] 2.0,4.0 = [[611, 681], [548, 631]] 3.0,4.0 = [[681, 841], [631, 694]] 4.0,4.0 = [[841, 949], [694, 877]] 5.0,4.0 = [[949, 1084], [877, 1018]] 6.0,4.0 = [[1084, 1054], [1018, 1142]] 7.0,4.0 = [[1054, 1093], [1142, 1172]] 0.0,5.0 = [[652, 618], [631, 579]] 1.0,5.0 = [[618, 548], [579, 506]] 2.0,5.0 = [[548, 631], [506, 483]] 3.0,5.0 = [[631, 694], [483, 556]] 4.0,5.0 = [[694, 877], [556, 686]] 5.0,5.0 = [[877, 1018], [686, 825]] 6.0,5.0 = [[1018, 1142], [825, 1004]] 7.0,5.0 = [[1142, 1172], [1004, 1053]] 0.0,6.0 = [[631, 579], [772, 766]] 1.0,6.0 = [[579, 506], [766, 627]] 2.0,6.0 = [[506, 483], [627, 529]] 3.0,6.0 = [[483, 556], [529, 473]] 4.0,6.0 = [[556, 686], [473, 556]] 5.0,6.0 = [[686, 825], [556, 669]] 6.0,6.0 = [[825, 1004], [669, 810]] 7.0,6.0 = [[1004, 1053], [810, 917]] 0.0,7.0 = [[772, 766], [900, 880]] 1.0,7.0 = [[766, 627], [880, 778]] 2.0,7.0 = [[627, 529], [778, 671]] 3.0,7.0 = [[529, 473], [671, 540]] 4.0,7.0 = [[473, 556], [540, 483]] 5.0,7.0 = [[556, 669], [483, 536]] 6.0,7.0 = [[669, 810], [536, 641]]
Set values on a Raster
File file = new File("src/main/resources/earth.tif")
GeoTIFF geotiff = new GeoTIFF(file)
Raster raster = geotiff.read("earth")
File arcGridFile = new File("target/earth.asc")
ArcGrid arcGrid = new ArcGrid(arcGridFile)
arcGrid.write(raster)
Raster arcGridRaster = arcGrid.read("earth")
arcGridRaster.eachCell {double value, double x, double y ->
double newValue = value + 100
arcGridRaster.setValue([x as int, y as int], newValue)
}
File arcGridAddFile = new File("target/earth_100.asc")
ArcGrid arcGridAdd = new ArcGrid(arcGridAddFile)
arcGridAdd.write(arcGridRaster)
Raster arcGridRasterAdd = arcGridAdd.read("earth_100")
List pixels = [
[92, 298],
[393.0, 343.0],
[795.0, 399.0]
]
pixels.each { List pixel ->
println "Original: ${raster.getValue(pixel)} New: ${arcGridRasterAdd.getValue(pixel)}"
}Original: 97.0 New: 197.0 Original: 96.0 New: 196.0 Original: 237.0 New: 337.0
Raster Processing
Crop
Crop a Raster with a Bounds
File file = new File("src/main/resources/earth.tif")
Format format = Format.getFormat(file)
Raster raster = format.read("earth")
Raster croppedRaster = raster.crop(new Bounds(-160.927734,6.751896,-34.716797,57.279043, "EPSG:4326"))
Project
Reproject a Raster to another Projection
File file = new File("src/main/resources/earth.tif")
Format format = Format.getFormat(file)
Raster raster = format.read("earth")
Projection projection = new Projection("EPSG:3857")
Raster projectedRaster = raster.crop(projection.geoBounds).reproject(projection)
Transform
File file = new File("src/main/resources/pc.tif")
Format format = Format.getFormat(file)
Raster raster = format.read("pc")Scale a Raster
Raster scaledRaster = raster.transform(scalex: 10, scaley: 10)
Shear a Raster
Raster shearedRaster = raster.transform(shearx: 10, sheary: 10)
Translate a Raster
Raster translatedRaster = raster.transform(translatex: 10.1, translatey: 12.6)
Transform a Raster with a combination of parameters
Raster transformedRaster = raster.transform(
scalex: 1.1, scaley: 2.1,
shearx: 0.4, sheary: 0.3,
translatex: 10.1, translatey: 12.6,
nodata: [-255],
interpolation: "NEAREST"
)
Select Bands
Extract a band from a Raster to create a new Raster
File file = new File("src/main/resources/earth.tif")
Format format = Format.getFormat(file)
Raster raster = format.read("earth")
Raster band1 = raster.selectBands([0])
Raster band2 = raster.selectBands([1])
Raster band3 = raster.selectBands([2])Band 1
Band 2
Band 3
Merge
Merge a List of Rasters representing different bands together to create a single Raster
File file = new File("src/main/resources/earth.tif")
Format format = Format.getFormat(file)
Raster raster = format.read("earth")
Raster band1 = raster.selectBands([0])
Raster band2 = raster.selectBands([1])
Raster band3 = raster.selectBands([2])
Raster mergedRaster = Raster.merge([band1,band2,band3], transform: "FIRST")
Mosaic
Mosaic a List of Rasters together to create a single Raster
File file = new File("src/main/resources/pc.tif")
Format format = Format.getFormat(file)
Raster raster = format.read("pc")
Bounds bounds = raster.bounds
List<Raster> rasters = bounds.tile(0.5).collect { Bounds b ->
raster.crop(b)
}
Raster mosaicedRaster = Raster.mosaic(rasters)
Contours
Create vector contours from a Raster
File file = new File("src/main/resources/pc.tif")
Format format = Format.getFormat(file)
Raster raster = format.read("pc")
int band = 0
int interval = 300
boolean simplify = true
boolean smooth = true
Layer contours = raster.contours(band, interval, simplify, smooth)
Stylize
Stylize a Raster by baking in a style to create a new Raster
File file = new File("src/main/resources/pc.tif")
Format format = Format.getFormat(file)
Raster raster = format.read("pc")
Raster stylizedRaster = raster.stylize(new ColorMap([
[color: "#9fd182", quantity:25],
[color: "#3e7f3c", quantity:470],
[color: "#133912", quantity:920],
[color: "#08306b", quantity:1370],
[color: "#fffff5", quantity:1820],
]))
Shaded Relief
Create a shaded relief Raster from another Raster
File file = new File("src/main/resources/pc.tif")
Format format = Format.getFormat(file)
Raster raster = format.read("pc")
Raster shadedReliefRaster = raster.createShadedRelief(
1.0, (1)
25, (2)
260 (3)
)| 1 | scale |
| 2 | altitude |
| 3 | azimuth |
Reclassify
Reclassify a Raster
File file = new File("src/main/resources/pc.tif")
Format format = Format.getFormat(file)
Raster raster = format.read("pc")
Raster reclassifiedRaster = raster.reclassify([
[min:0, max:0, value: 1],
[min:0, max:50, value: 2],
[min:50, max:200, value: 3],
[min:200, max:1000, value: 4],
[min:1000, max:1500, value: 5],
[min:1500, max:4000, value: 6]
])
Scale
Scale a Raster
File file = new File("src/main/resources/pc.tif")
Format format = Format.getFormat(file)
Raster raster = format.read("pc")
println "Original Raster Size = ${raster.size[0]}x${raster.size[1]}"
Raster scaledRaster = raster.scale(0.5, 0.5)
println "Scaled Raster Size = ${scaledRaster.size[0]}x${scaledRaster.size[1]}"Original Raster Size = 800x400 Scaled Raster Size = 400x200
Resample
Resample a Raster
File file = new File("src/main/resources/pc.tif")
Format format = Format.getFormat(file)
Raster raster = format.read("pc")
println "Original Raster Bounds = ${raster.bounds}"
println "Original Raster Size = ${raster.size[0]}x${raster.size[1]}"
Raster resampledRaster = raster.resample(size: [400, 400], bbox: raster.bounds.scale(-2))
println "Resampled Raster Bounds = ${resampledRaster.bounds}"
println "Resampled Raster Size = ${resampledRaster.size[0]}x${resampledRaster.size[1]}"Original Raster Bounds = (-123.55291606131708,46.25375026634816,-120.73958272798374,47.522916933014834,EPSG:4326) Original Raster Size = 800x400 Resampled Raster Bounds = (-124.95958272798374,45.619166933014824,-119.33291606131708,48.157500266348165,EPSG:4326) Resampled Raster Size = 400x400
Normalize
Normalize a Raster by diving all values by the maximum value.
File file = new File("src/main/resources/pc.tif")
Format format = Format.getFormat(file)
Raster raster = format.read("pc")
println "Original Raster Min Max values = ${raster.extrema.min[0]} - ${raster.extrema.max[0]}"
Raster normalizedRaster = raster.normalize()
println "Normalized Raster Min Max values = ${normalizedRaster.extrema.min[0]} - ${normalizedRaster.extrema.max[0]}"Original Raster Min Max values = -23.0 - 4370.0 Normalized Raster Min Max values = -0.005263158120214939 - 1.0
Convolve
Convolve a Raster with a radius.
File file = new File("src/main/resources/pc.tif")
Format format = Format.getFormat(file)
Raster raster = format.read("pc")
println "Original Raster Min Max values = ${raster.extrema.min[0]} - ${raster.extrema.max[0]}"
Raster convolvedRaster = raster.convolve(2)
println "Convolved Raster Min Max values = ${convolvedRaster.extrema.min[0]} - ${convolvedRaster.extrema.max[0]}"Original Raster Min Max values = -23.0 - 4370.0 Convolved Raster Min Max values = -32767.0 - 32767.0
Convolve a Raster with a width and height.
File file = new File("src/main/resources/pc.tif")
Format format = Format.getFormat(file)
Raster raster = format.read("pc")
println "Original Raster Min Max values = ${raster.extrema.min[0]} - ${raster.extrema.max[0]}"
Raster convolvedRaster = raster.convolve(1,2)
println "Convolved Raster Min Max values = ${convolvedRaster.extrema.min[0]} - ${convolvedRaster.extrema.max[0]}"Original Raster Min Max values = -23.0 - 4370.0 Convolved Raster Min Max values = -32767.0 - 8675.0
Invert
Invert the values of a Raster
File file = new File("src/main/resources/pc.tif")
Format format = Format.getFormat(file)
Raster raster = format.read("pc")
Raster invertedRaster = raster.invert()
Exponent
Calculate the exponent of the values of a Raster
File file = new File("src/main/resources/pc.tif")
Format format = Format.getFormat(file)
Raster raster = format.read("pc")
Raster expRaster = raster.exp()
Absolute
Calculate the absolute value of the values of a Raster
File file = new File("src/main/resources/absolute.tif")
Format format = Format.getFormat(file)
Raster raster = format.read("absolute")
Raster absolute = raster.absolute()
Log
Calculate the log of the values of a Raster
File file = new File("src/main/resources/pc.tif")
Format format = Format.getFormat(file)
Raster raster = format.read("pc")
Raster logRaster = raster.log()
Vectorize
Create a Polygon Layer from a Raster
File file = new File("src/main/resources/pc.tif")
Format format = Format.getFormat(file)
Raster raster = format.read("pc")
Raster reclassifiedRaster = raster.reclassify([
[min:0, max:0, value: 1],
[min:0, max:50, value: 2],
[min:50, max:200, value: 3],
[min:200, max:1000, value: 4],
[min:1000, max:1500, value: 5],
[min:1500, max:4000, value: 6]
])
Layer layer = reclassifiedRaster.polygonLayer
Create a Point Layer from a Raster
File file = new File("src/main/resources/pc.tif")
Format format = Format.getFormat(file)
Raster raster = format.read("pc").crop(new Bounds(-121.878548,46.808402,-121.636505,46.896097, "EPSG:4326"))
Layer layer = raster.pointLayer
Extract a foot print from a Raster
File file = new File("src/main/resources/earth.tif")
Format format = Format.getFormat(file)
Raster raster = format.read("earth")
Layer layer = raster.extractFootPrint()
Calculate zonal statistics
File file = new File("src/main/resources/pc.tif")
Format format = Format.getFormat(file)
Raster raster = format.read("pc")
Layer zones = new Memory().create("zones", [new Field("geom","Geometry","EPSG:4326")])
Bounds bounds = raster.bounds
bounds.tile(0.5).each{b -> zones.add([b.geometry])}
Layer stats = raster.zonalStatistics(0, zones)
| count | min | max | sum | avg | stddev |
|---|---|---|---|---|---|
79950 |
-3.0 |
1718.0 |
2.6618944E7 |
332.94489055659943 |
262.73459374414483 |
80000 |
254.0 |
4370.0 |
9.2963902E7 |
1162.0487749999913 |
439.0841907966851 |
71728 |
-23.0 |
1755.0 |
1.1585759E7 |
161.52351940664724 |
179.29389227723505 |
80000 |
24.0 |
2728.0 |
7.9051464E7 |
988.1433000000056 |
465.8407188458327 |
Histogram
Get histogram of the Raster
File file = new File("src/main/resources/earth.tif")
Format format = Format.getFormat(file)
Raster raster = format.read("earth")
Histogram histogram = raster.getHistogram()
println "# of bands = ${histogram.numberOfBands}"
println "# Counts = ${histogram.counts().size()}"
println "# Bins = ${histogram.bins().size()}"
println "Count 25 = ${histogram.count(25)}"
println "Bin 45 = ${histogram.bin(45)}"
Chart chart = Bar.xy(histogram.counts(0).withIndex().collect {int count, int index -> [index, count]})# of bands = 3 # Counts = 256 # Bins = 256 Count 25 = 0 Bin 45 = [45.0, 46.0]
Raster Algebra
Add
Add a constant value to a Raster
File file = new File("src/main/resources/pc.tif")
Format format = Format.getFormat(file)
Raster raster = format.read("pc")
double elevation1 = raster.getValue(new Point(-121.799927,46.867703))
println elevation1
Raster higherRaster = raster.add(100.00)
double elevation2 = higherRaster.getValue(new Point(-121.799927,46.867703))
println elevation23069.0 3169.0
Add two Raster together
Raster lowRaster = Format.getFormat(new File("src/main/resources/low.tif")).read("low")
Raster highRaster = Format.getFormat(new File("src/main/resources/high.tif")).read("high")
Raster lowPlusHighRaster = lowRaster.add(highRaster)Low
High
Low + High
Subtract
Subtract a constant value from a Raster
File file = new File("src/main/resources/pc.tif")
Format format = Format.getFormat(file)
Raster raster = format.read("pc")
double elevation1 = raster.getValue(new Point(-121.799927,46.867703))
println elevation1
Raster lowerRaster = raster.minus(50.00)
double elevation2 = lowerRaster.getValue(new Point(-121.799927,46.867703))
println elevation23069.0 3019.0
Subtract the Raster from a constant value
File file = new File("src/main/resources/pc.tif")
Format format = Format.getFormat(file)
Raster raster = format.read("pc")
double elevation1 = raster.getValue(new Point(-121.799927,46.867703))
println elevation1
Raster lowerRaster = raster.minusFrom(2000.0)
double elevation2 = lowerRaster.getValue(new Point(-121.799927,46.867703))
println elevation23069.0 -1069.0
Subtract a Raster from another Raster
Raster lowRaster = Format.getFormat(new File("src/main/resources/low.tif")).read("low")
Raster highRaster = Format.getFormat(new File("src/main/resources/high.tif")).read("high")
Raster highMinusLowRaster = highRaster.minus(lowRaster)Low
High
High - Low
Multiply
Multiply a constant value against a Raster
File file = new File("src/main/resources/pc.tif")
Format format = Format.getFormat(file)
Raster raster = format.read("pc")
double elevation1 = raster.getValue(new Point(-121.799927,46.867703))
println elevation1
Raster higherRaster = raster.multiply(2.0)
double elevation2 = higherRaster.getValue(new Point(-121.799927,46.867703))
println elevation23069.0 6138.0
Multiply a Raster with another Raster
Raster lowRaster = Format.getFormat(new File("src/main/resources/low.tif")).read("low")
Raster highRaster = Format.getFormat(new File("src/main/resources/high.tif")).read("high")
Raster multiplyRaster = highRaster.multiply(lowRaster)Low
High
High * Low
Divide
Divide a constant value against a Raster
File file = new File("src/main/resources/pc.tif")
Format format = Format.getFormat(file)
Raster raster = format.read("pc")
double elevation1 = raster.getValue(new Point(-121.799927,46.867703))
println elevation1
Raster lowerRaster = raster.divide(2.0)
double elevation2 = lowerRaster.getValue(new Point(-121.799927,46.867703))
println elevation23069.0 1534.5
Divide a Raster by another Raster
Raster lowRaster = Format.getFormat(new File("src/main/resources/low.tif")).read("low")
Raster highRaster = Format.getFormat(new File("src/main/resources/high.tif")).read("high")
Raster divideRaster = highRaster.divide(lowRaster)Low
High
High / Low
World File
Create a world file from a Bounds and size.
File file = new File("target/worldfile.txt")
WorldFile worldFile = new WorldFile(new Bounds(-123.06, 46.66, -121.15, 47.48), [500,500], file)
println "Pixel Size = ${worldFile.pixelSize[0]} x ${worldFile.pixelSize[1]}"
println "Rotation = ${worldFile.rotation[0]} x ${worldFile.rotation[1]}"
println "Upper Left Coordinate = ${worldFile.ulc.x}, ${worldFile.ulc.y}"
println "File = ${file.text}"Pixel Size = 0.003819999999999993 x -0.0016400000000000006 Rotation = 0.0 x 0.0 Upper Left Coordinate = -123.05809, 47.47918 File = 0.003819999999999993 0.0 0.0 -0.0016400000000000006 -123.05809 47.47918
Create a world file from an existing file.
File file = new File("src/main/resources/worldfile.txt")
WorldFile worldFile = new WorldFile(file)
println "Pixel Size = ${worldFile.pixelSize[0]} x ${worldFile.pixelSize[1]}"
println "Rotation = ${worldFile.rotation[0]} x ${worldFile.rotation[1]}"
println "Upper Left Coordinate = ${worldFile.ulc.x}, ${worldFile.ulc.y}"Pixel Size = 0.003819999999999993 x -0.0016400000000000006 Rotation = 0.0 x 0.0 Upper Left Coordinate = -123.05809, 47.47918
Map Algebra
GeoScript uses Jiffle to perform map or raster algebra.
Add two Rasters together
Raster lowRaster = Format.getFormat(new File("src/main/resources/low.tif")).read("low")
Raster highRaster = Format.getFormat(new File("src/main/resources/high.tif")).read("high")
MapAlgebra mapAlgebra = new MapAlgebra()
Raster output = mapAlgebra.calculate("dest = raster1 + raster2;", [raster1: lowRaster, raster2: highRaster], size: [300, 200])Low
High
High + Low
Generate a wave Raster
MapAlgebra algebra = new MapAlgebra()
String script = """
init {
// image centre coordinates
xc = width() / 2;
yc = height() / 2;
// constant term
C = M_PI * 8;
}
dx = (x() - xc) / xc;
dy = (y() - yc) / yc;
d = sqrt(dx*dx + dy*dy);
destImg = sin(C * d);
"""
Raster output = algebra.calculate(script, [:], outputName: "destImg")
Create a Raster of all cells greater than a given value
File file = new File("src/main/resources/pc.tif")
Format format = Format.getFormat(file)
Raster raster = format.read("pc")
println raster.size
MapAlgebra mapAlgebra = new MapAlgebra()
Raster output = mapAlgebra.calculate("dest = src > 1100;", [src: raster], size: [800, 400])
println output.extrema
WMS Recipes
The WMS classes are in the geoscript.layer package.
WMS Server
Connect to a WMS Server and list properties
WMS wms = new WMS("https://lpdaacsvc.cr.usgs.gov/ogc/wms")
println "Name = ${wms.name}"
println "Title = ${wms.title}"
println "Abstract = ${wms.abstract}"
println "Keywords = ${wms.keywords.join(', ')}"
println "Online Resource = ${wms.onlineResource}"
println "Update Sequence = ${wms.updateSequence}"
println "Version = ${wms.version}"
println "Map Formats = ${wms.getMapFormats.join(', ')}"Name = WMS Title = GeoServer Web Map Service Abstract = A compliant implementation of WMS plus most of the SLD extension (dynamic styling). Can also generate PDF, SVG, KML, GeoRSS Keywords = WFS, WMS, GEOSERVER Online Resource = http://geoserver.sourceforge.net/html/index.php Update Sequence = 35327 Version = 1.3.0 Map Formats = image/png, application/atom+xml, application/pdf, application/rss+xml, application/vnd.google-earth.kml+xml, application/vnd.google-earth.kml+xml;mode=networklink, application/vnd.google-earth.kmz, image/geotiff, image/geotiff8, image/gif, image/jpeg, image/png; mode=8bit, image/svg+xml, image/tiff, image/tiff8, text/html; subtype=openlayers
Get a list of Layers
WMS wms = new WMS("https://lpdaacsvc.cr.usgs.gov/ogc/wms")
wms.layers.subList(0,10).each { WMS.Layer layer ->
println layer
}MODIS:MCD12Q1.2016001.006.LandCover MODIS:MOD09A1.2018073.006.SurRefl MODIS:MOD09A1.2018081.006.SurRefl MODIS:MOD09A1.2018089.006.SurRefl MODIS:MOD09A1.2018097.006.SurRefl MODIS:MOD09A1.2018105.006.SurRefl MODIS:MOD09A1.2018113.006.SurRefl MODIS:MOD09A1.2018121.006.SurRefl MODIS:MOD09A1.2018129.006.SurRefl MODIS:MOD09A1.2018137.006.SurRefl
Get a Layer
WMS wms = new WMS("https://lpdaacsvc.cr.usgs.gov/ogc/wms")
WMS.Layer layer = wms.getLayer("MODIS:MOD09A1.2018185.006.SurRefl")
println "Name = ${layer.name}"
println "Title = ${layer.title}"
println "Bounds = ${layer.bounds}"
println "Lat/Lon Bounds = ${layer.latLonBounds}"
println "Queryable = ${layer.queryable}"
println "Min Scale = ${layer.minScale}"
println "Max Scale = ${layer.maxScale}"Name = MODIS:MOD09A1.2018185.006.SurRefl Title = MOD09A1.2018185.006.SurRefl Bounds = [(-90.00000143999999,-180.0,90.0,180.00000287999998,EPSG:4326), (-180.0,-90.00000143999999,180.00000287999998,90.0,EPSG:4326)] Lat/Lon Bounds = (-180.0,-90.00000143999999,180.00000287999998,90.0,EPSG:4326) Queryable = true Min Scale = NaN Max Scale = NaN
Get a Raster
WMS wms = new WMS("https://lpdaacsvc.cr.usgs.gov/ogc/wms")
Raster raster = wms.getRaster(["MODIS:MOD14A2.2018209.006.Fire"])
Get an Image
WMS wms = new WMS("https://lpdaacsvc.cr.usgs.gov/ogc/wms")
BufferedImage image = wms.getImage(["MODIS:MOD17A2H.2019041.006.GPP"])
WMSLayer
A WMSLayer is a way to draw one or more WMS layers on a Map.
Use WMS Layers to render a Map
WMS wms = new WMS("http://1maps.geo-solutions.it/geoserver/osm/wms?service=wms&version=1.1.1&request=GetCapabilities")
WMSLayer layer = new WMSLayer(wms, ["icesheet_polygons", "ne_10m_admin_0_countries"])
Map map = new Map(layers: [layer], backgroundColor: "#B0C4DE", bounds: new Bounds(-179, -85, 179, 85, "EPSG:4326").reproject("EPSG:3857"))
BufferedImage image = map.renderToImage()
Tile Recipes
The Tile classes are in the geoscript.layer package.
Tile
Tile Properties
Get a Tile’s Properties.
byte[] data = new File("src/main/resources/tile.png").bytes
Tile tile = new Tile(2,1,3,data)
println "Z = ${tile.z}"
println "X = ${tile.x}"
println "Y = ${tile.y}"
println "Tile = ${tile.toString()}"
println "# bytes = ${tile.data.length}"
println "Data as base64 encoded string = ${tile.base64String}"Z = 2 X = 1 Y = 3 Tile = Tile(x:1, y:3, z:2) # bytes = 11738 Data as base64 encoded string = iVBORw0KGgoAAAANSUhEUgAAAQAAAAEACAYAAABccqhmAAAtoU...
Grid
A Grid describes a level in a Pyramid of Tiles.
Grid Properties
Grid grid = new Grid(1, 2, 2, 78206.0, 78206.0)
println "Zoom Level: ${grid.z}"
println "Width / # Columns: ${grid.width}"
println "Height / # Rows: ${grid.height}"
println "Size / # Tiles: ${grid.size}"
println "X Resolution: ${grid.xResolution}"
println "Y Resolution: ${grid.yResolution}"Zoom Level: 1 Width / # Columns: 2 Height / # Rows: 2 Size / # Tiles: 4 X Resolution: 78206.0 Y Resolution: 78206.0
Pyramid
Pyramid Properties
Get the Pyramid’s Bounds.
Pyramid pyramid = Pyramid.createGlobalMercatorPyramid()
Bounds bounds = pyramid.bounds
println bounds(-2.0036395147881314E7,-2.0037471205137067E7,2.0036395147881314E7,2.003747120513706E7,EPSG:3857)
Get the Pyramid’s projection.
Projection proj = pyramid.proj
println projEPSG:3857
Get the Pyramid’s Origin.
Pyramid.Origin origin = pyramid.origin
println originBOTTOM_LEFT
Get the Pyramid’s Tile Width and Height.
int tileWidth = pyramid.tileWidth
int tileHeight = pyramid.tileHeight
println "${tileWidth} x ${tileHeight}"256 x 256
Create Pyramids
Create a Global Mercator Pyramid.
Pyramid pyramid = Pyramid.createGlobalMercatorPyramid()
println "Projection: ${pyramid.proj}"
println "Origin: ${pyramid.origin}"
println "Bounds: ${pyramid.bounds}"
println "Max Zoom: ${pyramid.maxGrid.z}"Projection: EPSG:3857 Origin: BOTTOM_LEFT Bounds: (-2.0036395147881314E7,-2.0037471205137067E7,2.0036395147881314E7,2.003747120513706E7,EPSG:3857) Max Zoom: 19
Create a Global Geodetic Pyramid.
Pyramid pyramid = Pyramid.createGlobalGeodeticPyramid()
println "Projection: ${pyramid.proj}"
println "Origin: ${pyramid.origin}"
println "Bounds: ${pyramid.bounds}"
println "Max Zoom: ${pyramid.maxGrid.z}"Projection: EPSG:4326 Origin: BOTTOM_LEFT Bounds: (-179.99,-89.99,179.99,89.99,EPSG:4326) Max Zoom: 19
Create a Global Mercator Pyramid from a well known name.
Well known names include:
-
GlobalMercator
-
Mercator
-
GlobalMercatorBottomLeft
-
GlobalMercatorTopLeft
-
GlobalGeodetic
-
Geodetic
Pyramid pyramid = Pyramid.fromString("mercator")
println "Projection: ${pyramid.proj}"
println "Origin: ${pyramid.origin}"
println "Bounds: ${pyramid.bounds}"
println "Max Zoom: ${pyramid.maxGrid.z}"Projection: EPSG:3857 Origin: BOTTOM_LEFT Bounds: (-2.0036395147881314E7,-2.0037471205137067E7,2.0036395147881314E7,2.003747120513706E7,EPSG:3857) Max Zoom: 19
Get Bounds from a Pyramid
Get the Bounds for a Tile.
Pyramid pyramid = Pyramid.createGlobalMercatorPyramid()
Tile tile = new Tile(2, 1, 1)
Bounds bounds = pyramid.bounds(tile)
println "The bounds of ${tile} is ${bounds}"The bounds of Tile(x:1, y:1, z:2) is (-1.0018197573940657E7,-1.0018735602568535E7,0.0,-3.725290298461914E-9,EPSG:3857)
Get the Bounds for an area around a Point at a zoom level.
Pyramid pyramid = Pyramid.createGlobalMercatorPyramid()
Point point = Projection.transform(new Point(22.1539306640625, 37.67077737288316), "EPSG:4326", "EPSG:3857")
int zoomLevel = 8
int width = 400
int height = 400
Bounds bounds = pyramid.bounds(point, zoomLevel, width, height)
println "The bounds around ${point} is ${bounds}"The bounds around POINT (2466164.2805929263 4533021.525424092) is (2343967.4055929263,4410824.650424092,2588361.1555929263,4655218.400424092,EPSG:3857)
Get a Grid from a Pyramid
Get a the min Grid.
Pyramid pyramid = Pyramid.createGlobalMercatorPyramid()
Grid grid = pyramid.minGrid
println "Zoom Level: ${grid.z}"
println "Width / # Columns: ${grid.width}"
println "Height / # Rows: ${grid.height}"
println "Size / # Tiles: ${grid.size}"
println "X Resolution: ${grid.xResolution}"
println "Y Resolution: ${grid.yResolution}"Zoom Level: 0 Width / # Columns: 1 Height / # Rows: 1 Size / # Tiles: 1 X Resolution: 156412.0 Y Resolution: 156412.0
Get a the max Grid.
Pyramid pyramid = Pyramid.createGlobalMercatorPyramid()
Grid grid = pyramid.maxGrid
println "Zoom Level: ${grid.z}"
println "Width / # Columns: ${grid.width}"
println "Height / # Rows: ${grid.height}"
println "Size / # Tiles: ${grid.size}"
println "X Resolution: ${grid.xResolution}"
println "Y Resolution: ${grid.yResolution}"Zoom Level: 19 Width / # Columns: 524288 Height / # Rows: 524288 Size / # Tiles: 274877906944 X Resolution: 0.29833221435546875 Y Resolution: 0.29833221435546875
Get a Grid from a Pyramid by Zoom Level.
Pyramid pyramid = Pyramid.createGlobalMercatorPyramid()
Grid grid = pyramid.grid(1)
println "Zoom Level: ${grid.z}"
println "Width / # Columns: ${grid.width}"
println "Height / # Rows: ${grid.height}"
println "Size / # Tiles: ${grid.size}"
println "X Resolution: ${grid.xResolution}"
println "Y Resolution: ${grid.yResolution}"Zoom Level: 1 Width / # Columns: 2 Height / # Rows: 2 Size / # Tiles: 4 X Resolution: 78206.0 Y Resolution: 78206.0
Get a Grid from a Pyramid by a Bounds and Resolution.
Pyramid pyramid = Pyramid.createGlobalMercatorPyramid()
Bounds bounds = new Bounds(-123.09, 46.66, -121.13, 47.48, "EPSG:4326").reproject("EPSG:3857")
Grid grid = pyramid.grid(bounds, bounds.width / 400.0, bounds.height / 200.0)
println "Zoom Level: ${grid.z}"
println "Width / # Columns: ${grid.width}"
println "Height / # Rows: ${grid.height}"
println "Size / # Tiles: ${grid.size}"
println "X Resolution: ${grid.xResolution}"
println "Y Resolution: ${grid.yResolution}"Zoom Level: 8 Width / # Columns: 256 Height / # Rows: 256 Size / # Tiles: 65536 X Resolution: 610.984375 Y Resolution: 610.984375
Get a Grid from a Pyramid by a Bounds and Size.
Pyramid pyramid = Pyramid.createGlobalMercatorPyramid()
Bounds bounds = new Bounds(-123.09, 46.66, -121.13, 47.48, "EPSG:4326").reproject("EPSG:3857")
Grid grid = pyramid.grid(bounds, 400, 200)
println "Zoom Level: ${grid.z}"
println "Width / # Columns: ${grid.width}"
println "Height / # Rows: ${grid.height}"
println "Size / # Tiles: ${grid.size}"
println "X Resolution: ${grid.xResolution}"
println "Y Resolution: ${grid.yResolution}"Zoom Level: 8 Width / # Columns: 256 Height / # Rows: 256 Size / # Tiles: 65536 X Resolution: 610.984375 Y Resolution: 610.984375
Get Tile Coordinates
Get the tile coordinates from a Pyramid by Bounds and zoom level
Pyramid pyramid = Pyramid.createGlobalMercatorPyramid()
Bounds bounds = new Bounds(-124.73142200000001, 24.955967, -66.969849, 49.371735, "EPSG:4326").reproject("EPSG:3857")
long zoomLevel = 4
Map<String, Integer> coords = pyramid.getTileCoordinates(bounds, zoomLevel)
println "Min X = ${coords.minX}"
println "Min Y = ${coords.minY}"
println "Max X = ${coords.maxX}"
println "Max Y = ${coords.maxY}"Min X = 2 Min Y = 9 Max X = 5 Max Y = 10
Get the tile coordinates from a Pyramid by Bounds and Grid
Pyramid pyramid = Pyramid.createGlobalMercatorPyramid()
Bounds bounds = new Bounds(20.798492,36.402494,22.765045,37.223768, "EPSG:4326").reproject("EPSG:3857")
Grid grid = pyramid.grid(10)
Map<String, Integer> coords = pyramid.getTileCoordinates(bounds, grid)
println "Min X = ${coords.minX}"
println "Min Y = ${coords.minY}"
println "Max X = ${coords.maxX}"
println "Max Y = ${coords.maxY}"Min X = 571 Min Y = 623 Max X = 576 Max Y = 626
Reading and Writing Pyramids
The Pyramid IO classes are in the geoscript.layer.io package.
Finding Pyramid Writer and Readers
List all Pyramid Writers
List<PyramidWriter> writers = PyramidWriters.list()
writers.each { PyramidWriter writer ->
println writer.class.simpleName
}CsvPyramidWriter GdalTmsPyramidWriter JsonPyramidWriter XmlPyramidWriter
Find a Pyramid Writer
Pyramid pyramid = Pyramid.createGlobalGeodeticPyramid(maxZoom: 2)
PyramidWriter writer = PyramidWriters.find("csv")
String pyramidStr = writer.write(pyramid)
println pyramidStrEPSG:4326 -179.99,-89.99,179.99,89.99,EPSG:4326 BOTTOM_LEFT 256,256 0,2,1,0.703125,0.703125 1,4,2,0.3515625,0.3515625 2,8,4,0.17578125,0.17578125
List all Pyramid Readers
List<PyramidReader> readers = PyramidReaders.list()
readers.each { PyramidReader reader ->
println reader.class.simpleName
}CsvPyramidReader GdalTmsPyramidReader JsonPyramidReader XmlPyramidReader
Find a Pyramid Reader
PyramidReader reader = PyramidReaders.find("csv")
Pyramid pyramid = reader.read("""EPSG:3857
-2.0036395147881314E7,-2.0037471205137067E7,2.0036395147881314E7,2.003747120513706E7,EPSG:3857
BOTTOM_LEFT
256,256
0,1,1,156412.0,156412.0
1,2,2,78206.0,78206.0
2,4,4,39103.0,39103.0
3,8,8,19551.5,19551.5
4,16,16,9775.75,9775.75
""")
println pyramidgeoscript.layer.Pyramid(proj:EPSG:3857, bounds:(-2.0036395147881314E7,-2.0037471205137067E7,2.0036395147881314E7,2.003747120513706E7,EPSG:3857), origin:BOTTOM_LEFT, tileWidth:256, tileHeight:256)
JSON
Get a JSON String from a Pyramid.
Pyramid pyramid = Pyramid.createGlobalMercatorPyramid(maxZoom: 4)
String json = pyramid.json
println json{
"proj": "EPSG:3857",
"bounds": {
"minX": -2.0036395147881314E7,
"minY": -2.0037471205137067E7,
"maxX": 2.0036395147881314E7,
"maxY": 2.003747120513706E7
},
"origin": "BOTTOM_LEFT",
"tileSize": {
"width": 256,
"height": 256
},
"grids": [
{
"z": 0,
"width": 1,
"height": 1,
"xres": 156412.0,
"yres": 156412.0
},
{
"z": 1,
"width": 2,
"height": 2,
"xres": 78206.0,
"yres": 78206.0
},
{
"z": 2,
"width": 4,
"height": 4,
"xres": 39103.0,
"yres": 39103.0
},
{
"z": 3,
"width": 8,
"height": 8,
"xres": 19551.5,
"yres": 19551.5
},
{
"z": 4,
"width": 16,
"height": 16,
"xres": 9775.75,
"yres": 9775.75
}
]
}
XML
Get a XML String from a Pyramid.
Pyramid pyramid = Pyramid.createGlobalMercatorPyramid(maxZoom: 4)
String xml = pyramid.xml
println xml<pyramid>
<proj>EPSG:3857</proj>
<bounds>
<minX>-2.0036395147881314E7</minX>
<minY>-2.0037471205137067E7</minY>
<maxX>2.0036395147881314E7</maxX>
<maxY>2.003747120513706E7</maxY>
</bounds>
<origin>BOTTOM_LEFT</origin>
<tileSize>
<width>256</width>
<height>256</height>
</tileSize>
<grids>
<grid>
<z>0</z>
<width>1</width>
<height>1</height>
<xres>156412.0</xres>
<yres>156412.0</yres>
</grid>
<grid>
<z>1</z>
<width>2</width>
<height>2</height>
<xres>78206.0</xres>
<yres>78206.0</yres>
</grid>
<grid>
<z>2</z>
<width>4</width>
<height>4</height>
<xres>39103.0</xres>
<yres>39103.0</yres>
</grid>
<grid>
<z>3</z>
<width>8</width>
<height>8</height>
<xres>19551.5</xres>
<yres>19551.5</yres>
</grid>
<grid>
<z>4</z>
<width>16</width>
<height>16</height>
<xres>9775.75</xres>
<yres>9775.75</yres>
</grid>
</grids>
</pyramid>
CSV
Get a CSV String from a Pyramid.
Pyramid pyramid = Pyramid.createGlobalMercatorPyramid(maxZoom: 4)
String csv = pyramid.csv
println csvEPSG:3857 -2.0036395147881314E7,-2.0037471205137067E7,2.0036395147881314E7,2.003747120513706E7,EPSG:3857 BOTTOM_LEFT 256,256 0,1,1,156412.0,156412.0 1,2,2,78206.0,78206.0 2,4,4,39103.0,39103.0 3,8,8,19551.5,19551.5 4,16,16,9775.75,9775.75
GDAL XML
Write a Pyramid to a GDAL XML File
Pyramid pyramid = Pyramid.createGlobalMercatorPyramid(maxZoom: 4)
GdalTmsPyramidWriter writer = new GdalTmsPyramidWriter()
String xml = writer.write(pyramid, serverUrl: 'https://myserver.com/${z}/${x}/${y}', imageFormat: 'png')
println xml<GDAL_WMS>
<Service name='TMS'>
<ServerURL>https://myserver.com/${z}/${x}/${y}</ServerURL>
<SRS>EPSG:3857</SRS>
<ImageFormat>png</ImageFormat>
</Service>
<DataWindow>
<UpperLeftX>-2.0036395147881314E7</UpperLeftX>
<UpperLeftY>2.003747120513706E7</UpperLeftY>
<LowerRightX>2.0036395147881314E7</LowerRightX>
<LowerRightY>-2.0037471205137067E7</LowerRightY>
<TileLevel>4</TileLevel>
<TileCountX>1</TileCountX>
<TileCountY>1</TileCountY>
<YOrigin>bottom</YOrigin>
</DataWindow>
<Projection>EPSG:3857</Projection>
<BlockSizeX>256</BlockSizeX>
<BlockSizeY>256</BlockSizeY>
<BandsCount>3</BandsCount>
</GDAL_WMS>
Read a Pyramid from a GDAL XML File
String xml = '''<GDAL_WMS>
<Service name='TMS'>
<ServerURL>https://myserver.com/${z}/${x}/${y}</ServerURL>
<SRS>EPSG:3857</SRS>
<ImageFormat>png</ImageFormat>
</Service>
<DataWindow>
<UpperLeftX>-2.0036395147881314E7</UpperLeftX>
<UpperLeftY>2.003747120513706E7</UpperLeftY>
<LowerRightX>2.0036395147881314E7</LowerRightX>
<LowerRightY>-2.0037471205137067E7</LowerRightY>
<TileLevel>4</TileLevel>
<TileCountX>1</TileCountX>
<TileCountY>1</TileCountY>
<YOrigin>bottom</YOrigin>
</DataWindow>
<Projection>EPSG:3857</Projection>
<BlockSizeX>256</BlockSizeX>
<BlockSizeY>256</BlockSizeY>
<BandsCount>3</BandsCount>
</GDAL_WMS>'''
GdalTmsPyramidReader reader = new GdalTmsPyramidReader()
Pyramid pyramid = reader.read(xml)geoscript.layer.Pyramid(proj:EPSG:3857, bounds:(-2.0036395147881314E7,-2.0037471205137067E7,2.0036395147881314E7,2.003747120513706E7,EPSG:3857), origin:BOTTOM_LEFT, tileWidth:256, tileHeight:256)
Generating Tiles
Generating Image Tiles
MBTiles
Generate Image Tiles to a MBTiles file
File file = new File("target/world.mbtiles")
MBTiles mbtiles = new MBTiles(file, "World", "World Tiles")
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
countries.style = new Fill("#ffffff") + new Stroke("#b2b2b2", 0.5)
Layer ocean = workspace.get("ocean")
ocean.style = new Fill("#a5bfdd")
ImageTileRenderer renderer = new ImageTileRenderer(mbtiles, [ocean, countries])
TileGenerator generator = new TileGenerator()
generator.generate(mbtiles, renderer, 0, 2)
Generate Image Tiles to a MBTiles file with metatiles
File file = new File("target/world_meta.mbtiles")
MBTiles mbtiles = new MBTiles(file, "World", "World Tiles")
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
countries.style = new Fill("#ffffff") + new Stroke("#b2b2b2", 0.5)
Layer ocean = workspace.get("ocean")
ocean.style = new Fill("#a5bfdd")
ImageTileRenderer renderer = new ImageTileRenderer(mbtiles, [ocean, countries])
TileGenerator generator = new TileGenerator()
generator.generate(mbtiles, renderer,0, 2, metatile: [width:4, height: 4])
DBTiles
Generate Image Tiles to a MBTiles like JDBC Database.
File file = new File("target/world_tiles.db")
DBTiles dbtiles = new DBTiles("jdbc:h2:${file}","org.h2.Driver", "World", "World wide tiles")
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
countries.style = new Fill("#ffffff") + new Stroke("#b2b2b2", 0.5)
Layer ocean = workspace.get("ocean")
ocean.style = new Fill("#a5bfdd")
ImageTileRenderer renderer = new ImageTileRenderer(dbtiles, [ocean, countries])
TileGenerator generator = new TileGenerator()
generator.generate(dbtiles, renderer, 0, 2)
GeoPackage
Generate Image Tiles to a GeoPackage file
File file = new File("target/world.gpkg")
geoscript.layer.GeoPackage geopackage = new geoscript.layer.GeoPackage(file, "World", Pyramid.createGlobalGeodeticPyramid())
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
countries.style = new Fill("#ffffff") + new Stroke("#b2b2b2", 0.5)
Layer ocean = workspace.get("ocean")
ocean.style = new Fill("#a5bfdd")
ImageTileRenderer renderer = new ImageTileRenderer(geopackage, [ocean, countries])
TileGenerator generator = new TileGenerator()
generator.generate(geopackage, renderer, 0, 2)
TMS
Generate Image Tiles to a TMS directory
File directory = new File("target/tiles")
directory.mkdir()
TMS tms = new TMS("world", "png", directory, Pyramid.createGlobalMercatorPyramid())
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
countries.style = new Fill("#ffffff") + new Stroke("#b2b2b2", 0.5)
Layer ocean = workspace.get("ocean")
ocean.style = new Fill("#a5bfdd")
ImageTileRenderer renderer = new ImageTileRenderer(tms, [ocean, countries])
TileGenerator generator = new TileGenerator()
generator.generate(tms, renderer, 0, 2)
UTFGrid
Generate UTFGrid tiles to a directory
File directory = new File("target/utfgrid")
directory.mkdir()
UTFGrid utf = new UTFGrid(directory)
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
UTFGridTileRenderer renderer = new UTFGridTileRenderer(utf, countries, [countries.schema.get("NAME")])
TileGenerator generator = new TileGenerator()
generator.generate(utf, renderer, 0, 2)
Vector Tiles
Generate vector tiles to a directory
File directory = new File("target/pbf")
directory.mkdir()
Workspace workspace = new Directory("src/main/resources/shapefiles")
Layer countries = workspace.get("countries")
Layer ocean = workspace.get("ocean")
Pyramid pyramid = Pyramid.createGlobalMercatorPyramid()
pyramid.origin = Pyramid.Origin.TOP_LEFT
VectorTiles vectorTiles = new VectorTiles(
"world",
directory,
pyramid,
"pbf",
style: [
"countries": new Fill("white") + new Stroke("black", 1),
"ocean": new Fill("blue")
]
)
PbfVectorTileRenderer renderer = new PbfVectorTileRenderer([countries, ocean], [
"countries": ["NAME"],
"ocean": ["FeatureCla"]
])
TileGenerator generator = new TileGenerator()
generator.generate(vectorTiles, renderer, 0, 2)
Generate vector tiles to a MBTiles file
File file = new File("target/vectortiles.mbtiles")
Workspace workspace = new Directory("src/main/resources/shapefiles")
Layer countries = workspace.get("countries")
Layer ocean = workspace.get("ocean")
Pyramid pyramid = Pyramid.createGlobalMercatorPyramid()
pyramid.origin = Pyramid.Origin.TOP_LEFT
VectorTiles vectorTiles = new VectorTiles(
"world",
file,
pyramid,
"pbf",
style: [
"countries": new Fill("white") + new Stroke("black", 1),
"ocean": new Fill("blue")
]
)
PbfVectorTileRenderer renderer = new PbfVectorTileRenderer([countries, ocean], [
"countries": ["NAME"],
"ocean": ["FeatureCla"]
])
TileGenerator generator = new TileGenerator()
generator.generate(vectorTiles, renderer, 0, 2)Tile Layer
Tile Layer Properties
Create a TileLayer from an MBTiles File.
File file = new File("src/main/resources/tiles.mbtiles")
MBTiles mbtiles = new MBTiles(file)Get the TileLayer’s name.
String name = mbtiles.name
println namecountries
Get the TileLayer’s Bounds.
Bounds bounds = mbtiles.bounds
println bounds(-2.0036395147881314E7,-2.0037471205137067E7,2.0036395147881314E7,2.003747120513706E7,EPSG:3857)
Get the TileLayer’s Projection.
Projection proj = mbtiles.proj
println projEPSG:3857
Get the TileLayer’s Pyramid.
Pyramid pyramid = mbtiles.pyramid
println pyramidgeoscript.layer.Pyramid(proj:EPSG:3857, bounds:(-2.0036395147881314E7,-2.0037471205137067E7,2.0036395147881314E7,2.003747120513706E7,EPSG:3857), origin:BOTTOM_LEFT, tileWidth:256, tileHeight:256)
Get a Tile from a TileLayer.
Tile tile = mbtiles.get(0, 0, 0)
println tileTile(x:0, y:0, z:0)
Get, put, and delete a Tile from a TileLayer
Get a Tile from a TileLayer.
MBTiles layer = new MBTiles(file)
ImageTile tile = layer.get(0,0,0)
Add a Tile to a TileLayer.
File newTileFile = new File("src/main/resources/yellowtile.png")
ImageTile newTile = new ImageTile(0,0,0, newTileFile.bytes)
layer.put(newTile)
newTile = layer.get(0,0,0)
Remove a Tile from a TileLayer.
layer.delete(newTile)
newTile = layer.get(0,0,0)
println "Image = ${newTile.image}"Image = null
Close a TileLayer
layer.close()Delete Tiles from a TileLayer
MBTiles layer = new MBTiles(file)
layer.tiles(1).each { Tile tile ->
println "${tile} = ${tile.image == null}"
}Tile(x:0, y:0, z:1) = false Tile(x:1, y:0, z:1) = false Tile(x:0, y:1, z:1) = false Tile(x:1, y:1, z:1) = false
layer.delete(layer.tiles(1))
layer.tiles(1).each { Tile tile ->
println "${tile} = ${tile.image == null}"
}Tile(x:0, y:0, z:1) = true Tile(x:1, y:0, z:1) = true Tile(x:0, y:1, z:1) = true Tile(x:1, y:1, z:1) = true
Tiles
Get a TileCursor from a TileLayer with all of the Tiles in a zoom level.
File file = new File("src/main/resources/tiles.mbtiles")
MBTiles mbtiles = new MBTiles(file)
long zoomLevel = 1
TileCursor tileCursor = mbtiles.tiles(zoomLevel)
println "Zoom Level: ${tileCursor.z}"
println "# of tiles: ${tileCursor.size}"
println "Bounds: ${tileCursor.bounds}"
println "Width / # Columns: ${tileCursor.width}"
println "Height / # Rows: ${tileCursor.height}"
println "MinX: ${tileCursor.minX}, MinY: ${tileCursor.minY}, MaxX: ${tileCursor.maxX}, MaxY: ${tileCursor.maxY}"
println "Tiles:"
tileCursor.each { Tile t ->
println t
}Zoom Level: 1 # of tiles: 4 Bounds: (-2.0036395147881314E7,-2.0037471205137067E7,2.0036395147881314E7,2.003747120513706E7,EPSG:3857) Width / # Columns: 2 Height / # Rows: 2 MinX: 0, MinY: 0, MaxX: 1, MaxY: 1 Tiles: Tile(x:0, y:0, z:1) Tile(x:1, y:0, z:1) Tile(x:0, y:1, z:1) Tile(x:1, y:1, z:1)
Get a TileCursor from a TileLayer with Tiles from a zoom level between min and max x and y coordinates.
File file = new File("src/main/resources/tiles.mbtiles")
MBTiles mbtiles = new MBTiles(file)
long zoomLevel = 4
long minX = 2
long minY = 4
long maxX = 5
long maxY = 8
TileCursor tileCursor = mbtiles.tiles(zoomLevel, minX, minY, maxX, maxY)
println "Zoom Level: ${tileCursor.z}"
println "# of tiles: ${tileCursor.size}"
println "Bounds: ${tileCursor.bounds}"
println "Width / # Columns: ${tileCursor.width}"
println "Height / # Rows: ${tileCursor.height}"
println "MinX: ${tileCursor.minX}, MinY: ${tileCursor.minY}, MaxX: ${tileCursor.maxX}, MaxY: ${tileCursor.maxY}"
println "Tiles:"
tileCursor.each { Tile t ->
println t
}Zoom Level: 4 # of tiles: 20 Bounds: (-1.5027296360910986E7,-1.0018735602568535E7,-5009098.786970329,2504683.900642129,EPSG:3857) Width / # Columns: 4 Height / # Rows: 5 MinX: 2, MinY: 4, MaxX: 5, MaxY: 8 Tiles: Tile(x:2, y:4, z:4) Tile(x:3, y:4, z:4) Tile(x:4, y:4, z:4) Tile(x:5, y:4, z:4) Tile(x:2, y:5, z:4) Tile(x:3, y:5, z:4) Tile(x:4, y:5, z:4) Tile(x:5, y:5, z:4) Tile(x:2, y:6, z:4) Tile(x:3, y:6, z:4) Tile(x:4, y:6, z:4) Tile(x:5, y:6, z:4) Tile(x:2, y:7, z:4) Tile(x:3, y:7, z:4) Tile(x:4, y:7, z:4) Tile(x:5, y:7, z:4) Tile(x:2, y:8, z:4) Tile(x:3, y:8, z:4) Tile(x:4, y:8, z:4) Tile(x:5, y:8, z:4)
Get a TileCursor from a TileLayer for a zoom level and a given Bounds.
File file = new File("src/main/resources/tiles.mbtiles")
MBTiles mbtiles = new MBTiles(file)
Bounds bounds = new Bounds(-102.875977, 45.433154, -96.481934, 48.118434, "EPSG:4326").reproject("EPSG:3857")
int zoomLevel = 8
TileCursor tileCursor = mbtiles.tiles(bounds, zoomLevel)
println "Zoom Level: ${tileCursor.z}"
println "# of tiles: ${tileCursor.size}"
println "Bounds: ${tileCursor.bounds}"
println "Width / # Columns: ${tileCursor.width}"
println "Height / # Rows: ${tileCursor.height}"
println "MinX: ${tileCursor.minX}, MinY: ${tileCursor.minY}, MaxX: ${tileCursor.maxX}, MaxY: ${tileCursor.maxY}"
println "Tiles:"
tileCursor.each { Tile t ->
println t
}Zoom Level: 8 # of tiles: 24 Bounds: (-1.1583540944868885E7,5635538.7764447965,-1.0644334922311949E7,6261709.751605326,EPSG:3857) Width / # Columns: 6 Height / # Rows: 4 MinX: 54, MinY: 164, MaxX: 59, MaxY: 167 Tiles: Tile(x:54, y:164, z:8) Tile(x:55, y:164, z:8) Tile(x:56, y:164, z:8) Tile(x:57, y:164, z:8) Tile(x:58, y:164, z:8) Tile(x:59, y:164, z:8) Tile(x:54, y:165, z:8) Tile(x:55, y:165, z:8) Tile(x:56, y:165, z:8) Tile(x:57, y:165, z:8) Tile(x:58, y:165, z:8) Tile(x:59, y:165, z:8) Tile(x:54, y:166, z:8) Tile(x:55, y:166, z:8) Tile(x:56, y:166, z:8) Tile(x:57, y:166, z:8) Tile(x:58, y:166, z:8) Tile(x:59, y:166, z:8) Tile(x:54, y:167, z:8) Tile(x:55, y:167, z:8) Tile(x:56, y:167, z:8) Tile(x:57, y:167, z:8) Tile(x:58, y:167, z:8) Tile(x:59, y:167, z:8)
Get a TileCursor from a TileLayer for a zoom level and given x and y resolutions.
File file = new File("src/main/resources/tiles.mbtiles")
MBTiles mbtiles = new MBTiles(file)
Bounds bounds = new Bounds(-124.73142200000001, 24.955967, -66.969849, 49.371735, "EPSG:4326").reproject("EPSG:3857")
double resolutionX = bounds.width / 400
double resolutionY = bounds.height / 300
TileCursor tileCursor = mbtiles.tiles(bounds, resolutionX, resolutionY)
println "Zoom Level: ${tileCursor.z}"
println "# of tiles: ${tileCursor.size}"
println "Bounds: ${tileCursor.bounds}"
println "Width / # Columns: ${tileCursor.width}"
println "Height / # Rows: ${tileCursor.height}"
println "MinX: ${tileCursor.minX}, MinY: ${tileCursor.minY}, MaxX: ${tileCursor.maxX}, MaxY: ${tileCursor.maxY}"
println "Tiles:"
tileCursor.each { Tile t ->
println t
}Zoom Level: 4 # of tiles: 8 Bounds: (-1.5027296360910986E7,2504683.9006421305,-5009098.786970329,7514051.701926393,EPSG:3857) Width / # Columns: 4 Height / # Rows: 2 MinX: 2, MinY: 9, MaxX: 5, MaxY: 10 Tiles: Tile(x:2, y:9, z:4) Tile(x:3, y:9, z:4) Tile(x:4, y:9, z:4) Tile(x:5, y:9, z:4) Tile(x:2, y:10, z:4) Tile(x:3, y:10, z:4) Tile(x:4, y:10, z:4) Tile(x:5, y:10, z:4)
Get a TileCursor from a TileLayer for a Bounds and a given canvas width and height.
File file = new File("src/main/resources/tiles.mbtiles")
MBTiles mbtiles = new MBTiles(file)
Bounds bounds = new Bounds(-102.875977, 45.433154, -96.481934, 48.118434, "EPSG:4326").reproject("EPSG:3857")
int width = 400
int height = 400
TileCursor tileCursor = mbtiles.tiles(bounds, width, height)
println "Zoom Level: ${tileCursor.z}"
println "# of tiles: ${tileCursor.size}"
println "Bounds: ${tileCursor.bounds}"
println "Width / # Columns: ${tileCursor.width}"
println "Height / # Rows: ${tileCursor.height}"
println "MinX: ${tileCursor.minX}, MinY: ${tileCursor.minY}, MaxX: ${tileCursor.maxX}, MaxY: ${tileCursor.maxY}"
println "Tiles:"
tileCursor.each { Tile t ->
println t
}Zoom Level: 7 # of tiles: 6 Bounds: (-1.1583540944868885E7,5635538.7764447965,-1.0644334922311949E7,6261709.751605329,EPSG:3857) Width / # Columns: 3 Height / # Rows: 2 MinX: 27, MinY: 82, MaxX: 29, MaxY: 83 Tiles: Tile(x:27, y:82, z:7) Tile(x:28, y:82, z:7) Tile(x:29, y:82, z:7) Tile(x:27, y:83, z:7) Tile(x:28, y:83, z:7) Tile(x:29, y:83, z:7)
Get a TileCursor from a TileLayer around a Point at a given zoom level for a given canvas width and height.
File file = new File("src/main/resources/tiles.mbtiles")
MBTiles mbtiles = new MBTiles(file)
Point point = Projection.transform(new Point(-102.875977, 45.433154), "EPSG:4326", "EPSG:3857")
int zoomLevel = 12
int width = 400
int height = 400
TileCursor tileCursor = mbtiles.tiles(point, zoomLevel, width, height)
println "Zoom Level: ${tileCursor.z}"
println "# of tiles: ${tileCursor.size}"
println "Bounds: ${tileCursor.bounds}"
println "Width / # Columns: ${tileCursor.width}"
println "Height / # Rows: ${tileCursor.height}"
println "MinX: ${tileCursor.minX}, MinY: ${tileCursor.minY}, MaxX: ${tileCursor.maxX}, MaxY: ${tileCursor.maxY}"
println "Tiles:"
tileCursor.each { Tile t ->
println t
}Zoom Level: 12 # of tiles: 9 Bounds: (-1.1466140192049267E7,5674674.46239233,-1.1436790003844364E7,5704026.226852979,EPSG:3857) Width / # Columns: 3 Height / # Rows: 3 MinX: 876, MinY: 2628, MaxX: 878, MaxY: 2630 Tiles: Tile(x:876, y:2628, z:12) Tile(x:877, y:2628, z:12) Tile(x:878, y:2628, z:12) Tile(x:876, y:2629, z:12) Tile(x:877, y:2629, z:12) Tile(x:878, y:2629, z:12) Tile(x:876, y:2630, z:12) Tile(x:877, y:2630, z:12) Tile(x:878, y:2630, z:12)
Get the tile coordinates from a TileLayer by Bounds and Grid
File file = new File("src/main/resources/tiles.mbtiles")
MBTiles mbtiles = new MBTiles(file)
Bounds bounds = new Bounds(20.798492,36.402494,22.765045,37.223768, "EPSG:4326").reproject("EPSG:3857")
Grid grid = mbtiles.pyramid.grid(10)
Map<String, Integer> coords = mbtiles.getTileCoordinates(bounds, grid)
println "Min X = ${coords.minX}"
println "Min Y = ${coords.minY}"
println "Max X = ${coords.maxX}"
println "Max Y = ${coords.maxY}"Min X = 571 Min Y = 623 Max X = 576 Max Y = 626
Get a Layer from a TileLayer representing the outline of the Tiles in the TileCursor.
File file = new File("src/main/resources/tiles.mbtiles")
MBTiles mbtiles = new MBTiles(file)
Layer layer = mbtiles.getLayer(mbtiles.tiles(1))
| id | z | x | y |
|---|---|---|---|
0 |
1 |
0 |
0 |
1 |
1 |
1 |
0 |
2 |
1 |
0 |
1 |
3 |
1 |
1 |
1 |
Using Tile Layers
Get a TileLayer and make sure it is closed when done.
File file = new File("src/main/resources/tiles.mbtiles")
TileLayer.withTileLayer(new MBTiles(file)) { TileLayer tileLayer ->
println tileLayer.name
println tileLayer.proj
println tileLayer.bounds
}countries EPSG:3857 (-2.0036395147881314E7,-2.0037471205137067E7,2.0036395147881314E7,2.003747120513706E7,EPSG:3857)
Get Tile Layer from a Map
Get an MBTiles TileLayer from a Map
TileLayer mbtiles = TileLayer.getTileLayer([type:'mbtiles', file: 'src/main/resources/tiles.mbtiles'])
println "${mbtiles.name} ${mbtiles.proj} ${mbtiles.bounds} ${mbtiles.pyramid}"countries EPSG:3857 (-2.0036395147881314E7,-2.0037471205137067E7,2.0036395147881314E7,2.003747120513706E7,EPSG:3857) geoscript.layer.Pyramid(proj:EPSG:3857, bounds:(-2.0036395147881314E7,-2.0037471205137067E7,2.0036395147881314E7,2.003747120513706E7,EPSG:3857), origin:BOTTOM_LEFT, tileWidth:256, tileHeight:256)
Get an GeoPackage TileLayer from a Map
TileLayer geopackage = TileLayer.getTileLayer([type: 'geopackage', name: 'world', file: 'src/main/resources/tiles.gpkg'])
println "${geopackage.name} ${geopackage.proj} ${geopackage.bounds} ${geopackage.pyramid}"world EPSG:4326 (-179.99,-89.99,179.99,89.99,EPSG:4326) geoscript.layer.Pyramid(proj:EPSG:4326, bounds:(-179.99,-89.99,179.99,89.99,EPSG:4326), origin:TOP_LEFT, tileWidth:256, tileHeight:256)
Get an TMS TileLayer from a Map
TileLayer tms = TileLayer.getTileLayer([type: 'tms', file: 'src/main/resources/tms', format: 'png', pyramid: 'globalmercator'])
println "${tms.name} ${tms.proj} ${tms.bounds} ${tms.pyramid}"tms EPSG:3857 (-2.0036395147881314E7,-2.0037471205137067E7,2.0036395147881314E7,2.003747120513706E7,EPSG:3857) geoscript.layer.Pyramid(proj:EPSG:3857, bounds:(-2.0036395147881314E7,-2.0037471205137067E7,2.0036395147881314E7,2.003747120513706E7,EPSG:3857), origin:BOTTOM_LEFT, tileWidth:256, tileHeight:256)
Get an OSM TileLayer from a Map
TileLayer osm = TileLayer.getTileLayer([type: 'osm', url: 'http://a.tile.openstreetmap.org'])
println "${osm.name} ${osm.proj} ${osm.bounds} ${osm.pyramid}"OSM EPSG:3857 (-2.0036395147881314E7,-2.0037471205137067E7,2.0036395147881314E7,2.003747120513706E7,EPSG:3857) geoscript.layer.Pyramid(proj:EPSG:3857, bounds:(-2.0036395147881314E7,-2.0037471205137067E7,2.0036395147881314E7,2.003747120513706E7,EPSG:3857), origin:TOP_LEFT, tileWidth:256, tileHeight:256)
Get an PBF Vector TileLayer from a Map
TileLayer pbf = TileLayer.getTileLayer([type: 'vectortiles', name: 'world', file: 'src/main/resources/pbf', format: 'pbf', pyramid: 'GlobalMercator'])
println "${pbf.name} ${pbf.proj} ${pbf.bounds} ${pbf.pyramid}"world EPSG:3857 (-2.0036395147881314E7,-2.0037471205137067E7,2.0036395147881314E7,2.003747120513706E7,EPSG:3857) geoscript.layer.Pyramid(proj:EPSG:3857, bounds:(-2.0036395147881314E7,-2.0037471205137067E7,2.0036395147881314E7,2.003747120513706E7,EPSG:3857), origin:BOTTOM_LEFT, tileWidth:256, tileHeight:256)
Get an UTF TileLayer from a Map
TileLayer utf = TileLayer.getTileLayer([type: 'utfgrid', file: 'src/main/resources/utf'])
println "${utf.name} ${utf.proj} ${utf.bounds} ${utf.pyramid}"utf EPSG:3857 (-2.0036395147881314E7,-2.0037471205137067E7,2.0036395147881314E7,2.003747120513706E7,EPSG:3857) geoscript.layer.Pyramid(proj:EPSG:3857, bounds:(-2.0036395147881314E7,-2.0037471205137067E7,2.0036395147881314E7,2.003747120513706E7,EPSG:3857), origin:TOP_LEFT, tileWidth:256, tileHeight:256)
Get Tile Layer from a String
Get an MBTiles TileLayer from a String
TileLayer mbtiles = TileLayer.getTileLayer("type=mbtiles file=src/main/resources/tiles.mbtiles")
println "${mbtiles.name} ${mbtiles.proj} ${mbtiles.bounds} ${mbtiles.pyramid}"countries EPSG:3857 (-2.0036395147881314E7,-2.0037471205137067E7,2.0036395147881314E7,2.003747120513706E7,EPSG:3857) geoscript.layer.Pyramid(proj:EPSG:3857, bounds:(-2.0036395147881314E7,-2.0037471205137067E7,2.0036395147881314E7,2.003747120513706E7,EPSG:3857), origin:BOTTOM_LEFT, tileWidth:256, tileHeight:256)
Get an GeoPackage TileLayer from a String
TileLayer geopackage = TileLayer.getTileLayer("type=geopackage name=world file=src/main/resources/tiles.gpkg")
println "${geopackage.name} ${geopackage.proj} ${geopackage.bounds} ${geopackage.pyramid}"world EPSG:4326 (-179.99,-89.99,179.99,89.99,EPSG:4326) geoscript.layer.Pyramid(proj:EPSG:4326, bounds:(-179.99,-89.99,179.99,89.99,EPSG:4326), origin:TOP_LEFT, tileWidth:256, tileHeight:256)
Get an TMS TileLayer from a String
TileLayer tms = TileLayer.getTileLayer("type=tms file=src/main/resources/tms format=png pyramid=globalmercator")
println "${tms.name} ${tms.proj} ${tms.bounds} ${tms.pyramid}"tms EPSG:3857 (-2.0036395147881314E7,-2.0037471205137067E7,2.0036395147881314E7,2.003747120513706E7,EPSG:3857) geoscript.layer.Pyramid(proj:EPSG:3857, bounds:(-2.0036395147881314E7,-2.0037471205137067E7,2.0036395147881314E7,2.003747120513706E7,EPSG:3857), origin:BOTTOM_LEFT, tileWidth:256, tileHeight:256)
Get an OSM TileLayer from a String
TileLayer osm = TileLayer.getTileLayer("type=osm url=http://a.tile.openstreetmap.org")
println "${osm.name} ${osm.proj} ${osm.bounds} ${osm.pyramid}"OSM EPSG:3857 (-2.0036395147881314E7,-2.0037471205137067E7,2.0036395147881314E7,2.003747120513706E7,EPSG:3857) geoscript.layer.Pyramid(proj:EPSG:3857, bounds:(-2.0036395147881314E7,-2.0037471205137067E7,2.0036395147881314E7,2.003747120513706E7,EPSG:3857), origin:TOP_LEFT, tileWidth:256, tileHeight:256)
Get an PBF Vector TileLayer from a String
TileLayer pbf = TileLayer.getTileLayer("type=vectortiles name=world file=src/main/resources/pbf format=pbf pyramid=GlobalMercator")
println "${pbf.name} ${pbf.proj} ${pbf.bounds} ${pbf.pyramid}"world EPSG:3857 (-2.0036395147881314E7,-2.0037471205137067E7,2.0036395147881314E7,2.003747120513706E7,EPSG:3857) geoscript.layer.Pyramid(proj:EPSG:3857, bounds:(-2.0036395147881314E7,-2.0037471205137067E7,2.0036395147881314E7,2.003747120513706E7,EPSG:3857), origin:BOTTOM_LEFT, tileWidth:256, tileHeight:256)
Get an UTF TileLayer from a String
TileLayer utf = TileLayer.getTileLayer("type=utfgrid file=src/main/resources/utf")
println "${utf.name} ${utf.proj} ${utf.bounds} ${utf.pyramid}"utf EPSG:3857 (-2.0036395147881314E7,-2.0037471205137067E7,2.0036395147881314E7,2.003747120513706E7,EPSG:3857) geoscript.layer.Pyramid(proj:EPSG:3857, bounds:(-2.0036395147881314E7,-2.0037471205137067E7,2.0036395147881314E7,2.003747120513706E7,EPSG:3857), origin:TOP_LEFT, tileWidth:256, tileHeight:256)
TileRenderer
TileRenderers know how to create a Tile for a given Bounds. GeoScript has TileRenderer for creating images, vector tiles, and utfgrids.
Get default TileRenderer
Get a default TileRenderer for a TileLayer
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
countries.style = new Fill("#ffffff") + new Stroke("#b2b2b2", 0.5)
Layer ocean = workspace.get("ocean")
ocean.style = new Fill("#a5bfdd")
TileLayer tileLayer = TileLayer.getTileLayer([type:'mbtiles', file: 'target/countries.mbtiles'])
TileRenderer tileRenderer = TileLayer.getTileRenderer(tileLayer, [ocean, countries])
Pyramid pyramid = tileLayer.pyramid
Tile tile = tileLayer.get(0,0,0)
Bounds bounds = pyramid.bounds(tile)
tile.data = tileRenderer.render(bounds)
tileLayer.put(tile)
ImageTileRenderer
Use an ImageTileRenderer to create an image Tile.
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
countries.style = new Fill("#ffffff") + new Stroke("#b2b2b2", 0.5)
Layer ocean = workspace.get("ocean")
ocean.style = new Fill("#a5bfdd")
TileLayer tileLayer = TileLayer.getTileLayer([type:'mbtiles', file: 'target/countries.mbtiles'])
ImageTileRenderer tileRenderer = new ImageTileRenderer(tileLayer, [ocean, countries])
Pyramid pyramid = tileLayer.pyramid
Tile tile = tileLayer.get(0,0,0)
Bounds bounds = pyramid.bounds(tile)
tile.data = tileRenderer.render(bounds)
tileLayer.put(tile)
VectorTileRenderer
Use an VectorTileRenderer to create a Vector Tile.
Workspace workspace = new Directory("src/main/resources/shapefiles")
Layer countries = workspace.get("countries")
File directory = new File("target/country_geojson_tiles")
directory.mkdir()
Pyramid pyramid = Pyramid.createGlobalMercatorPyramid()
VectorTiles tileLayer = new VectorTiles(
"countries",
directory,
pyramid,
"geojson"
)
GeoJSONWriter writer = new GeoJSONWriter()
VectorTileRenderer tileRenderer = new VectorTileRenderer(writer, countries, [countries.schema.get("NAME")])
Tile tile = tileLayer.get(0,0,0)
Bounds bounds = pyramid.bounds(tile)
tile.data = tileRenderer.render(bounds)
tileLayer.put(tile){"type":"FeatureCollection","features":[{"type":"Feature","geometry":{"type":"MultiPolygon","coordinates":[[[[180,-16.0671],[180,-16.5552],[179.3641,-16.8014],[178.7251,-17.012],[178.5968,-16.6392],[179.0966,-16.434],[179.4135,-16.3791],[180,-16.0671]]],[[[178.1256,-17.5048],[178.3736,-17.3399],[178.7181,-17.6285],[178.5527,-18.1506],[177.9327,-18.288],[177.3815,-18.1643],[177.285,-17.7246],[177.6709,-17.3811],[178.1256,-17.5048]]],[[[-179.7933,-16.0209],[-179.9174,-16.5018],[-180,-16.5552],[-180,-16.0671],[-179.7933,-16.0209]]]]},"properties":{"NAME":"Fiji"},"id":"fid-34d9214a_16d54d1675c_-3456"},{"type":"Feature","geometry":{"type":"MultiPolygon","coordinates":[[[[33.9037,-0.95],[34.0726,-1.0598],[37.6987,-3.097],[37.7669,-3.6771],[39.2022,-4.6768],[38.7405,-5.9089],[38.7998,-6.4757],[39.44,-6.84],[39.47,-7.1],[39.1947,-7.7039],[39.252,-8.0078],[39.1865,-8.4855],[39.5357,-9.1124],[39.9
PbfVectorTileRenderer
Use an PbfVectorTileRenderer to create a Vector Tile.
Workspace workspace = new Directory("src/main/resources/shapefiles")
Layer countries = workspace.get("countries")
File directory = new File("target/country_pbf_tiles")
directory.mkdir()
Pyramid pyramid = Pyramid.createGlobalMercatorPyramid()
pyramid.origin = Pyramid.Origin.TOP_LEFT
VectorTiles tileLayer = new VectorTiles(
"countries",
directory,
pyramid,
"pbf"
)
PbfVectorTileRenderer tileRenderer = new PbfVectorTileRenderer(countries, [countries.schema.get("NAME")])
Tile tile = tileLayer.get(0,0,0)
Bounds bounds = pyramid.bounds(tile)
tile.data = tileRenderer.render(bounds)
tileLayer.put(tile)UTFGridTileRenderer
Use an UTFGridTileRenderer to create a UTFGrid Tile.
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
File directory = new File("target/countryUtfGrid")
directory.mkdir()
UTFGrid tileLayer = new UTFGrid(directory)
UTFGridTileRenderer tileRenderer = new UTFGridTileRenderer(tileLayer, countries, [countries.schema.get("NAME")])
Pyramid pyramid = tileLayer.pyramid
Tile tile = tileLayer.get(0,0,0)
Bounds bounds = pyramid.bounds(tile)
tile.data = tileRenderer.render(bounds)
tileLayer.put(tile){
"grid": [
" ",
" ",
" ",
" ! ### ",
" !!!!! ##### ",
" !!!!!######### ",
" !!!!!!######### $ ",
" !!!!!######### %%% $ ",
" ! !!! ######### %% $$ ",
" ! !! !!########## %% $ ",
" ! !!!!! ######### % $ $$ ",
" !!!!!!! #######
TileCursor
A TileCursor is a way to get a collection of Tiles from a TileLayer.
Get a TileCursor with all of the Tiles from a TileLayer in a zoom level.
File file = new File("src/main/resources/tiles.mbtiles")
MBTiles mbtiles = new MBTiles(file)
long zoomLevel = 1
TileCursor tileCursor = new TileCursor(mbtiles, zoomLevel)
println "Zoom Level: ${tileCursor.z}"
println "# of tiles: ${tileCursor.size}"
println "Bounds: ${tileCursor.bounds}"
println "Width / # Columns: ${tileCursor.width}"
println "Height / # Rows: ${tileCursor.height}"
println "MinX: ${tileCursor.minX}, MinY: ${tileCursor.minY}, MaxX: ${tileCursor.maxX}, MaxY: ${tileCursor.maxY}"
println "Tiles:"
tileCursor.each { Tile t ->
println t
}Zoom Level: 1 # of tiles: 4 Bounds: (-2.0036395147881314E7,-2.0037471205137067E7,2.0036395147881314E7,2.003747120513706E7,EPSG:3857) Width / # Columns: 2 Height / # Rows: 2 MinX: 0, MinY: 0, MaxX: 1, MaxY: 1 Tiles: Tile(x:0, y:0, z:1) Tile(x:1, y:0, z:1) Tile(x:0, y:1, z:1) Tile(x:1, y:1, z:1)
Get a TileCursor with Tiles from a TileLayer in a zoom level between min and max x and y coordinates.
File file = new File("src/main/resources/tiles.mbtiles")
MBTiles mbtiles = new MBTiles(file)
long zoomLevel = 4
long minX = 2
long minY = 4
long maxX = 5
long maxY = 8
TileCursor tileCursor = new TileCursor(mbtiles, zoomLevel, minX, minY, maxX, maxY)
println "Zoom Level: ${tileCursor.z}"
println "# of tiles: ${tileCursor.size}"
println "Bounds: ${tileCursor.bounds}"
println "Width / # Columns: ${tileCursor.width}"
println "Height / # Rows: ${tileCursor.height}"
println "MinX: ${tileCursor.minX}, MinY: ${tileCursor.minY}, MaxX: ${tileCursor.maxX}, MaxY: ${tileCursor.maxY}"
println "Tiles:"
tileCursor.each { Tile t ->
println t
}Zoom Level: 4 # of tiles: 20 Bounds: (-1.5027296360910986E7,-1.0018735602568535E7,-5009098.786970329,2504683.900642129,EPSG:3857) Width / # Columns: 4 Height / # Rows: 5 MinX: 2, MinY: 4, MaxX: 5, MaxY: 8 Tiles: Tile(x:2, y:4, z:4) Tile(x:3, y:4, z:4) Tile(x:4, y:4, z:4) Tile(x:5, y:4, z:4) Tile(x:2, y:5, z:4) Tile(x:3, y:5, z:4) Tile(x:4, y:5, z:4) Tile(x:5, y:5, z:4) Tile(x:2, y:6, z:4) Tile(x:3, y:6, z:4) Tile(x:4, y:6, z:4) Tile(x:5, y:6, z:4) Tile(x:2, y:7, z:4) Tile(x:3, y:7, z:4) Tile(x:4, y:7, z:4) Tile(x:5, y:7, z:4) Tile(x:2, y:8, z:4) Tile(x:3, y:8, z:4) Tile(x:4, y:8, z:4) Tile(x:5, y:8, z:4)
Get a TileCursor with Tiles from a TileLayer in a zoom level for a given Bounds.
File file = new File("src/main/resources/tiles.mbtiles")
MBTiles mbtiles = new MBTiles(file)
Bounds bounds = new Bounds(-102.875977, 45.433154, -96.481934, 48.118434, "EPSG:4326").reproject("EPSG:3857")
int zoomLevel = 8
TileCursor tileCursor = new TileCursor(mbtiles, bounds, zoomLevel)
println "Zoom Level: ${tileCursor.z}"
println "# of tiles: ${tileCursor.size}"
println "Bounds: ${tileCursor.bounds}"
println "Width / # Columns: ${tileCursor.width}"
println "Height / # Rows: ${tileCursor.height}"
println "MinX: ${tileCursor.minX}, MinY: ${tileCursor.minY}, MaxX: ${tileCursor.maxX}, MaxY: ${tileCursor.maxY}"
println "Tiles:"
tileCursor.each { Tile t ->
println t
}Zoom Level: 8 # of tiles: 24 Bounds: (-1.1583540944868885E7,5635538.7764447965,-1.0644334922311949E7,6261709.751605326,EPSG:3857) Width / # Columns: 6 Height / # Rows: 4 MinX: 54, MinY: 164, MaxX: 59, MaxY: 167 Tiles: Tile(x:54, y:164, z:8) Tile(x:55, y:164, z:8) Tile(x:56, y:164, z:8) Tile(x:57, y:164, z:8) Tile(x:58, y:164, z:8) Tile(x:59, y:164, z:8) Tile(x:54, y:165, z:8) Tile(x:55, y:165, z:8) Tile(x:56, y:165, z:8) Tile(x:57, y:165, z:8) Tile(x:58, y:165, z:8) Tile(x:59, y:165, z:8) Tile(x:54, y:166, z:8) Tile(x:55, y:166, z:8) Tile(x:56, y:166, z:8) Tile(x:57, y:166, z:8) Tile(x:58, y:166, z:8) Tile(x:59, y:166, z:8) Tile(x:54, y:167, z:8) Tile(x:55, y:167, z:8) Tile(x:56, y:167, z:8) Tile(x:57, y:167, z:8) Tile(x:58, y:167, z:8) Tile(x:59, y:167, z:8)
Get a TileCursor with Tiles from a TileLayer in a zoom level for a given x and y resolution.
File file = new File("src/main/resources/tiles.mbtiles")
MBTiles mbtiles = new MBTiles(file)
Bounds bounds = new Bounds(-124.73142200000001, 24.955967, -66.969849, 49.371735, "EPSG:4326").reproject("EPSG:3857")
double resolutionX = bounds.width / 400
double resolutionY = bounds.height / 300
TileCursor tileCursor = new TileCursor(mbtiles, bounds, resolutionX, resolutionY)
println "Zoom Level: ${tileCursor.z}"
println "# of tiles: ${tileCursor.size}"
println "Bounds: ${tileCursor.bounds}"
println "Width / # Columns: ${tileCursor.width}"
println "Height / # Rows: ${tileCursor.height}"
println "MinX: ${tileCursor.minX}, MinY: ${tileCursor.minY}, MaxX: ${tileCursor.maxX}, MaxY: ${tileCursor.maxY}"
println "Tiles:"
tileCursor.each { Tile t ->
println t
}Zoom Level: 4 # of tiles: 8 Bounds: (-1.5027296360910986E7,2504683.9006421305,-5009098.786970329,7514051.701926393,EPSG:3857) Width / # Columns: 4 Height / # Rows: 2 MinX: 2, MinY: 9, MaxX: 5, MaxY: 10 Tiles: Tile(x:2, y:9, z:4) Tile(x:3, y:9, z:4) Tile(x:4, y:9, z:4) Tile(x:5, y:9, z:4) Tile(x:2, y:10, z:4) Tile(x:3, y:10, z:4) Tile(x:4, y:10, z:4) Tile(x:5, y:10, z:4)
Get a TileCursor with Tiles from a TileLayer within a Bounds for a given canvas width and height.
File file = new File("src/main/resources/tiles.mbtiles")
MBTiles mbtiles = new MBTiles(file)
Bounds bounds = new Bounds(-102.875977, 45.433154, -96.481934, 48.118434, "EPSG:4326").reproject("EPSG:3857")
int width = 400
int height = 400
TileCursor tileCursor = new TileCursor(mbtiles, bounds, width, height)
println "Zoom Level: ${tileCursor.z}"
println "# of tiles: ${tileCursor.size}"
println "Bounds: ${tileCursor.bounds}"
println "Width / # Columns: ${tileCursor.width}"
println "Height / # Rows: ${tileCursor.height}"
println "MinX: ${tileCursor.minX}, MinY: ${tileCursor.minY}, MaxX: ${tileCursor.maxX}, MaxY: ${tileCursor.maxY}"
println "Tiles:"
tileCursor.each { Tile t ->
println t
}Zoom Level: 7 # of tiles: 6 Bounds: (-1.1583540944868885E7,5635538.7764447965,-1.0644334922311949E7,6261709.751605329,EPSG:3857) Width / # Columns: 3 Height / # Rows: 2 MinX: 27, MinY: 82, MaxX: 29, MaxY: 83 Tiles: Tile(x:27, y:82, z:7) Tile(x:28, y:82, z:7) Tile(x:29, y:82, z:7) Tile(x:27, y:83, z:7) Tile(x:28, y:83, z:7) Tile(x:29, y:83, z:7)
Get a TileCursor with Tiles from a TileLayer around a Point at a given zoom level for a given canvas width and height.
File file = new File("src/main/resources/tiles.mbtiles")
MBTiles mbtiles = new MBTiles(file)
Bounds bounds = new Bounds(-102.875977, 45.433154, -96.481934, 48.118434, "EPSG:4326").reproject("EPSG:3857")
int width = 400
int height = 400
TileCursor tileCursor = new TileCursor(mbtiles, bounds, width, height)
println "Zoom Level: ${tileCursor.z}"
println "# of tiles: ${tileCursor.size}"
println "Bounds: ${tileCursor.bounds}"
println "Width / # Columns: ${tileCursor.width}"
println "Height / # Rows: ${tileCursor.height}"
println "MinX: ${tileCursor.minX}, MinY: ${tileCursor.minY}, MaxX: ${tileCursor.maxX}, MaxY: ${tileCursor.maxY}"
println "Tiles:"
tileCursor.each { Tile t ->
println t
}Zoom Level: 7 # of tiles: 6 Bounds: (-1.1583540944868885E7,5635538.7764447965,-1.0644334922311949E7,6261709.751605329,EPSG:3857) Width / # Columns: 3 Height / # Rows: 2 MinX: 27, MinY: 82, MaxX: 29, MaxY: 83 Tiles: Tile(x:27, y:82, z:7) Tile(x:28, y:82, z:7) Tile(x:29, y:82, z:7) Tile(x:27, y:83, z:7) Tile(x:28, y:83, z:7) Tile(x:29, y:83, z:7)
TMS
Access a TileLayer from an TMS directory
File dir = new File("src/main/resources/tms")
Pyramid pyramid = Pyramid.createGlobalMercatorPyramid()
TMS tms = new TMS(
"world", (1)
"png", (2)
dir, (3)
pyramid (4)
)| 1 | Name |
| 2 | Image type |
| 3 | Directory |
| 4 | Pyramid |
MBTiles
Access a TileLayer from an MBTiles file
File file = new File("src/main/resources/tiles.mbtiles")
MBTiles mbtiles = new MBTiles(file)
DBTiles
Access a TileLayer from an DBTiles H2 database
File file = new File("src/main/resources/h2dbtiles/world_tiles.db")
DBTiles dbtiles = new DBTiles("jdbc:h2:${file}","org.h2.Driver", "World", "World wide tiles")
GeoPackage
Access a TileLayer with a Global Geodetic Pyramid from an GeoPackage file
File file = new File("src/main/resources/data.gpkg")
geoscript.layer.GeoPackage geopackage = new geoscript.layer.GeoPackage(file, "world")
Access a TileLayer with a Global Mercator Pyramid from an GeoPackage file
File file = new File("src/main/resources/data.gpkg")
geoscript.layer.GeoPackage geopackage = new geoscript.layer.GeoPackage(file, "world_mercator")
UTFGrid
Access a TileLayer from an UTFGrid directory
File dir = new File("src/main/resources/utf")
UTFGrid utfGrid = new UTFGrid(dir)VectorTiles
Access a TileLayer from an VectorTiles directory
File dir = new File("src/main/resources/pbf")
Pyramid pyramid = Pyramid.createGlobalMercatorPyramid()
VectorTiles vectorTiles = new VectorTiles(
"World", (1)
dir, (2)
pyramid, (3)
"pbf" (4)
)| 1 | Name |
| 2 | Directory |
| 3 | Pyramid |
| 4 | Type |
Access a TileLayer from an VectorTiles MBTiles file
File file = new File("src/main/resources/vectortiles.mbtiles")
Pyramid pyramid = Pyramid.createGlobalMercatorPyramid()
VectorTiles vectorTiles = new VectorTiles(
"World", (1)
file, (2)
pyramid, (3)
"pbf" (4)
)| 1 | Name |
| 2 | MBTiles File |
| 3 | Pyramid |
| 4 | Type |
Generating TileLayer
A GeneratingTileLayer can create tiles on demand when they are accessed.
File dir = new File("target/worldtiles")
Pyramid pyramid = Pyramid.createGlobalMercatorPyramid()
TileLayer tileLayer = new TMS("World", "png", dir, pyramid)
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
countries.style = new Fill("#ffffff") + new Stroke("#b2b2b2", 0.5)
Layer ocean = workspace.get("ocean")
ocean.style = new Fill("#a5bfdd")
TileRenderer tileRenderer = new ImageTileRenderer(tileLayer, [ocean, countries])
GeneratingTileLayer generatingTileLayer = new GeneratingTileLayer(tileLayer, tileRenderer)
Tile tile = generatingTileLayer.get(0, 0, 0)
OSM
Create a TileLayer for OSM tiles.
OSM osm = new OSM()
Create a TileLayer for OSM tiles with custom urls.
OSM osm = new OSM("OSM", [
"http://a.tile.openstreetmap.org",
"http://b.tile.openstreetmap.org",
"http://c.tile.openstreetmap.org"
])
Stamen Toner
Create a TileLayer for OSM Stamen Toner tiles.
OSM osm = OSM.getWellKnownOSM("stamen-toner")
Stamen Toner Lite
Create a TileLayer for OSM Stamen Toner Lite tiles.
OSM osm = OSM.getWellKnownOSM("stamen-toner-lite")
