TiledRasterData

abstract def alloc(cols: Int, rows: Int): MutableRasterData

abstract def getTile(col: Int, row: Int): RasterData

Get a RasterData instance for a particular tile.

abstract def getTileOp(rl: ResolutionLayout, c: Int, r: Int): Op[Raster]

Return an operation that when run will yield a particular tile's raster.

abstract def getType: RasterType

abstract def tileLayout: TileLayout

Returns the particular layout of this TiledRasterData's tiles.

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ->[B](y: B): (TiledRasterData, B)

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def asArray: Some[IntArrayRasterData]

Return the current RasterData as an array.

final def asInstanceOf[T0]: T0

def cellToTile(col: Int, row: Int): (Int, Int)

For a given grid coordinate, return the applicable tile coordinate.

def clone(): AnyRef

def cols: Int

def combine(other: RasterData)(f: (Int, Int) ⇒ Int): LazyTiledCombine

Combine two RasterData's cells into new cells using the given integer function.

def combineDouble(other: RasterData)(f: (Double, Double) ⇒ Double): LazyTiledCombine

Combine two RasterData's cells into new cells using the given double function.

def convert(typ: RasterType): RasterData

def copy: TiledRasterData

def ensuring(cond: (TiledRasterData) ⇒ Boolean, msg: ⇒ Any): TiledRasterData

def ensuring(cond: (TiledRasterData) ⇒ Boolean): TiledRasterData

def ensuring(cond: Boolean, msg: ⇒ Any): TiledRasterData

def ensuring(cond: Boolean): TiledRasterData

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def force: Option[MutableRasterData]

Return the current RasterData values as a strict (calculated) ArrayRasterData.

def foreach(f: (Int) ⇒ Unit): Unit

For every cell in the given raster, run the given integer function.

def foreachDouble(f: (Double) ⇒ Unit): Unit

For every cell in the given raster, run the given double function.

def formatted(fmtstr: String): String

def get(col: Int, row: Int): Int

Get a particular (x, y) cell's integer value.

final def getClass(): Class[_]

def getDouble(col: Int, row: Int): Double

Get a particular (x, y) cell's double value.

def getTileList(re: RasterExtent): List[Raster]

Function like getTiles but returns a list instead.

def getTileOpList(re: RasterExtent, clipExtent: Polygon[_]): List[Op[Raster]]

Return a list of operations that load a tile's raster, filtered by a clip extent.

def getTileOpList(re: RasterExtent): List[Op[Raster]]

Return a list of operations; each operation will load a tile's raster.

def getTileRaster(rl: ResolutionLayout, c: Int, r: Int): Raster

Given a resolution layout, and a particular tile's column/row, return a Raster corresponding to that tile.

def getTiles(re: RasterExtent): Array[Raster]

Given a raster extent (geographical area plus resolution) return an array of Rasters which represent that area as tiles.

def hashCode(): Int

def isFloat: Boolean

final def isInstanceOf[T0]: Boolean

def length: Int

def lengthLong: Long

def map(f: (Int) ⇒ Int): TiledRasterData

Map each cell in the given raster to a new one, using the given function.

def mapDouble(f: (Double) ⇒ Double): TiledRasterData

Map each cell in the given raster to a new one, using the given function.

def mapIfSet(f: (Int) ⇒ Int): TiledRasterData

Similar to map, except that this method passes through "nodata" cells without calling the provided function.

def mapIfSetDouble(f: (Double) ⇒ Double): TiledRasterData

Similar to map, except that this method passes through "nodata" cells without calling the provided function.

def mutable: Option[MutableRasterData]

Return a mutable version of the current raster.

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def pixelCols: Int

def pixelRows: Int

def rows: Int

final def synchronized[T0](arg0: ⇒ T0): T0

def tileCols: Int

def tileRows: Int

def toString(): String

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def withinBounds(col: Int, row: Int): Boolean

* Returns true if (col,row) is a valid tile in this tileset.

def →[B](y: B): (TiledRasterData, B)

val self: Any

val self: Any

def x: TiledRasterData

def x: TiledRasterData