Initial generation of slippy map tiles in WebMercator.

Signed-off-by: Simeon H.K. Fitch <[email protected]>

Author: metasim

core/src/main/scala/astraea/spark/rasterframes/util/debug/package.scala

@@ -39,37 +39,6 @@ import org.apache.spark.annotation.Experimental
  */
 package object debug {
   implicit class RasterFrameWithDebug(val self: RasterFrame)  {
-    /** Create a slippy map directory structure export of raster frame, for debugging purposes only. */
-    @Experimental
-    def debugTileExport(dest: URI, zoomLevel: Int = 8): Unit = {
-      val spark = self.sparkSession
-      implicit val sc = spark.sparkContext
-
-      val tgtCrs =  self.crs //WebMercator
-
-      val scheme = ZoomedLayoutScheme(tgtCrs)
-      val mapTransform = scheme
-        .levelForZoom(zoomLevel)
-        .layout
-        .mapTransform
-
-      val writer = new HadoopSlippyTileWriter[MultibandTile](dest.toASCIIString, "tiff")({ (key, tile) =>
-        val extent = mapTransform(key)
-        val opts = GeoTiffOptions.DEFAULT.mapWhen(_ ⇒ tile.bands.lengthCompare(3) == 0, _.copy(colorSpace = ColorSpace.RGB))
-        MultibandGeoTiff(tile, extent, tgtCrs, opts).toByteArray
-      })
-
-      /** If there's a temporal component to the key, we drop it blindly. */
-      val tlrdd: MultibandTileLayerRDD[SpatialKey] = self.toMultibandTileLayerRDD(self.tileColumns: _*) match {
-        case Left(spatial) ⇒ spatial
-        case Right(origRDD) ⇒
-          val newMD = origRDD.metadata.map(_.spatialKey)
-          val rdd = origRDD.map { case (k, v) ⇒ (k.spatialKey, v)}
-          ContextRDD(rdd, newMD)
-      }
-
-      writer.write(zoomLevel, tlrdd)
-    }
 
     /** Renders the whole schema with metadata as a JSON string. */
     def describeFullSchema: String = {

core/src/test/resources/NAIP-VA-b1.tiff

@@ -242,8 +242,6 @@ class GeoTrellisDataSourceSpec
 
       assertEqual(raster.tile, sampleGeoTiff.tile)
 
-      rf.debugTileExport(new File("target/slippy2").toURI)
-
       //GeoTiff(raster).write("target/from-split.tiff")
       // 774 x 500
     }

core/src/test/resources/NAIP-VA-b2.tiff

@@ -1,10 +1,123 @@
+/*
+ * This software is licensed under the Apache 2 license, quoted below.
+ *
+ * Copyright 2018 Astraea. Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ *     [http://www.apache.org/licenses/LICENSE-2.0]
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ *
+ *
+ */
+
 package astraea.spark.rasterframes.experimental
 
+import geotrellis.util.MethodExtensions
+import java.net.URI
+
+import astraea.spark.rasterframes._
+import astraea.spark.rasterframes.util._
+import geotrellis.proj4.WebMercator
+import geotrellis.raster.io.geotiff.tags.codes.ColorSpace
+import geotrellis.raster.io.geotiff._
+import geotrellis.raster.resample.Bilinear
+import geotrellis.raster._
+import geotrellis.raster.render.{ColorMap, ColorMaps, ColorRamps}
+import geotrellis.spark._
+import geotrellis.spark.io.slippy.HadoopSlippyTileWriter
+import geotrellis.spark.tiling.ZoomedLayoutScheme
+import org.apache.spark.annotation.Experimental
+
+import scala.util.Try
+
 /**
- *
+ * Experimental support for exporting a RasterFrame into Slippy map format.
  *
  * @since 4/10/18
  */
-class SlippyExport {
+@Experimental
+trait SlippyExport extends MethodExtensions[RasterFrame]{
+  /**
+   * Export GeoTiff tiles in a slippy map directory structure; for debugging purposes only.
+   * NB: Temporal components are ignored blindly.
+   */
+  @Experimental
+  def exportGeoTiffTiles(dest: URI): Unit = {
+    val spark = self.sparkSession
+    implicit val sc = spark.sparkContext
 
+    val tlm = self.tileLayerMetadata.widen
+    val crs = tlm.crs
+    val mapTransform = tlm.mapTransform
+
+    val writer = new HadoopSlippyTileWriter[MultibandTile](dest.toASCIIString, "tiff")({ (key, tile) =>
+      val extent = mapTransform(key)
+      // If we have exactly 3 columns, we assume RGB color space.
+      val opts = GeoTiffOptions.DEFAULT
+        .mapWhen(_ ⇒ tile.bands.lengthCompare(3) == 0,
+          _.copy(colorSpace = ColorSpace.RGB)
+        )
+      MultibandGeoTiff(tile, extent, crs, opts).toByteArray
+    })
+
+    val tlrdd: MultibandTileLayerRDD[SpatialKey] = self.toMultibandTileLayerRDD(self.tileColumns: _*) match {
+      case Left(spatial) ⇒ spatial
+      case Right(origRDD) ⇒
+        val newMD = origRDD.metadata.map(_.spatialKey)
+        val rdd = origRDD.map { case (k, v) ⇒ (k.spatialKey, v)}
+        ContextRDD(rdd, newMD)
+    }
+
+    writer.write(0, tlrdd)
+  }
+
+  /**
+   * Export tiles as a slippy map. For debugging purposes only.
+   * NB: Temporal components are ignored blindly.
+   */
+  @Experimental
+  def exportSlippyMap(dest: URI, colorMap: Option[ColorMap] = None): Unit = {
+    val spark = self.sparkSession
+    implicit val sc = spark.sparkContext
+
+    val inputRDD: MultibandTileLayerRDD[SpatialKey] = self.toMultibandTileLayerRDD(self.tileColumns: _*) match {
+      case Left(spatial) ⇒ spatial
+      case Right(origRDD) ⇒
+        val newMD = origRDD.metadata.map(_.spatialKey)
+        val rdd = origRDD.map { case (k, v) ⇒ (k.spatialKey, v)}
+        ContextRDD(rdd, newMD)
+    }
+
+    val layoutScheme = ZoomedLayoutScheme(WebMercator, tileSize = 256)
+
+    val (zoom, reprojected) = inputRDD.reproject(WebMercator, layoutScheme, Bilinear)
+
+    val writer = new HadoopSlippyTileWriter[MultibandTile](dest.toASCIIString, "png")({ (_, tile) =>
+      val png = if(colorMap.isEmpty && tile.bands.lengthCompare(3) == 0) {
+        // `Try` below is due to https://github.com/locationtech/geotrellis/issues/2621
+        tile.mapBands((_, t) ⇒ Try(t.rescale(0, 255)).getOrElse(t)).renderPng()
+      }
+      else {
+        // Are there other ways to use the other bands?
+        val selected = tile.bands.head
+        colorMap.map(m ⇒ selected.renderPng(m)).getOrElse(selected.renderPng(ColorRamps.greyscale(256)))
+      }
+      png.bytes
+    })
+
+    writer.write(zoom, reprojected)
+  }
 }
+
+object SlippyExport {
+  implicit class RasterFrameHasSlippy(val self: RasterFrame) extends SlippyExport
+}
+

core/src/test/resources/NAIP-VA-b3.tiff

@@ -28,8 +28,9 @@ import geotrellis.raster._
 import geotrellis.raster.io.geotiff.SinglebandGeoTiff
 import org.apache.spark.sql.SparkSession
 
-object Slippy {
+object SlippyExportTest {
   def main(args: Array[String]): Unit = {
+
     implicit val spark = SparkSession
       .builder()
       .master("local[*]")
@@ -39,6 +40,7 @@ object Slippy {
 
     val bands: Seq[SinglebandGeoTiff] = for (i ← 1 to 3) yield {
       TestData.readSingleband(s"NAIP-VA-b$i.tiff")
+      //s"L8-B$i-Elkton-VA.tiff")
     }
 
     val mtile = MultibandTile(bands.map(_.tile))
@@ -49,6 +51,8 @@ object Slippy {
 
     val rf = pr.toRF(64, 64)
 
-    rf.exportGeoTIFFTiles(new File("target/slippy-tiff").toURI)
+    rf.exportGeoTiffTiles(new File("target/slippy-tiff").toURI)
+
+    rf.exportSlippyMap(new File("target/slippy-png").toURI)
   }
 }