RasterFunctions

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

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

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def aggDataCells(col: Column): TypedColumn[Any, Long]

Computes the number of non-NoData cells in a column.

def aggHistogram(col: Column): TypedColumn[Any, CellHistogram]

Compute the full column aggregate floating point histogram.

def aggMean(col: Column): TypedColumn[Any, Double]

Computes the column aggregate mean.

def aggNoDataCells(col: Column): TypedColumn[Any, Long]

Computes the number of NoData cells in a column.

def aggStats(col: Column): TypedColumn[Any, CellStatistics]

Compute the full column aggregate floating point statistics.

def arrayToTile(arrayCol: Column, cols: Int, rows: Int): Column

def assembleTile(columnIndex: Column, rowIndex: Column, cellData: Column, tileCols: Column, tileRows: Column): TypedColumn[Any, Tile]

Create a Tile from a column of cell data with location indexes.

def assembleTile(columnIndex: Column, rowIndex: Column, cellData: Column, tileCols: Int, tileRows: Int, ct: CellType): TypedColumn[Any, Tile]

Create a Tile from a column of cell data with location indexes and preform cell conversion.

def boundsGeometry(bounds: Column): TypedColumn[Any, Geometry]

Convert a bounding box structure to a Geometry type.

def cellType(col: Column): TypedColumn[Any, CellType]

Extract the Tile's cell type

def convertCellType(col: Column, cellTypeName: String): Column

Change the Tile's cell type

def convertCellType(col: Column, cellType: CellType): Column

Change the Tile's cell type

def dataCells(tile: Column): TypedColumn[Any, Long]

Counts the number of non-NoData cells per Tile.

def explodeTiles(cols: Column*): Column

Create a row for each cell in Tile.

def explodeTilesSample(sampleFraction: Double, cols: Column*): Column

Create a row for each cell in Tile with random sampling (no seed).

def explodeTilesSample(sampleFraction: Double, seed: Option[Long], cols: Column*): Column

Create a row for each cell in Tile with random sampling and optional seed.

def inverseMask(sourceTile: Column, maskTile: Column): TypedColumn[Any, Tile]

Where the mask tile DOES NOT contain NODATA, replace values in the source tile with NODATA

def isNoDataTile(tile: Column): TypedColumn[Any, Boolean]

def localAdd(left: Column, right: Column): Column

Cellwise addition between two Tiles.

def localAddScalar[T](tileCol: Column, value: T)(implicit arg0: Numeric[T]): Column

Cellwise addition of a scalar to a tile.

def localAggDataCells(col: Column): TypedColumn[Any, Tile]

Compute the cellwise/local count of non-NoData cells for all Tiles in a column.

def localAggMax(col: Column): TypedColumn[Any, Tile]

Compute the cell-wise/local max operation between Tiles in a column.

def localAggMean(col: Column): TypedColumn[Any, Tile]

Compute the cellwise/local mean operation between Tiles in a column.

def localAggMin(col: Column): TypedColumn[Any, Tile]

Compute the cellwise/local min operation between Tiles in a column.

def localAggNoDataCells(col: Column): TypedColumn[Any, Tile]

Compute the cellwise/local count of NoData cells for all Tiles in a column.

def localAggStats(col: Column): Column

Compute cell-local aggregate descriptive statistics for a column of Tiles.

def localAlgebra(op: LocalTileBinaryOp, left: Column, right: Column): TypedColumn[Any, Tile]

Perform an arbitrary GeoTrellis LocalTileBinaryOp between two Tile columns.

def localDivide(left: Column, right: Column): Column

Cellwise division between two Tiles.

def localDivideScalar[T](tileCol: Column, value: T)(implicit arg0: Numeric[T]): Column

Cellwise division of a tile by a scalar.

def localEqual(left: Column, right: Column): Column

Cellwise equal to value comparison between two tiles.

def localEqualScalar[T](tileCol: Column, value: T)(implicit arg0: Numeric[T]): Column

Cellwise equal to value comparison between a tile and a scalar.

def localGreater(left: Column, right: Column): Column

Cellwise greater than value comparison between two tiles.

def localGreaterEqual(left: Column, right: Column): Column

Cellwise greater than or equal to value comparison between two tiles.

def localGreaterEqualScalar[T](tileCol: Column, value: T)(implicit arg0: Numeric[T]): Column

Cellwise greater than or equal to value comparison between a tile and a scalar.

def localGreaterScalar[T](tileCol: Column, value: T)(implicit arg0: Numeric[T]): Column

Cellwise greater than value comparison between a tile and a scalar.

def localLess(left: Column, right: Column): Column

Cellwise less than value comparison between two tiles.

def localLessEqual(left: Column, right: Column): Column

Cellwise less than or equal to value comparison between a tile and a scalar.

def localLessEqualScalar[T](tileCol: Column, value: T)(implicit arg0: Numeric[T]): Column

Cellwise less than or equal to value comparison between a tile and a scalar.

def localLessScalar[T](tileCol: Column, value: T)(implicit arg0: Numeric[T]): Column

Cellwise less than value comparison between a tile and a scalar.

def localMultiply(left: Column, right: Column): Column

Cellwise multiplication between two Tiles.

def localMultiplyScalar[T](tileCol: Column, value: T)(implicit arg0: Numeric[T]): Column

Cellwise multiplication of a tile by a scalar.

def localSubtract(left: Column, right: Column): Column

Cellwise subtraction between two Tiles.

def localSubtractScalar[T](tileCol: Column, value: T)(implicit arg0: Numeric[T]): Column

Cellwise subtraction of a scalar from a tile.

def localUnequal(left: Column, right: Column): Column

Cellwise inequality comparison between two tiles.

def localUnequalScalar[T](tileCol: Column, value: T)(implicit arg0: Numeric[T]): Column

Cellwise inequality comparison between a tile and a scalar.

def makeConstantTile(value: Number, cols: Int, rows: Int, cellType: String): TypedColumn[Any, Tile]

Constructor for constant tile column

def maskByValue(sourceTile: Column, maskTile: Column, maskValue: Column): TypedColumn[Any, Tile]

Where the mask tile equals the mask value, replace values in the source tile with NODATA

def noDataCells(tile: Column): TypedColumn[Any, Long]

Counts the number of NoData cells per Tile.

def normalizedDifference(left: Column, right: Column): TypedColumn[Any, Tile]

Compute the normalized difference of two tile columns

def renderAscii(col: Column): TypedColumn[Any, String]

Render Tile as ASCII string for debugging purposes.

def reprojectGeometry(sourceGeom: Column, srcCRS: CRS, dstCRS: CRS): TypedColumn[Any, Geometry]

Reproject a column of geometry from one CRS to another.

def tileDimensions(col: Column): Column

Query the number of (cols, rows) in a Tile.

def tileHistogram(col: Column): TypedColumn[Any, CellHistogram]

Compute TileHistogram of Tile values.

def tileMax(col: Column): TypedColumn[Any, Double]

Compute the maximum cell value in tile.

def tileMean(col: Column): TypedColumn[Any, Double]

Compute the Tile-wise mean

def tileMin(col: Column): TypedColumn[Any, Double]

Compute the minimum cell value in tile.

def tileOnes(cols: Int, rows: Int, cellType: String = "float64"): TypedColumn[Any, Tile]

Alias for column of constant tiles of one

def tileStats(col: Column): TypedColumn[Any, CellStatistics]

Compute statistics of Tile values.

def tileSum(col: Column): TypedColumn[Any, Double]

Compute the Tile-wise sum

def tileZeros(cols: Int, rows: Int, cellType: String = "float64"): TypedColumn[Any, Tile]

Alias for column of constant tiles of zero

def withNoData(col: Column, nodata: Double): Column

Assign a NoData value to the Tiles.