Add mosaic tile support for collections

.jvmopts

@@ -0,0 +1,3 @@
+-Xms512m
+-Xmx3g
+-Xss2m

application/src/main/resources/migrations/V14__add_mosaic_definitions_table.sql

@@ -0,0 +1,14 @@
+CREATE TABLE mosaic_definitions (
+    id uuid primary key,
+    collection text references collections(id) not null,
+    mosaic jsonb not null,
+    histograms jsonb,
+    created_at timestamp with time zone not null,
+    serial_id serial not null
+);
+
+CREATE INDEX IF NOT EXISTS mosaic_definition_collection_idx ON mosaic_definitions (collection);
+
+CREATE INDEX mosaic_definitions_serial_id_idx ON mosaic_definitions (serial_id);
+
+CREATE INDEX mosaic_definitions_created_at_idx ON mosaic_definitions (created_at);

application/src/main/resources/migrations/V15__add_item_asset_histogram_table.sql

@@ -0,0 +1,7 @@
+CREATE TABLE item_asset_histograms (
+    item_id text not null references collection_items (id),
+    asset_name text not null,
+    histograms jsonb not null
+);
+
+CREATE INDEX item_asset_histograms_idx ON item_asset_histograms (item_id, asset_name);

application/src/main/scala/com/azavea/franklin/api/Server.scala

@@ -31,7 +31,6 @@ import sttp.tapir.docs.openapi.OpenAPIDocsInterpreter
 import sttp.tapir.openapi.circe.yaml._
 import sttp.tapir.swagger.http4s.SwaggerHttp4s
 
-import scala.concurrent.ExecutionContext
 import scala.concurrent.ExecutionContext
 
 import java.util.concurrent.Executors
@@ -82,6 +81,7 @@ $$$$
       Some(`application/json`),
       Some("Welcome to Franklin")
     )
+    implicit val logger = Slf4jLogger.getLogger[IO]
     AsyncHttpClientCatsBackend.resource[IO]() flatMap { implicit backend =>
       for {
         connectionEc  <- ExecutionContexts.fixedThreadPool[IO](2)
@@ -94,7 +94,6 @@ $$$$
           connectionEc,
           Blocker.liftExecutionContext(transactionEc)
         )
-        implicit0(logger: log4cats.Logger[IO]) = Slf4jLogger.getLogger[IO]
         collectionItemEndpoints = new CollectionItemEndpoints[IO](
           apiConfig.defaultLimit,
           apiConfig.enableTransactions,

application/src/main/scala/com/azavea/franklin/api/endpoints/CollectionEndpoints.scala

@@ -2,15 +2,19 @@ package com.azavea.franklin.api.endpoints
 
 import cats.effect.Concurrent
 import com.azavea.franklin.api.schemas._
+import com.azavea.franklin.datamodel.MosaicDefinition
 import com.azavea.franklin.error.NotFound
 import com.azavea.stac4s.StacCollection
 import io.circe._
 import sttp.capabilities.fs2.Fs2Streams
+import sttp.model.StatusCode
 import sttp.model.StatusCode.{NotFound => NF}
 import sttp.tapir._
 import sttp.tapir.generic.auto._
 import sttp.tapir.json.circe._
 
+import java.util.UUID
+
 class CollectionEndpoints[F[_]: Concurrent](
     enableTransactions: Boolean,
     enableTiles: Boolean,
@@ -61,7 +65,50 @@ class CollectionEndpoints[F[_]: Concurrent](
       .description("A collection's tile endpoints")
       .name("collectionTiles")
 
+  val createMosaic
+      : Endpoint[(String, MosaicDefinition), NotFound, MosaicDefinition, Fs2Streams[F]] =
+    base.post
+      .in(path[String] / "mosaic")
+      .in(jsonBody[MosaicDefinition])
+      .out(jsonBody[MosaicDefinition])
+      .errorOut(
+        oneOf(statusMapping(NF, jsonBody[NotFound].description("not found")))
+      )
+      .description("Create a mosaic from items in this collection")
+      .name("collectionMosaicPost")
+
+  val getMosaic: Endpoint[(String, UUID), NotFound, MosaicDefinition, Fs2Streams[F]] =
+    base.get
+      .in(path[String] / "mosaic" / path[UUID])
+      .out(jsonBody[MosaicDefinition])
+      .errorOut(
+        oneOf(
+          statusMapping(NF, jsonBody[NotFound].description("Mosaic does not exist in collection"))
+        )
+      )
+      .description("Fetch a mosaic defined for this collection")
+      .name("collectionMosaicGet")
+
+  val deleteMosaic: Endpoint[(String, UUID), NotFound, Unit, Fs2Streams[F]] =
+    base.delete
+      .in(path[String] / "mosaic" / path[UUID])
+      .out(statusCode(StatusCode.NoContent))
+      .errorOut(
+        oneOf(
+          statusMapping(NF, jsonBody[NotFound].description("Mosaic does not exist in collection"))
+        )
+      )
+
+  val listMosaics: Endpoint[String, NotFound, List[MosaicDefinition], Fs2Streams[F]] =
+    base.get
+      .in(path[String] / "mosaic")
+      .out(jsonBody[List[MosaicDefinition]])
+      .errorOut(
+        oneOf(statusMapping(NF, jsonBody[NotFound].description("Collection does not exist")))
+      )
+
   val endpoints = List(collectionsList, collectionUnique) ++ {
-    if (enableTiles) List(collectionTiles) else Nil
+    if (enableTiles) List(collectionTiles, createMosaic, getMosaic, deleteMosaic, listMosaics)
+    else Nil
   } ++ { if (enableTransactions) List(createCollection, deleteCollection) else Nil }
 }

application/src/main/scala/com/azavea/franklin/api/endpoints/TileEndpoints.scala

@@ -1,6 +1,7 @@
 package com.azavea.franklin.api.endpoints
 
 import cats.effect.Concurrent
+import com.azavea.franklin.datamodel.CollectionMosaicRequest
 import com.azavea.franklin.datamodel.{
   ItemRasterTileRequest,
   MapboxVectorTileFootprintRequest,
@@ -17,16 +18,18 @@ import sttp.tapir.codec.refined._
 import sttp.tapir.generic.auto._
 import sttp.tapir.json.circe._
 
+import java.util.UUID
+
 class TileEndpoints[F[_]: Concurrent](enableTiles: Boolean, pathPrefix: Option[String]) {
 
   val basePath = baseFor(pathPrefix, "tiles" / "collections")
   val zxyPath  = path[Int] / path[Int] / path[Int]
 
   val itemRasterTilePath: EndpointInput[(String, String, Int, Int, Int)] =
-    (basePath / path[String] / "items" / path[String] / "WebMercatorQuad" / zxyPath)
+    basePath / path[String] / "items" / path[String] / "WebMercatorQuad" / zxyPath
 
   val collectionFootprintTilePath: EndpointInput[(String, Int, Int, Int)] =
-    (basePath / path[String] / "footprint" / "WebMercatorQuad" / zxyPath)
+    basePath / path[String] / "footprint" / "WebMercatorQuad" / zxyPath
 
   val collectionFootprintTileParameters
       : EndpointInput[(String, Int, Int, Int, List[NonEmptyString])] =
@@ -35,6 +38,9 @@ class TileEndpoints[F[_]: Concurrent](enableTiles: Boolean, pathPrefix: Option[S
   val collectionFootprintTileJsonPath: EndpointInput[String] =
     (basePath / path[String] / "footprint" / "tile-json")
 
+  val collectionMosaicTilePath: EndpointInput[(String, UUID, Int, Int, Int)] =
+    (basePath / path[String] / "mosaic" / path[UUID] / "WebMercatorQuad" / zxyPath)
+
   val itemRasterTileParameters: EndpointInput[ItemRasterTileRequest] =
     itemRasterTilePath
       .and(query[String]("asset"))
@@ -46,6 +52,16 @@ class TileEndpoints[F[_]: Concurrent](enableTiles: Boolean, pathPrefix: Option[S
       .and(query[Option[NonNegInt]]("singleBand"))
       .mapTo(ItemRasterTileRequest)
 
+  val collectionRasterTileParameters: EndpointInput[CollectionMosaicRequest] =
+    collectionMosaicTilePath
+      .and(query[Option[Int]]("redBand"))
+      .and(query[Option[Int]]("greenBand"))
+      .and(query[Option[Int]]("blueBand"))
+      .and(query[Option[Quantile]]("upperQuantile"))
+      .and(query[Option[Quantile]]("lowerQuantile"))
+      .and(query[Option[NonNegInt]]("singleBand"))
+      .mapTo(CollectionMosaicRequest)
+
   val itemRasterTileEndpoint
       : Endpoint[ItemRasterTileRequest, NotFound, Array[Byte], Fs2Streams[F]] =
     endpoint.get
@@ -74,9 +90,25 @@ class TileEndpoints[F[_]: Concurrent](enableTiles: Boolean, pathPrefix: Option[S
       .description("TileJSON representation of this collection's footprint tiles")
       .name("collectionFootprintTileJSON")
 
+  val collectionMosaicEndpoint
+      : Endpoint[CollectionMosaicRequest, Unit, Array[Byte], Fs2Streams[F]] =
+    endpoint.get
+      .in(collectionRasterTileParameters)
+      .out(rawBinaryBody[Array[Byte]])
+      .out(header("content-type", "image/png"))
+      .description(
+        "Raster tile endpoint for collection mosaic"
+      )
+      .name("collectionMosaicTiles")
+
   val endpoints = enableTiles match {
     case true =>
-      List(itemRasterTileEndpoint, collectionFootprintTileEndpoint, collectionFootprintTileJson)
+      List(
+        itemRasterTileEndpoint,
+        collectionFootprintTileEndpoint,
+        collectionFootprintTileJson,
+        collectionMosaicEndpoint
+      )
     case _ => List.empty
   }
 }

application/src/main/scala/com/azavea/franklin/api/implicits/package.scala

@@ -1,6 +1,7 @@
 package com.azavea.franklin.api
 
 import com.azavea.franklin.api.commands.ApiConfig
+import com.azavea.franklin.datamodel.MosaicDefinition
 import com.azavea.stac4s._
 import eu.timepit.refined.types.string.NonEmptyString
 
@@ -87,9 +88,29 @@ package object implicits {
       collection.copy(links = tileLink :: collection.links)
     }
 
+    def addMosaicLinks(apiHost: String, mosaicDefinitions: List[MosaicDefinition]) = {
+      val encodedCollectionId = URLEncoder.encode(collection.id, StandardCharsets.UTF_8.toString)
+      val mosaicLinks = mosaicDefinitions map { mosaicDefinition =>
+        StacLink(
+          s"$apiHost/collections/$encodedCollectionId/mosaic/${mosaicDefinition.id}",
+          StacLinkType.VendorLinkType("mosaic-definition"),
+          Some(`application/json`),
+          mosaicDefinition.description orElse Some(s"Mosaic ${mosaicDefinition.id}")
+        )
+      }
+      collection.copy(links = collection.links ++ mosaicLinks)
+    }
+
     def maybeAddTilesLink(enableTiles: Boolean, apiHost: String) =
       if (enableTiles) addTilesLink(apiHost) else collection
 
+    def maybeAddMosaicLinks(
+        enableTiles: Boolean,
+        apiHost: String,
+        mosaicDefinitions: List[MosaicDefinition]
+    ) =
+      if (enableTiles) addMosaicLinks(apiHost, mosaicDefinitions) else collection
+
     def updateLinksWithHost(apiConfig: ApiConfig) = {
       val updatedLinks = collection.links.map(_.addServerHost(apiConfig))
       collection.copy(links = updatedLinks)