geotrellis.engine.op.global.GlobalRasterSourceMethods.scala Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of geotrellis-engine_2.10 Show documentation

GeoTrellis is an open source geographic data processing engine for high performance applications.

There is a newer version: 0.10.3

Show newest version

/*
 * Copyright (c) 2014 Azavea.
 *
 * 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 geotrellis.engine.op.global

import geotrellis.engine._
import geotrellis.raster._
import geotrellis.raster.costdistance.CostDistance
import geotrellis.raster.regiongroup.RegionGroupOptions
import geotrellis.raster.viewshed.{ApproxViewshed, Viewshed}
import geotrellis.vector._

@deprecated("geotrellis-engine has been deprecated", "Geotrellis Version 0.10")
trait GlobalRasterSourceMethods extends RasterSourceMethods {
  def costDistance(points: Seq[(Int, Int)]) =
    rasterSource.global(CostDistance(_, points))

  def rescale(newMin: Int, newMax: Int) =
    rasterSource.global(_.rescale(newMin, newMax))

  def rescale(newMin: Double, newMax: Double) =
    rasterSource.global(_.rescale(newMin, newMax))

  def toVector() =
    rasterSource.converge.mapOp { tileOp =>
      (tileOp, rasterSource.rasterDefinition).map { (tile, rd) =>
        tile.toVector(rd.rasterExtent.extent)
      }
    }

  def regionGroup(options: RegionGroupOptions = RegionGroupOptions.default) =
    rasterSource.converge.map(_.regionGroup(options))

  def viewshed(p: Point, exact: Boolean = false) =
    if(exact)
      rasterSource.globalOp { r =>
        rasterSource.rasterDefinition.map { rd =>
          val (col, row) = rd.rasterExtent.mapToGrid(p.x, p.y)
          Viewshed(r, col, row)
        }
      }
    else
      rasterSource.globalOp { r =>
        rasterSource.rasterDefinition.map { rd =>
          val (col, row) = rd.rasterExtent.mapToGrid(p.x, p.y)
          ApproxViewshed(r, col, row)
        }
      }

  def viewshedOffsets(p: Point, exact: Boolean = false) =
    if(exact)
      rasterSource.globalOp { r =>
        rasterSource.rasterDefinition.map { rd =>
          val (col, row) = rd.rasterExtent.mapToGrid(p.x, p.y)
          Viewshed.offsets(r, col, row)
        }
      }
    else
      rasterSource.globalOp { r =>
        rasterSource.rasterDefinition.map { rd =>
          val (col, row) = rd.rasterExtent.mapToGrid(p.x, p.y)
          ApproxViewshed.offsets(r, col, row)
        }
      }
}