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"Uber Jar
GeoScript Groovy also comes packaged as an uber jar which contains all dependencies. Download geoscript-groovy-app-1.21.0-SNAPSHOT.jar from github.
Run uber jar from the command line.
java -jar geoscript-groovy-app-1.21.0-SNAPSHOT.jarThe uber jar can take four commands:
-
script = Runs a script file like the geoscript-groovy command.
-
shell = Start an interactive shell like the geoscript-groovysh commmand.
-
console = Open the simple GUI like the geoscript-groovyConsole command.
-
version = Print the versions of GeoScript, GeoTools, and Groovy
Library
Maven
You can also use GeoScript Groovy as a library. If you use Maven you will need to add the OSGeo Maven Repository:
<repository>
<id>osgeo-releases</id>
<name>OSGeo Nexus Release Repository</name>
<url>https://repo.osgeo.org/repository/release/</url>
<snapshots>
<enabled>false</enabled>
</snapshots>
<releases>
<enabled>true</enabled>
</releases>
</repository>and then include the GeoScript Groovy dependency:
<dependency>
<groupId>org.geoscript</groupId>
<artifactId>geoscript-groovy</artifactId>
<version>1.21.0-SNAPSHOT</version>
</dependency>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.45502379201072 47.23410579860775, -122.43487808337773 47.21113402059189, -122.41190630536187 47.19098831195889, -122.38650151145399 47.1740133713689, -122.35909838472138 47.160499644761764, -122.33016580026003 47.150678355746436, -122.3001988026117 47.14471754930094, -122.26971013541457 47.14271921647622, -122.23922146821744 47.14471754930094, -122.2092544705691 47.150678355746436, -122.18032188610776 47.160499644761764, -122.15291875937515 47.1740133713689, -122.12751396546727 47.19098831195889, -122.10454218745141 47.21113402059189, -122.08439647881842 47.23410579860775, -122.06742153822843 47.25951059251563, -122.05390781162129 47.28691371924824, -122.04408652260595 47.315846303709584, -122.03812571616047 47.34581330135792, -122.03612738333574 47.37630196855505, -122.03613281249999 47.37789454155521, -122.03812571616047 47.406790635752174, -122.04408652260595 47.43675763340051, -122.05390781162129 47.465690217861855, -122.06742153822843 47.49309334459446, -122.08439647881842 47.518498138502345, -122.10454218745141 47.5414699165182, -122.12751396546727 47.561615625151205, -122.15291875937515 47.578590565741194, -122.18032188610776 47.59210429234833, -122.2092544705691 47.60192558136366, -122.23922146821744 47.60788638780915, -122.26971013541457 47.60988472063387, -122.3001988026117 47.60788638780915, -122.33016580026003 47.60192558136366, -122.35909838472138 47.59210429234833, -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.45502379201072 47.23410579860775, -122.43487808337773 47.21113402059189, -122.41190630536187 47.19098831195889, -122.38650151145399 47.1740133713689, -122.35909838472138 47.160499644761764, -122.33016580026003 47.150678355746436, -122.3001988026117 47.14471754930094, -122.26971013541457 47.14271921647622, -122.23922146821744 47.14471754930094, -122.2092544705691 47.150678355746436, -122.18032188610776 47.160499644761764, -122.15291875937515 47.1740133713689, -122.12751396546727 47.19098831195889, -122.10454218745141 47.21113402059189, -122.08439647881842 47.23410579860775, -122.06742153822843 47.25951059251563, -122.05390781162129 47.28691371924824, -122.04408652260595 47.315846303709584, -122.03812571616047 47.34581330135792, -122.03612738333574 47.37630196855505, -122.03613281249999 47.37789454155521, -122.03812571616047 47.406790635752174, -122.04408652260595 47.43675763340051, -122.05390781162129 47.465690217861855, -122.06742153822843 47.49309334459446, -122.08439647881842 47.518498138502345, -122.10454218745141 47.5414699165182, -122.12751396546727 47.561615625151205, -122.15291875937515 47.578590565741194, -122.18032188610776 47.59210429234833, -122.2092544705691 47.60192558136366, -122.23922146821744 47.60788638780915, -122.26971013541457 47.60988472063387, -122.3001988026117 47.60788638780915, -122.33016580026003 47.60192558136366, -122.35909838472138 47.59210429234833, -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.58869123015454 41.90177457905915, -118.91479847512255 43.54122641035521, -119.02412442253559 45.20921804090461, -118.91479847512254 46.87720967145401, -118.58869123015452 48.51666150275007, -118.05138247300695 50.099522059417374, -117.31206570548476 51.5987081584795, -116.38339084245754 52.98856831012859, -115.28124776830907 54.24532162182789, -114.02449445660977 55.34746469597637, -112.63463430496068 56.27613955900357, -111.13544820589856 57.01545632652577, -109.6875 57.51582286553883, -109.55258764923124 57.55276508367335, -107.91313581793518 57.878872328641364, -106.24514418738578 57.988198276054405, -104.57715255683637 57.878872328641364, -102.93770072554031 57.55276508367335, -101.354840168873 57.01545632652578, -99.85565406981087 56.27613955900357, -98.46579391816178 55.34746469597637, -97.20904060646248 54.245321621827884, -96.106897532314 52.98856831012859, -95.1782226692868 51.598708158479496, -94.4389059017646 50.09952205941737, -93.90159714461703 48.516661502750054, -93.57548989964901 46.877209671454, -93.46616395223596 45.209218040904595, -93.57548989964901 43.54122641035519, -93.8671875 42.032974332441405, -92.52944589377745 42.87620255408929, -90.13998424943786 44.054554634672606, -87.61715897053443 44.91093841996456, -85.00413629704852 45.43070094596436, -82.34562577139023 45.604948931746776, -79.68711524573195 45.430700945964375, -77.07409257224603 44.910938419964566, -74.5512672933426 44.05455463467261, -72.161805649003 42.8762025540893, -69.9465919904458 41.396044109014326, -67.94352923754218 39.63940522082037, -66.18689034934822 37.63634246791675, -64.70673190427324 35.42112880935956, -63.52837982368993 33.031667165019954, -62.67199603839798 30.508841886116528, -62.57812500000001 30.14512718337613, -62.15223351239817 27.89581921263062, -61.97798552661577 25.237308686972334, -62.15223351239817 22.578798161314044, -62.67199603839798 19.96577548782814, -63.528379823689924 17.44295020892471, -64.70673190427324 15.053488564585109, -66.1868903493482 12.838274906027912, -67.94352923754217 10.835212153124287, -69.94659199044578 9.07857326493033, -72.16180564900299 7.598414819855357, -74.55126729334258 6.420062739272041, -77.074092572246 5.563678953980087, -79.68711524573192 5.043916427980278, -82.3456257713902 4.869668442197874, -85.0041362970485 5.043916427980275, -87.6171589705344 5.56367895398008, -90.13998424943783 6.4200627392720335, -92.10937499999999 7.36246686553575, -94.00832592648507 5.722586433241055, -96.36933879828982 4.1450080684486394, -98.91606817456315 2.889100125199903, -101.60493880959024 1.9763515366073001, -104.38994338131 1.4223796840833565, -107.22342968935116 1.2366631796147836, -110.05691599739234 1.4223796840833742, -112.84192056911209 1.9763515366073285, -115.53079120413918 2.8891001251999526, -118.0775205804125 4.145008068448703, -120.43853345221724 5.72258643324113, -122.57343223472039 7.594842416368291, -124.44568821784753 9.729741198871434, -126.02326658263995 12.090754070676176, -127.265625 14.604847155053898, -127.27917452588868 14.637483446949501, -128.19192311448128 17.32635408197659, -128.74589496700523 20.111358653696357, -128.93161147147381 22.944844961737523, -128.74589496700523 25.77833126977869, -128.19192311448128 28.56333584149845, -127.27917452588866 31.25220647652554, -126.0232665826399 33.79893585279886, -124.44568821784749 36.159948724603595, -122.57343223472034 38.29484750710674, -120.4385334522172 40.167103490233885, -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.58869123015454 41.90177457905915, -118.91479847512255 43.54122641035521, -119.02412442253559 45.20921804090461, -118.91479847512254 46.87720967145401, -118.58869123015452 48.51666150275007, -118.05138247300695 50.099522059417374, -117.31206570548476 51.5987081584795, -116.38339084245754 52.98856831012859, -115.28124776830907 54.24532162182789, -114.02449445660977 55.34746469597637, -112.63463430496068 56.27613955900357, -111.13544820589856 57.01545632652577, -109.6875 57.51582286553883, -109.55258764923124 57.55276508367335, -107.91313581793518 57.878872328641364, -106.24514418738578 57.988198276054405, -104.57715255683637 57.878872328641364, -102.93770072554031 57.55276508367335, -101.354840168873 57.01545632652578, -99.85565406981087 56.27613955900357, -98.46579391816178 55.34746469597637, -97.20904060646248 54.245321621827884, -96.106897532314 52.98856831012859, -95.1782226692868 51.598708158479496, -94.4389059017646 50.09952205941737, -93.90159714461703 48.516661502750054, -93.57548989964901 46.877209671454, -93.46616395223596 45.209218040904595, -93.57548989964901 43.54122641035519, -93.8671875 42.032974332441405, -92.52944589377745 42.87620255408929, -90.13998424943786 44.054554634672606, -87.61715897053443 44.91093841996456, -85.00413629704852 45.43070094596436, -82.34562577139023 45.604948931746776, -79.68711524573195 45.430700945964375, -77.07409257224603 44.910938419964566, -74.5512672933426 44.05455463467261, -72.161805649003 42.8762025540893, -69.9465919904458 41.396044109014326, -67.94352923754218 39.63940522082037, -66.18689034934822 37.63634246791675, -64.70673190427324 35.42112880935956, -63.52837982368993 33.031667165019954, -62.67199603839798 30.508841886116528, -62.57812500000001 30.14512718337613, -62.15223351239817 27.89581921263062, -61.97798552661577 25.237308686972334, -62.15223351239817 22.578798161314044, -62.67199603839798 19.96577548782814, -63.528379823689924 17.44295020892471, -64.70673190427324 15.053488564585109, -66.1868903493482 12.838274906027912, -67.94352923754217 10.835212153124287, -69.94659199044578 9.07857326493033, -72.16180564900299 7.598414819855357, -74.55126729334258 6.420062739272041, -77.074092572246 5.563678953980087, -79.68711524573192 5.043916427980278, -82.3456257713902 4.869668442197874, -85.0041362970485 5.043916427980275, -87.6171589705344 5.56367895398008, -90.13998424943783 6.4200627392720335, -92.10937499999999 7.36246686553575, -94.00832592648507 5.722586433241055, -96.36933879828982 4.1450080684486394, -98.91606817456315 2.889100125199903, -101.60493880959024 1.9763515366073001, -104.38994338131 1.4223796840833565, -107.22342968935116 1.2366631796147836, -110.05691599739234 1.4223796840833742, -112.84192056911209 1.9763515366073285, -115.53079120413918 2.8891001251999526, -118.0775205804125 4.145008068448703, -120.43853345221724 5.72258643324113, -122.57343223472039 7.594842416368291, -124.44568821784753 9.729741198871434, -126.02326658263995 12.090754070676176, -127.265625 14.604847155053898, -127.27917452588868 14.637483446949501, -128.19192311448128 17.32635408197659, -128.74589496700523 20.111358653696357, -128.93161147147381 22.944844961737523, -128.74589496700523 25.77833126977869, -128.19192311448128 28.56333584149845, -127.27917452588866 31.25220647652554, -126.0232665826399 33.79893585279886, -124.44568821784749 36.159948724603595, -122.57343223472034 38.29484750710674, -120.4385334522172 40.167103490233885, -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.02233144941429 23.848852560584696, 25.52476733728419 22.848212211944787, 23.909405319245256 22.051603821364196, 22.203884687289097 21.472657579267327, 20.43738737228814 21.121279416370683, 18.640138633067632 21.003481510461857, 16.842889893847126 21.121279416370697, 15.076392578846168 21.47265757926735, 13.370871946890016 22.051603821364225, 11.755509928851087 22.848212211944826, 10.25794581672099 23.84885256058474, 8.903803347661489 25.036403633488828, 7.716252274757407 26.390546102548335, 6.7156119261174965 27.888110214678434, 5.9190035355369055 29.503472232717364, 5.340057293440033 31.208992864673522, 4.988679130543385 32.97549017967448, 4.870881224634555 34.77273891889499, 4.988679130543391 36.569987658115494, 5.340057293440042 38.33648497311645, 5.919003535536916 40.0420056050726, 5.9765625 40.17887331434696, 6.715611926117511 41.65736762311153, 7.716252274757425 43.15493173524163, 8.903803347661508 44.509074204301136, 10.257945816721014 45.69662527720522, 11.755509928851112 46.697265625845134, 13.370871946890045 47.493874016425735, 15.076392578846201 48.072820258522604, 16.84288989384716 48.424198421419256, 18.64013863306767 48.54199632732809, 20.437387372288185 48.424198421419256, 22.203884687289143 48.072820258522604, 22.5 47.98992166741417, 71.71875 49.15296965617039, 72.58658076138722 48.95345106044013, 74.12646468490567 48.43073090444655, 75.58494601643166 47.71148750685246, 76.93706973601536 46.80802732160264, 78.1597006319352 45.7358088029532, 79.23191915058463 44.51317790703337, 80.13537933583444 43.161054187449665, 80.85462273342853 41.70257285592368, 81.37734288942211 40.16268893240523, 81.5625 39.36827914916011, 81.69459591702073 38.56775025776221, 81.80095352896302 36.94504667491831, 81.69459591702073 35.322343092074405, 81.37734288942211 33.72740441743139, 80.85462273342853 32.18752049391294, 80.13537933583444 30.72903916238695, 79.23191915058463 29.376915442803245, 78.1597006319352 28.154284546883417, 76.93706973601536 27.08206602823398, 75.58494601643166 26.17860584298416, 74.12646468490567 25.45936244539007, 72.58658076138722 24.93664228939649, 70.9916420867442 24.619389261797874, 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.02233144941429 23.848852560584696, 25.52476733728419 22.848212211944787, 23.909405319245256 22.051603821364196, 22.203884687289097 21.472657579267327, 20.43738737228814 21.121279416370683, 18.640138633067632 21.003481510461857, 16.842889893847126 21.121279416370697, 15.076392578846168 21.47265757926735, 13.370871946890016 22.051603821364225, 11.755509928851087 22.848212211944826, 10.25794581672099 23.84885256058474, 8.903803347661489 25.036403633488828, 7.716252274757407 26.390546102548335, 6.7156119261174965 27.888110214678434, 5.9190035355369055 29.503472232717364, 5.340057293440033 31.208992864673522, 4.988679130543385 32.97549017967448, 4.870881224634555 34.77273891889499, 4.988679130543391 36.569987658115494, 5.340057293440042 38.33648497311645, 5.919003535536916 40.0420056050726, 5.9765625 40.17887331434696, 6.715611926117511 41.65736762311153, 7.716252274757425 43.15493173524163, 8.903803347661508 44.509074204301136, 10.257945816721014 45.69662527720522, 11.755509928851112 46.697265625845134, 13.370871946890045 47.493874016425735, 15.076392578846201 48.072820258522604, 16.84288989384716 48.424198421419256, 18.64013863306767 48.54199632732809, 20.437387372288185 48.424198421419256, 22.203884687289143 48.072820258522604, 22.5 47.98992166741417) LINESTRING (22.5 47.98992166741417, 71.71875 49.15296965617039) LINESTRING (71.71875 49.15296965617039, 72.58658076138722 48.95345106044013, 74.12646468490567 48.43073090444655, 75.58494601643166 47.71148750685246, 76.93706973601536 46.80802732160264, 78.1597006319352 45.7358088029532, 79.23191915058463 44.51317790703337, 80.13537933583444 43.161054187449665, 80.85462273342853 41.70257285592368, 81.37734288942211 40.16268893240523, 81.5625 39.36827914916011, 81.69459591702073 38.56775025776221, 81.80095352896302 36.94504667491831, 81.69459591702073 35.322343092074405, 81.37734288942211 33.72740441743139, 80.85462273342853 32.18752049391294, 80.13537933583444 30.72903916238695, 79.23191915058463 29.376915442803245, 78.1597006319352 28.154284546883417, 76.93706973601536 27.08206602823398, 75.58494601643166 26.17860584298416, 74.12646468490567 25.45936244539007, 72.58658076138722 24.93664228939649, 70.9916420867442 24.619389261797874, 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.02233144941429 23.848852560584696, 25.52476733728419 22.848212211944787, 23.909405319245256 22.051603821364196, 22.203884687289097 21.472657579267327, 20.43738737228814 21.121279416370683, 18.640138633067632 21.003481510461857, 16.842889893847126 21.121279416370697, 15.076392578846168 21.47265757926735, 13.370871946890016 22.051603821364225, 11.755509928851087 22.848212211944826, 10.25794581672099 23.84885256058474, 8.903803347661489 25.036403633488828, 7.716252274757407 26.390546102548335, 6.7156119261174965 27.888110214678434, 5.9190035355369055 29.503472232717364, 5.340057293440033 31.208992864673522, 4.988679130543385 32.97549017967448, 4.870881224634555 34.77273891889499, 4.988679130543391 36.569987658115494, 5.340057293440042 38.33648497311645, 5.919003535536916 40.0420056050726, 5.9765625 40.17887331434696, 6.715611926117511 41.65736762311153, 7.716252274757425 43.15493173524163, 8.903803347661508 44.509074204301136, 10.257945816721014 45.69662527720522, 11.755509928851112 46.697265625845134, 13.370871946890045 47.493874016425735, 15.076392578846201 48.072820258522604, 16.84288989384716 48.424198421419256, 18.64013863306767 48.54199632732809, 20.437387372288185 48.424198421419256, 22.203884687289143 48.072820258522604, 22.5 47.98992166741417, 71.71875 49.15296965617039, 72.58658076138722 48.95345106044013, 74.12646468490567 48.43073090444655, 75.58494601643166 47.71148750685246, 76.93706973601536 46.80802732160264, 78.1597006319352 45.7358088029532, 79.23191915058463 44.51317790703337, 80.13537933583444 43.161054187449665, 80.85462273342853 41.70257285592368, 81.37734288942211 40.16268893240523, 81.5625 39.36827914916011, 81.69459591702073 38.56775025776221, 81.80095352896302 36.94504667491831, 81.69459591702073 35.322343092074405, 81.37734288942211 33.72740441743139, 80.85462273342853 32.18752049391294, 80.13537933583444 30.72903916238695, 79.23191915058463 29.376915442803245, 78.1597006319352 28.154284546883417, 76.93706973601536 27.08206602823398, 75.58494601643166 26.17860584298416, 74.12646468490567 25.45936244539007, 72.58658076138722 24.93664228939649, 70.9916420867442 24.619389261797874, 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.02233144941429 23.848852560584696, 25.52476733728419 22.848212211944787, 23.909405319245256 22.051603821364196, 22.203884687289097 21.472657579267327, 20.43738737228814 21.121279416370683, 18.640138633067632 21.003481510461857, 16.842889893847126 21.121279416370697, 15.076392578846168 21.47265757926735, 13.370871946890016 22.051603821364225, 11.755509928851087 22.848212211944826, 10.25794581672099 23.84885256058474, 8.903803347661489 25.036403633488828, 7.716252274757407 26.390546102548335, 6.7156119261174965 27.888110214678434, 5.9190035355369055 29.503472232717364, 5.340057293440033 31.208992864673522, 4.988679130543385 32.97549017967448, 4.870881224634555 34.77273891889499, 4.988679130543391 36.569987658115494, 5.340057293440042 38.33648497311645, 5.919003535536916 40.0420056050726, 5.9765625 40.17887331434696, 6.715611926117511 41.65736762311153, 7.716252274757425 43.15493173524163, 8.903803347661508 44.509074204301136, 10.257945816721014 45.69662527720522, 11.755509928851112 46.697265625845134, 13.370871946890045 47.493874016425735, 15.076392578846201 48.072820258522604, 16.84288989384716 48.424198421419256, 18.64013863306767 48.54199632732809, 20.437387372288185 48.424198421419256, 22.203884687289143 48.072820258522604, 22.5 47.98992166741417, 71.71875 49.15296965617039, 72.58658076138722 48.95345106044013, 74.12646468490567 48.43073090444655, 75.58494601643166 47.71148750685246, 76.93706973601536 46.80802732160264, 78.1597006319352 45.7358088029532, 79.23191915058463 44.51317790703337, 80.13537933583444 43.161054187449665, 80.85462273342853 41.70257285592368, 81.37734288942211 40.16268893240523, 81.5625 39.36827914916011, 81.69459591702073 38.56775025776221, 81.80095352896302 36.94504667491831, 81.69459591702073 35.322343092074405, 81.37734288942211 33.72740441743139, 80.85462273342853 32.18752049391294, 80.13537933583444 30.72903916238695, 79.23191915058463 29.376915442803245, 78.1597006319352 28.154284546883417, 76.93706973601536 27.08206602823398, 75.58494601643166 26.17860584298416, 74.12646468490567 25.45936244539007, 72.58658076138722 24.93664228939649, 70.9916420867442 24.619389261797874, 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.02233144941429 23.848852560584696, 25.52476733728419 22.848212211944787, 23.909405319245256 22.051603821364196, 22.203884687289097 21.472657579267327, 20.43738737228814 21.121279416370683, 18.640138633067632 21.003481510461857, 16.842889893847126 21.121279416370697, 15.076392578846168 21.47265757926735, 13.370871946890016 22.051603821364225, 11.755509928851087 22.848212211944826, 10.25794581672099 23.84885256058474, 8.903803347661489 25.036403633488828, 7.716252274757407 26.390546102548335, 6.7156119261174965 27.888110214678434, 5.9190035355369055 29.503472232717364, 5.340057293440033 31.208992864673522, 4.988679130543385 32.97549017967448, 4.870881224634555 34.77273891889499, 4.988679130543391 36.569987658115494, 5.340057293440042 38.33648497311645, 5.919003535536916 40.0420056050726, 5.9765625 40.17887331434696, 6.715611926117511 41.65736762311153, 7.716252274757425 43.15493173524163, 8.903803347661508 44.509074204301136, 10.257945816721014 45.69662527720522, 11.755509928851112 46.697265625845134, 13.370871946890045 47.493874016425735, 15.076392578846201 48.072820258522604, 16.84288989384716 48.424198421419256, 18.64013863306767 48.54199632732809, 20.437387372288185 48.424198421419256, 22.203884687289143 48.072820258522604, 22.5 47.98992166741417) LINESTRING (22.5 47.98992166741417, 71.71875 49.15296965617039) LINESTRING (71.71875 49.15296965617039, 72.58658076138722 48.95345106044013, 74.12646468490567 48.43073090444655, 75.58494601643166 47.71148750685246, 76.93706973601536 46.80802732160264, 78.1597006319352 45.7358088029532, 79.23191915058463 44.51317790703337, 80.13537933583444 43.161054187449665, 80.85462273342853 41.70257285592368, 81.37734288942211 40.16268893240523, 81.5625 39.36827914916011, 81.69459591702073 38.56775025776221, 81.80095352896302 36.94504667491831, 81.69459591702073 35.322343092074405, 81.37734288942211 33.72740441743139, 80.85462273342853 32.18752049391294, 80.13537933583444 30.72903916238695, 79.23191915058463 29.376915442803245, 78.1597006319352 28.154284546883417, 76.93706973601536 27.08206602823398, 75.58494601643166 26.17860584298416, 74.12646468490567 25.45936244539007, 72.58658076138722 24.93664228939649, 70.9916420867442 24.619389261797874, 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.02233144941429 23.848852560584696, 25.52476733728419 22.848212211944787, 23.909405319245256 22.051603821364196, 22.203884687289097 21.472657579267327, 20.43738737228814 21.121279416370683, 18.640138633067632 21.003481510461857, 16.842889893847126 21.121279416370697, 15.076392578846168 21.47265757926735, 13.370871946890016 22.051603821364225, 11.755509928851087 22.848212211944826, 10.25794581672099 23.84885256058474, 8.903803347661489 25.036403633488828, 7.716252274757407 26.390546102548335, 6.7156119261174965 27.888110214678434, 5.9190035355369055 29.503472232717364, 5.340057293440033 31.208992864673522, 4.988679130543385 32.97549017967448, 4.870881224634555 34.77273891889499, 4.988679130543391 36.569987658115494, 5.340057293440042 38.33648497311645, 5.919003535536916 40.0420056050726, 5.9765625 40.17887331434696, 6.715611926117511 41.65736762311153, 7.716252274757425 43.15493173524163, 8.903803347661508 44.509074204301136, 10.257945816721014 45.69662527720522, 11.755509928851112 46.697265625845134, 13.370871946890045 47.493874016425735, 15.076392578846201 48.072820258522604, 16.84288989384716 48.424198421419256, 18.64013863306767 48.54199632732809, 20.437387372288185 48.424198421419256, 22.203884687289143 48.072820258522604, 22.5 47.98992166741417, 71.71875 49.15296965617039, 72.58658076138722 48.95345106044013, 74.12646468490567 48.43073090444655, 75.58494601643166 47.71148750685246, 76.93706973601536 46.80802732160264, 78.1597006319352 45.7358088029532, 79.23191915058463 44.51317790703337, 80.13537933583444 43.161054187449665, 80.85462273342853 41.70257285592368, 81.37734288942211 40.16268893240523, 81.5625 39.36827914916011, 81.69459591702073 38.56775025776221, 81.80095352896302 36.94504667491831, 81.69459591702073 35.322343092074405, 81.37734288942211 33.72740441743139, 80.85462273342853 32.18752049391294, 80.13537933583444 30.72903916238695, 79.23191915058463 29.376915442803245, 78.1597006319352 28.154284546883417, 76.93706973601536 27.08206602823398, 75.58494601643166 26.17860584298416, 74.12646468490567 25.45936244539007, 72.58658076138722 24.93664228939649, 70.9916420867442 24.619389261797874, 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)
Buffer a LineString with a beginning and end distance.
LineString line = new LineString([
[-122.38494873046875, 47.57281986733871],
[-122.27508544921875, 47.342545069660225],
[-122.15972900390624, 47.14302937421008],
[-121.96197509765625, 47.03082254778662],
[-121.73950195312499, 46.89586230605985],
[-121.56372070312499, 46.81509864599243]
])
Geometry buffer = line.variableBuffer([0.03, 0.07])
Buffer a LineString with a beginning, middle, and end distance.
LineString line = new LineString([
[-122.38494873046875, 47.57281986733871],
[-122.27508544921875, 47.342545069660225],
[-122.15972900390624, 47.14302937421008],
[-121.96197509765625, 47.03082254778662],
[-121.73950195312499, 46.89586230605985],
[-121.56372070312499, 46.81509864599243]
])
Geometry buffer = line.variableBuffer([0.03, 0.07, 0.1])
Buffer a LineString with a list of distances.
LineString line = new LineString([
[-122.38494873046875, 47.57281986733871],
[-122.27508544921875, 47.342545069660225],
[-122.15972900390624, 47.14302937421008],
[-121.96197509765625, 47.03082254778662],
[-121.73950195312499, 46.89586230605985],
[-121.56372070312499, 46.81509864599243]
])
Geometry buffer = line.variableBuffer([0.03, 0.05, 0.07, 0.09, 0.1, 0.2])
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
Triangulate inside of a Geometry.
Geometry geometry = Geometry.fromWKT("POLYGON ((-120.047607421875 48.100094697973795, -121.53076171875 48.44377831058802, " +
"-122.03613281249999 47.5394554474239, -120.81665039062499 47.249406957888446, -121.78344726562499 46.437856895024204, " +
"-119.20166015625 46.31658418182218, -118.05908203124999 47.39834920035926, -117.61962890624999 48.50204750525715, " +
"-119.3115234375 48.65468584817256, -119.20166015625 47.82053186746053, -120.003662109375 47.60616304386874, " +
"-120.0146484375 48.06339653776211, -120.047607421875 48.100094697973795))")
Geometry triangles = geometry.triangulate()
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
Calculate the largest empty circle within a Geometry
Geometry g = Geometry.fromWKT("POLYGON ((-122.38855361938475 47.5805786829606, -122.38636493682861 47.5783206388176, " +
"-122.38700866699219 47.5750491969984, -122.38177299499512 47.57502024527343, " +
"-122.38481998443604 47.5780600889959, -122.38151550292969 47.5805786829606, " +
"-122.38855361938475 47.5805786829606))")
Geometry circle = g.getLargestEmptyCircle(1.0)
Calculate the maximum inscribed circle within a Geometry
Geometry g = Geometry.fromWKT("POLYGON ((-122.38855361938475 47.5805786829606, -122.38636493682861 47.5783206388176, " +
"-122.38700866699219 47.5750491969984, -122.38177299499512 47.57502024527343, " +
"-122.38481998443604 47.5780600889959, -122.38151550292969 47.5805786829606, " +
"-122.38855361938475 47.5805786829606))")
Geometry circle = g.getMaximumInscribedCircle(1.0)
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
Fix a Geometry
Geometry line = new LineString([[0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [1, 1]])
println "LineString with duplicated Points = ${line.wkt}"
Geometry fixedLine = line.fix()
println "Fixed LineString = ${fixedLine}"
LineString with duplicated Points = LINESTRING (0 0, 0 0, 0 0, 0 0, 0 0, 1 1) Fixed LineString = LINESTRING (0 0, 1 1)
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 = 454292680 nanoseconds Time with PreparedGeometry = 256996788 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 = 391420308 nanoseconds Time with PreparedGeometry = 254410345 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 YamlReader
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 YamlWriter TWkbWriter
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
Get a Geometry from a TWKB Encoded String
String twkb = "E10801BFCBB99609A0D3F9B80300"
Geometry geometry = Geometry.fromTwkb(twkb)
Get TWKB Encoded String from a Geometry
Geometry geometry = new Point(-123.15, 46.237)
String twkb = geometry.twkb
println twkbE10801BFCBB99609A0D3F9B80300
Read a Geometry from TWKB hex encoded String
TWkbReader reader = new TWkbReader()
Geometry geometry = reader.read("E10801BFCBB99609A0D3F9B80300")
println geometry.wktPOINT (-123.15 46.237)
Write a Geometry to a TWKB hex encoded String using the TwkbWriter
Geometry geometry = new LineString(
[3.198, 43.164],
[6.713, 49.755],
[9.702, 42.592],
[15.32, 53.798]
)
TWkbWriter writer = new TWkbWriter()
String twkb = writer.write(geometry)
println twkbE2080104C0E7BF1E80B7D29B0300E0E2C221E0D3ED3E00A0D7C01CDFF2A74400C0F4C935C099EF6A00
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@
YAML
Get a Geometry from a GeoYaml String
String yaml = """---
geometry:
type: "Point"
coordinates:
- -122.23
- 45.67
"""
Geometry geometry = Geometry.fromYaml(yaml)
Get GeoYaml from a Geometry
Geometry geometry = new Point(-123.15, 46.237)
String yaml = geometry.yaml
println yaml--- geometry: type: Point coordinates: - -123.15 - 46.237
Read a Geometry from a GeoYaml String using the YamlReader
String yaml = """---
geometry:
type: "Point"
coordinates:
- -122.23
- 45.67
"""
YamlReader reader = new YamlReader()
Geometry geometry = reader.read(yaml)
Write a Geometry to a GeoYaml String using the YamlWriter
Geometry geometry = new LineString(
[3.198, 43.164],
[6.713, 49.755],
[9.702, 42.592],
[15.32, 53.798]
)
YamlWriter writer = new YamlWriter()
String yaml = writer.write(geometry)
println yaml---
geometry:
type: LineString
coordinates:
- - 3.198
- 43.164
- - 6.713
- 49.755
- - 9.702
- 42.592
- - 15.32
- 53.798
Bounds Recipes
The Bounds class is in the geoscript.geom package.
It represents a minimum bounding box or rectangle, so it has minimum and maximum x and y coordinates in a specified projection.
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.7684518,703506.2231641796,1155828.1202425023,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.2040371664 703068.0661327793)
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.2040371664 703068.0661327793)
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.2040371664 703068.0661327793)
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.2040371664 703068.0661327793)
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.65817457195088
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.51642779589723)
double azimuth = results.backAzimuth
println azimuth75.65337425050723
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.52791689304304) POINT (-79.8828640042499 44.63747566950249) POINT (-84.51118758826816 45.565540142641005) POINT (-89.27793446221685 46.300124344169255) POINT (-94.15564606698499 46.83102721803566) POINT (-99.11079892605703 47.15045006457598) POINT (-104.10532353179985 47.25351783423774) POINT (-109.09873812691617 47.13862709798196) POINT (-114.05062990603696 46.80756425557422) 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 HPRtree
Create a HPRtree spatial index
HPRtree index = new HPRtree()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 (5 5) POINT (4 4)
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])
Draw a Geometry to a Base64 Encoded String
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]
]])
String base64EncodedString = Viewer.drawToBase64EncodedString(polygon)
println base64EncodedStringimage/png;base64,iVBORw0KGgoAAAANSUhEUgAAAfQAAAH0CAYAAADL1t+KAAAR/ElEQVR4Xu3bC47kxrVFUc1VA30z0JT8ELKvXXWU9UkyfiTXBhZg2SmpO8jk...
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.
The major classes in this package include Field, Schema, and Feature.
A Field has a name and a type and describes a column of data.
A Schema is a collection of Fields together with a name. Schemas are used to create new Layers.
A Feature contains a geometry and a collection of attributes. A collection of Features is called a Layer.
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-6908cacc_18a62461511_-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 YamlWriter
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 YamlReader
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 geobuf0a0269640a046e616d65100218062a2b0a0c08001a089fd8d374c0ebb22d5a06636974792e316a0218016a090a0753656174746c65720400000101
Get a Feature from a GeoBuf String
String geobuf = '0a0269640a046e616d65100218062a1d0a0c08001a089fd8d374c0ebb22d6a0218016a090a0753656174746c65'
Feature feature = Feature.fromGeobuf(geobuf)
println featurefeatures. 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 geobuf0a0269640a046e616d65100218062a2b0a0c08001a089fd8d374c0ebb22d5a06636974792e316a0218016a090a0753656174746c65720400000101
Read a Feature from a GeoBuf String
GeobufReader reader = new GeobufReader()
String geobuf = '0a0269640a046e616d65100218062a1d0a0c08001a089fd8d374c0ebb22d6a0218016a090a0753656174746c65'
Feature feature = reader.read(geobuf)
println featurefeatures. 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>[geom:POINT (-122.3204 47.6024), id:1, name:Seattle]</summary><updated>Mon Sep 04 22:17:55 UTC 2023</updated><georss:point>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-6908cacc_18a62461511_-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>[geom:POINT (-122.3204 47.6024), id:1, name:Seattle]</summary><updated>Mon Sep 04 22:17:55 UTC 2023</updated><georss:point>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-6908cacc_18a62461511_-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-6908cacc_18a62461511_-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-6908cacc_18a62461511_-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)
YAML
Get a Yaml 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 yaml = feature.yaml
println yaml--- type: Feature properties: id: 1 name: Seattle geometry: type: Point coordinates: - -122.3204 - 47.6024
Get a Feature from a Yaml String
String yaml = """---
type: "Feature"
properties:
id: 1
name: "Seattle"
geometry:
type: "Point"
coordinates:
- -122.3204
- 47.6024
"""
Feature feature = Feature.fromYaml(yaml)
println featurefeature.1 id: 1, name: Seattle, geom: POINT (-122.3204 47.6024)
Write a Feature to a YAML 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)
YamlWriter writer = new YamlWriter()
String yml = writer.write(feature)
println yml--- type: Feature properties: id: 1 name: Seattle geometry: type: Point coordinates: - -122.3204 - 47.6024
Read a Feature from a YAML String
YamlReader reader = new YamlReader()
String yml = """---
type: "Feature"
properties:
id: 1
name: "Seattle"
geometry:
type: "Point"
coordinates:
- -122.3204
- 47.6024
"""
Feature feature = reader.read(yml)
println featurefeature.1 id: 1, name: Seattle, geom: 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 318 Functions: And Area Categorize Collection_Average Collection_Bounds Collection_Count Collection_Max Collection_Median Collection_Min Collection_Nearest
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
}PiYG RdGy Purples Reds BuPu Set1 PuBuGn Grays PuOr Accents YlGn YlOrBr RdPu PuRd RdYlGn Paired Set3 Set2 GnBu YlGnBu RdYlBu RdBu BuGn BrBG PRGn Blues Greens OrRd Dark2 Oranges Spectral Pastel2 Pastel1 PuBu YlOrRd 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
}PiYG RdGy PuOr RdYlGn RdYlBu RdBu BrBG PRGn Spectral BlueToOrange GreenToOrange BlueToRed GreenToRedOrange
Get sequential color palettes
List<String> sequentialPalettes = Color.getPaletteNames("sequential")
sequentialPalettes.each { String name ->
println name
}Purples Reds BuPu PuBuGn Grays YlGn YlOrBr RdPu PuRd GnBu YlGnBu BuGn Blues Greens OrRd Oranges PuBu YlOrRd Sunset Green YellowToRedHeatMap BlueToYellowToRedHeatMap DarkRedToYellowWhiteHeatMap LightPurpleToDarkPurpleHeatMap BoldLandUse MutedTerrain
Get qualitative color palettes
List<String> qualitativePalettes = Color.getPaletteNames("qualitative")
qualitativePalettes.each { String name ->
println name
}Set1 Accents Paired Set3 Set2 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:GroupCandidateSelection 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:difference geo:union geo:isValid geo:intersects geo:getX geo:getY geo:area geo:numGeometries geo:splitPolygon geo:reproject geo:isClosed geo:within geo:touches geo:convexHull geo:crosses geo:symDifference geo:boundary geo:centroid geo:interiorPoint geo:getGeometryN geo:intersection geo:overlaps geo:isSimple geo:isWithinDistance geo:relate geo:densify geo:simplify geo:startPoint geo:numPoints geo:dimension geo:exteriorRing geo:numInteriorRing geo:geometryType geo:envelope geo:equalsExact geo:isRing geo:polygonize geo:endPoint geo:interiorRingN geo:relatePattern geo:pointN geo:equalsExactTolerance geo:length geo:buffer geo:isEmpty geo:contains geo:distance geo:disjoint polygonlabelprocess:PolyLabeller centerLine:centerLine skeltonize:centerLine 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
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})
println geoms
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.997186888040857E7,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
Projections
Create a map in the mercator projection
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
countries.style = new Fill("#ffffff") + new Stroke("black", 0.5)
Layer ocean = workspace.get("ocean")
ocean.style = new Fill("#a5bfdd") + new Stroke("black", 0.5)
Layer graticules = workspace.get("graticules")
graticules.style = new Stroke("black", 0.5)
Projection proj = new Projection("Mercator")
Bounds bounds = new Bounds(-179.99, -85.0511, 179.99, 85.0511, "EPSG:4326").reproject(proj)
Map map = new Map(
width: 400,
height: 400,
proj: proj,
bounds: bounds,
layers: [ocean, countries, graticules]
)
File file = new File("map_mercator.png")
map.render(file)
Create a map in the WGS84 projection
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
countries.style = new Fill("#ffffff") + new Stroke("black", 0.5)
Layer ocean = workspace.get("ocean")
ocean.style = new Fill("#a5bfdd") + new Stroke("black", 0.5)
Layer graticules = workspace.get("graticules")
graticules.style = new Stroke("black", 0.5)
Projection proj = new Projection("WGS84")
Bounds bounds = new Bounds(-180, -90, 180, 90, "EPSG:4326").reproject(proj)
Map map = new Map(
width: 600,
height: 350,
proj: proj,
bounds: bounds,
layers: [ocean, countries, graticules]
)
File file = new File("map_wgs84.png")
map.render(file)
Create a map in the Equal Earth projection
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
countries.style = new Fill("#ffffff") + new Stroke("black", 0.5)
Layer ocean = workspace.get("ocean")
ocean.style = new Fill("#a5bfdd") + new Stroke("black", 0.5)
Layer graticules = workspace.get("graticules")
graticules.style = new Stroke("black", 0.5)
Projection proj = new Projection("EqualEarth")
Bounds bounds = new Bounds(-180, -90, 180, 90, "EPSG:4326").reproject(proj)
Map map = new Map(
width: 600,
height: 350,
proj: proj,
bounds: bounds,
layers: [ocean, countries, graticules]
)
File file = new File("map_equalearth.png")
map.render(file)
Create a map in the Mollweide projection
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
countries.style = new Fill("#ffffff") + new Stroke("black", 0.5)
Layer ocean = workspace.get("ocean")
ocean.style = new Fill("#a5bfdd") + new Stroke("black", 0.5)
Layer graticules = workspace.get("graticules")
graticules.style = new Stroke("black", 0.5)
Projection proj = new Projection("Mollweide")
Bounds bounds = new Bounds(-180, -90, 180, 90, "EPSG:4326").reproject(proj)
Map map = new Map(
width: 600,
height: 350,
proj: proj,
bounds: bounds,
layers: [ocean, countries, graticules]
)
File file = new File("map_mollweide.png")
map.render(file)
Create a map in the Aitoff projection
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
countries.style = new Fill("#ffffff") + new Stroke("black", 0.5)
Layer ocean = workspace.get("ocean")
ocean.style = new Fill("#a5bfdd") + new Stroke("black", 0.5)
Layer graticules = workspace.get("graticules")
graticules.style = new Stroke("black", 0.5)
Projection proj = new Projection("Aitoff")
Bounds bounds = new Bounds(-180, -90, 180, 90, "EPSG:4326").reproject(proj)
Map map = new Map(
width: 600,
height: 350,
proj: proj,
bounds: bounds,
layers: [ocean, countries, graticules]
)
File file = new File("map_aitoff.png")
map.render(file)
Create a map in the Eckert IV projection
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
countries.style = new Fill("#ffffff") + new Stroke("black", 0.5)
Layer ocean = workspace.get("ocean")
ocean.style = new Fill("#a5bfdd") + new Stroke("black", 0.5)
Layer graticules = workspace.get("graticules")
graticules.style = new Stroke("black", 0.5)
Projection proj = new Projection("EckertIV")
Bounds bounds = new Bounds(-180, -90, 180, 90, "EPSG:4326").reproject(proj)
Map map = new Map(
width: 600,
height: 350,
proj: proj,
bounds: bounds,
layers: [ocean, countries, graticules]
)
File file = new File("map_eckertIV.png")
map.render(file)
Create a map in the Wagner IV projection
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
countries.style = new Fill("#ffffff") + new Stroke("black", 0.5)
Layer ocean = workspace.get("ocean")
ocean.style = new Fill("#a5bfdd") + new Stroke("black", 0.5)
Layer graticules = workspace.get("graticules")
graticules.style = new Stroke("black", 0.5)
Projection proj = new Projection("WagnerIV")
Bounds bounds = new Bounds(-180, -90, 180, 90, "EPSG:4326").reproject(proj)
Map map = new Map(
width: 600,
height: 350,
proj: proj,
bounds: bounds,
layers: [ocean, countries, graticules]
)
File file = new File("map_wagnerIV.png")
map.render(file)
Create a map in the Robinson projection
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
countries.style = new Fill("#ffffff") + new Stroke("black", 0.5)
Layer ocean = workspace.get("ocean")
ocean.style = new Fill("#a5bfdd") + new Stroke("black", 0.5)
Layer graticules = workspace.get("graticules")
graticules.style = new Stroke("black", 0.5)
Projection proj = new Projection("Robinson")
Bounds bounds = new Bounds(-180, -90, 180, 90, "EPSG:4326").reproject(proj)
Map map = new Map(
width: 600,
height: 350,
proj: proj,
bounds: bounds,
layers: [ocean, countries, graticules]
)
File file = new File("map_robinson.png")
map.render(file)
Create a map in the Winkel Tripel projection
Workspace workspace = new GeoPackage('src/main/resources/data.gpkg')
Layer countries = workspace.get("countries")
countries.style = new Fill("#ffffff") + new Stroke("black", 0.5)
Layer ocean = workspace.get("ocean")
ocean.style = new Fill("#a5bfdd") + new Stroke("black", 0.5)
Layer graticules = workspace.get("graticules")
graticules.style = new Stroke("black", 0.5)
Projection proj = new Projection("WinkelTripel")
Bounds bounds = new Bounds(-180, -90, 180, 90, "EPSG:4326").reproject(proj)
Map map = new Map(
width: 600,
height: 350,
proj: proj,
bounds: bounds,
layers: [ocean, countries, graticules]
)
File file = new File("map_winkeltripel.png")
map.render(file)
Create a map in the World Vander Grinten I projection
Workspace workspace = new Directory('src/main/resources/shapefiles')
Layer countries = workspace.get("countries")
countries.style = new Fill("#ffffff") + new Stroke("black", 0.5)
Layer ocean = workspace.get("ocean")
ocean.style = new Fill("#a5bfdd") + new Stroke("black", 0.5)
Layer graticules = workspace.get("graticules")
graticules.style = new Stroke("black", 0.5)
Projection proj = new Projection("WorldVanderGrintenI")
Bounds bounds = new Bounds(-180, -90, 180, 90, "EPSG:4326").reproject(proj)
Map map = new Map(
width: 600,
height: 350,
proj: proj,
bounds: bounds,
layers: [ocean, countries, graticules]
)
File file = new File("map_worldVanderGrintenIMap.png")
map.render(file)
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("target/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("target/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 = '${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 = '${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