Charting and some tweaks to rendering API

Author: dwins

geoscript/build.sbt

@@ -8,6 +8,7 @@ libraryDependencies <++= gtVersion { v =>
     "org.geotools" % "gt-render" % v,
     "org.geotools" % "gt-xml" % v,
     "org.geotools" % "gt-geojson" % v,
+    "org.geotools" % "gt-charts" % v,
     "org.geotools.jdbc" % "gt-jdbc-postgis" % v,
     "org.geotools.jdbc" % "gt-jdbc-spatialite" % v
   )

geoscript/src/main/scala/Converters.scala

@@ -5,7 +5,7 @@ package object geoscript {
   import layer._
   import workspace._
   import render._
-  import projection.{ Projection, RichProjection }
+  import projection.{ Projection, RichProjection, Projectable, Referenced }
 
   implicit def enrichGeometry(g: Geometry): RichGeometry =
     new RichGeometry(g)
@@ -37,4 +37,11 @@ package object geoscript {
 
   implicit def enrichProjection(p: Projection): RichProjection = 
     new RichProjection(p)
+
+  class RichProjectable[P : Projectable](p: P) {
+    def in(proj: Projection): Referenced[P] = Referenced(p, proj)
+    def lift: Option[Referenced[P]] = implicitly[Projectable[P]].lift(p)
+  }
+
+  implicit def enrichProjectable[P : Projectable](p: P) = new RichProjectable(p)
 }

geoscript/src/main/scala/geometry/Geometry.scala

@@ -9,22 +9,50 @@ class RichGeometry(geometry: Geometry) {
    */
   def area: Double = geometry.getArea()
 
+  /**
+   * A symbolic alias for the union operation
+   */
+  def ||(that: Geometry): Geometry = geometry union that
+
+  /**
+   * A symbolic alias for the intersection operation
+   */
+  def &&(that: Geometry): Geometry = geometry intersection that
+
   /**
    * A jts.Envelope that fully encloses this Geometry.
    */
-  def envelope: Envelope = geometry.getEnvelopeInternal() // in projection
+  def envelope: Envelope = geometry.getEnvelopeInternal()
 
   /**
    * A point that represents the "center of gravity" of this geometry's
    * enclosed area.  Note that this point is not necessarily on the geometry!
    */
-  def centroid: Point = geometry.getCentroid() // in projection
+  def centroid: Point = geometry.getCentroid()
 
   /**
    * All the coordinates that compose this Geometry as a sequence.
    */
   def coordinates: Seq[Coordinate] = geometry.getCoordinates().toSeq
 
+  /**
+   * prepare creates a PreparedGeometry instance, which requires more time to
+   * construct but has faster implementations of several operations including
+   * `contains`, `coveredBy`, `covers`, `crosses`, `disjoint`, 
+   * `intersects`, `overlaps`, `touches`, and `within`
+   *
+   * Typically, this would be used when one geometry is being compared against
+   * many others.
+   * 
+   * {{{
+   * (needle: Geometry, haystack: Geometry) => {
+   *   val p = needle.prepared
+   *   haystack.filter(p.contains(_))
+   * }
+   * }}}
+   */
+  def prepare = preparingFactory.create(geometry)
+
   /**
    * The length of the line segments that compose this geometry, in the same
    * units as used by its coordinates.

geoscript/src/main/scala/geometry/io/package.scala

@@ -1,6 +1,7 @@
 package org.geoscript.geometry
 
 import org.geoscript.serialize._
+import org.geotools.geojson.geom.GeometryJSON
 
 object WKT extends Format[Geometry] {
   private val reader = new com.vividsolutions.jts.io.WKTReader()
@@ -23,7 +24,6 @@ object WKB extends Codec[Geometry] {
   }
 }
 
-import org.geotools.geojson.geom.GeometryJSON
 class GeoJSON(format: GeometryJSON) extends Format[Geometry] {
   def this(precision: Int) = this(new GeometryJSON(precision))
 

geoscript/src/main/scala/geometry/package.scala

@@ -19,6 +19,7 @@ package object geometry {
   val EmptyEnvelope = new jts.Envelope
 
   val factory = new jts.GeometryFactory
+  protected[geometry] val preparingFactory = new jts.prep.PreparedGeometryFactory
 
   def union(a: Envelope, b: Envelope): Envelope =
     if (a.isNull) b

geoscript/src/main/scala/projection/Projectable.scala

@@ -2,21 +2,32 @@ package org.geoscript
 package projection
 
 import geometry._
-import org.geotools.geometry.jts.JTS
+import org.geotools.geometry.jts.{ JTS, ReferencedEnvelope }
 
 trait Projectable[T] {
+  def extractProjection(t: T): Option[Projection]
+  def lift(t: T): Option[Referenced[T]] = 
+    extractProjection(t).map(Referenced(t, _)(this))
   def project(from: Projection, to: Projection)(t: T): T
 }
 
 object Projectable {
   implicit def geometriesAreProjectable[T <: Geometry]:
     Projectable[T] = new Projectable[T] {
+      def extractProjection(t: T): Option[Projection] = 
+        if (t.getSRID > 0)
+          fromSrid("EPSG:" + t.getSRID)
+        else
+          None
+
       def project(from: Projection, to: Projection)(t: T): T =
         JTS.transform(t, transform(from, to)).asInstanceOf[T]
     }
 
   implicit def envelopesAreProjectable: Projectable[Envelope] = 
     new Projectable[Envelope] {
+      def extractProjection(e: Envelope): Option[Projection] = None
+
       def project(from: Projection, to: Projection)(e: Envelope) = 
          JTS.transform(e, transform(from, to))
     }

geoscript/src/main/scala/projection/Projection.scala

@@ -16,8 +16,15 @@ package object projection {
   type Projection = CoordinateReferenceSystem
   type Transform = org.opengis.referencing.operation.MathTransform
 
+  lazy val LatLon = fromSrid("EPSG:4326").get
+  lazy val WebMercator = fromSrid("EPSG:3857").get
+
   private val catchLookup = catching(classOf[FactoryException])
 
+  def forceXYAxisOrder() {
+    System.setProperty("org.geotools.referencing.forceXY", "true")
+  }
+
   def fromWKT(s: String): Option[Projection] =
     catching(classOf[FactoryException]).opt { CRS.parseWKT(s) }
 
@@ -35,14 +42,6 @@ package object projection {
     CRS.findMathTransform(p, q)
 
   def Projection(s: String): Projection = (fromSrid(s) orElse fromWKT(s)).orNull
-
-  lazy val LatLon = fromSrid("EPSG:4326").get
-  lazy val WebMercator = fromSrid("EPSG:3857").get
-
-  def reference[T : Projectable](t: T, proj: Projection): Referenced[T] =
-    Referenced(t, proj)
-
-  def aspatial[T](t: T): Referenced[T] = Referenced(t)
 }
 
 package projection {

geoscript/src/main/scala/projection/Referenced.scala

@@ -8,8 +8,8 @@ trait Referenced[T] {
   def map[U](f: T => U): Referenced[U]
   def flatMap[U](f: T => Referenced[U]): Referenced[U]
   def native: Option[Projection]
-  def force(p: Projection): T
-  def forceNative: T = force(native.get)
+  def project(p: Projection): T
+  def forceNative: T = project(native.get)
 }
 
 object Referenced {
@@ -21,7 +21,7 @@ object Referenced {
   private class Ideal[T](value: T) extends Referenced[T] {
     def map[U](f: T => U): Referenced[U] = new Ideal(f(value))
     def flatMap[U](f: T => Referenced[U]): Referenced[U] = f(value)
-    def force(p: Projection): T = value
+    def project(p: Projection): T = value
     def native = None
   }
 
@@ -33,7 +33,7 @@ object Referenced {
     def flatMap[U](f: T => Referenced[U]): Referenced[U] =
       new FlatMapped(this, f)
 
-    def force(p: Projection): T =
+    def project(p: Projection): T =
       implicitly[Projectable[T]].project(proj, p)(value)
 
     def native = Some(proj)
@@ -46,7 +46,7 @@ object Referenced {
     def flatMap[V](g: U => Referenced[V]): Referenced[V] =
       new FlatMapped(base, f andThen g)
 
-    def force(p: Projection): U = f(base.force(p))
+    def project(p: Projection): U = f(base.project(p))
 
     def native = base.native
   }
@@ -58,8 +58,8 @@ object Referenced {
     def flatMap[V](g: U => Referenced[V]): Referenced[V] =
        new FlatMapped(this, g)
 
-    def force(p: Projection): U =
-      f(base.force(p)).force(p)
+    def project(p: Projection): U =
+      f(base.project(p)).project(p)
 
     def native = base.native
   }