rasterframes

def CENTER_COLUMN: TypedColumn[Any, Point]

val COLUMN_INDEX_COLUMN: TypedColumn[Any, Int]

def CRS_COLUMN: TypedColumn[Any, CRS]

def EXTENT_COLUMN: TypedColumn[Any, Extent]

def GEOMETRY_COLUMN: TypedColumn[Any, Polygon]

val METADATA_COLUMN: TypedColumn[Any, Map[String, String]]

final val NOMINAL_TILE_DIMS: TileDimensions

final val NOMINAL_TILE_SIZE: Int

val PATH_COLUMN: TypedColumn[Any, String]

def PROJECTED_EXTENT_COLUMN: TypedColumn[Any, ProjectedExtent]

def PROJECTED_RASTER_COLUMN: TypedColumn[Any, ProjectedRasterTile]

val ROW_INDEX_COLUMN: TypedColumn[Any, Int]

def RasterSourceType: RasterSourceUDT

val SPATIAL_INDEX_COLUMN: TypedColumn[Any, Long]

val SPATIAL_KEY_COLUMN: TypedColumn[Any, SpatialKey]

val TEMPORAL_KEY_COLUMN: TypedColumn[Any, TemporalKey]

def TILE_COLUMN: TypedColumn[Any, Tile]

val TILE_FEATURE_DATA_COLUMN: Column

val TIMESTAMP_COLUMN: TypedColumn[Any, Timestamp]

def TileType: TileUDT

implicit def cellContextEncoder: ExpressionEncoder[CellContext]

implicit def cellHistEncoder: ExpressionEncoder[CellHistogram]

implicit def cellSizeEncoder: ExpressionEncoder[CellSize]

implicit def cellStatsEncoder: ExpressionEncoder[CellStatistics]

implicit def cellTypeEncoder: ExpressionEncoder[CellType]

implicit def cellsEncoder: ExpressionEncoder[Cells]

implicit def crsEncoder: ExpressionEncoder[CRS]

package datasource

Module utilities

implicit def envelopeEncoder: ExpressionEncoder[Envelope]

def expressionEncoder[T](implicit arg0: scala.reflect.api.JavaUniverse.TypeTag[T]): ExpressionEncoder[T]

implicit def extentEncoder: ExpressionEncoder[Extent]

implicit def extentTilePairEncoder: Encoder[(ProjectedExtent, Tile)]

def geomCollLit(g: GeometryCollection): TypedColumn[Any, GeometryCollection]

def geomLit(g: Geometry): TypedColumn[Any, Geometry]

def initRF(sqlContext: SQLContext): Unit

def isCellTrue(v: Int): Boolean

def isCellTrue(v: Double): Boolean

implicit def jtsGeometryCollectionEncoder: Encoder[GeometryCollection]

implicit def jtsGeometryEncoder: Encoder[Geometry]

implicit def jtsLineStringEncoder: Encoder[LineString]

implicit def jtsMultiLineStringEncoder: Encoder[MultiLineString]

implicit def jtsMultiPointEncoder: Encoder[MultiPoint]

implicit def jtsMultiPolygonEncoder: Encoder[MultiPolygon]

implicit def jtsPointEncoder: Encoder[Point]

implicit def jtsPolygonEncoder: Encoder[Polygon]

implicit def layoutDefinitionEncoder: ExpressionEncoder[LayoutDefinition]

def lineLit(g: LineString): TypedColumn[Any, LineString]

implicit def localCellStatsEncoder: ExpressionEncoder[LocalCellStatistics]

lazy val logger: Logger

def mLineLit(g: MultiLineString): TypedColumn[Any, MultiLineString]

def mPointLit(g: MultiPoint): TypedColumn[Any, MultiPoint]

def mPolygonLit(g: MultiPolygon): TypedColumn[Any, MultiPolygon]

def pointLit(g: Point): TypedColumn[Any, Point]

def polygonLit(g: Polygon): TypedColumn[Any, Polygon]

implicit def projectedExtentEncoder: ExpressionEncoder[ProjectedExtent]

implicit def rasterEncoder: ExpressionEncoder[Raster[Tile]]

def rf_abs(tileCol: Column): TypedColumn[Any, Tile]

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

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

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

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

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

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

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

def rf_agg_local_stats(col: Column): TypedColumn[Any, LocalCellStatistics]

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

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

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

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

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

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

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

def rf_convert_cell_type(col: Column, cellTypeName: String): TypedColumn[Any, Tile]

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

def rf_crs(col: Column): TypedColumn[Any, CRS]

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

def rf_dimensions(col: Column): TypedColumn[Any, TileDimensions]

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

def rf_exp(tileCol: Column): TypedColumn[Any, Tile]

def rf_exp10(tileCol: Column): TypedColumn[Any, Tile]

def rf_exp2(tileCol: Column): TypedColumn[Any, Tile]

def rf_explode_tiles(cols: Column*): Column

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

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

def rf_expm1(tileCol: Column): TypedColumn[Any, Tile]

def rf_extent(col: Column): TypedColumn[Any, Extent]

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

def rf_geometry(raster: Column): TypedColumn[Any, Geometry]

def rf_identity(tileCol: Column): TypedColumn[Any, Tile]

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

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

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

def rf_local_add[T](tileCol: Column, value: T)(implicit arg0: Numeric[T]): TypedColumn[Any, Tile]

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

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

def rf_local_divide[T](tileCol: Column, value: T)(implicit arg0: Numeric[T]): TypedColumn[Any, Tile]

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

def rf_local_equal[T](tileCol: Column, value: T)(implicit arg0: Numeric[T]): TypedColumn[Any, Tile]

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

def rf_local_greater[T](tileCol: Column, value: T)(implicit arg0: Numeric[T]): TypedColumn[Any, Tile]

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

def rf_local_greater_equal[T](tileCol: Column, value: T)(implicit arg0: Numeric[T]): TypedColumn[Any, Tile]

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

def rf_local_less[T](tileCol: Column, value: T)(implicit arg0: Numeric[T]): TypedColumn[Any, Tile]

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

def rf_local_less_equal[T](tileCol: Column, value: T)(implicit arg0: Numeric[T]): TypedColumn[Any, Tile]

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

def rf_local_multiply[T](tileCol: Column, value: T)(implicit arg0: Numeric[T]): TypedColumn[Any, Tile]

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

def rf_local_subtract[T](tileCol: Column, value: T)(implicit arg0: Numeric[T]): TypedColumn[Any, Tile]

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

def rf_local_unequal[T](tileCol: Column, value: T)(implicit arg0: Numeric[T]): TypedColumn[Any, Tile]

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

def rf_log(tileCol: Column): TypedColumn[Any, Tile]

def rf_log10(tileCol: Column): TypedColumn[Any, Tile]

def rf_log1p(tileCol: Column): TypedColumn[Any, Tile]

def rf_log2(tileCol: Column): TypedColumn[Any, Tile]

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

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

def rf_make_ones_tile(cols: Int, rows: Int, cellTypeName: String): TypedColumn[Any, Tile]

def rf_make_ones_tile(cols: Int, rows: Int, cellType: CellType): TypedColumn[Any, Tile]

def rf_make_zeros_tile(cols: Int, rows: Int, cellTypeName: String): TypedColumn[Any, Tile]

def rf_make_zeros_tile(cols: Int, rows: Int, cellType: CellType): TypedColumn[Any, Tile]

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

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

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

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

def rf_rasterize(geometry: Column, bounds: Column, value: Column, cols: Column, rows: Column): TypedColumn[Any, Tile]

def rf_rasterize(geometry: Column, bounds: Column, value: Column, cols: Int, rows: Int): TypedColumn[Any, Tile]

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

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

def rf_resample(tileCol: Column, factorCol: Column): TypedColumn[Any, Tile]

def rf_resample[T](tileCol: Column, factorValue: T)(implicit arg0: Numeric[T]): TypedColumn[Any, Tile]

def rf_round(tileCol: Column): TypedColumn[Any, Tile]

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

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

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

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

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

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

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

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

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

def rf_with_no_data(col: Column, nodata: Double): TypedColumn[Any, Tile]

implicit def singlebandTileEncoder: ExpressionEncoder[Tile]

implicit def spaceTimeKeyEncoder: ExpressionEncoder[SpaceTimeKey]

implicit def spatialKeyEncoder: ExpressionEncoder[SpatialKey]

def st_aggregateDistanceSphere(geomSeq: Column): TypedColumn[Any, Double]

def st_antimeridianSafeGeom(geom: Column): TypedColumn[Any, Geometry]

def st_area(geom: Column): TypedColumn[Any, Double]

def st_asBinary(geom: Column): TypedColumn[Any, Array[Byte]]

def st_asGeoJSON(geom: Column): TypedColumn[Any, String]

def st_asLatLonText(point: Column): TypedColumn[Any, String]

def st_asText(geom: Column): TypedColumn[Any, String]

def st_boundary(geom: Column): TypedColumn[Any, Geometry]

def st_bufferPoint(geom: Column, buffer: Double): TypedColumn[Any, Geometry]

def st_bufferPoint(geom: Column, buffer: Column): TypedColumn[Any, Geometry]

def st_byteArray(str: Column): TypedColumn[Any, Array[Byte]]

def st_castToGeometry(geom: Column): TypedColumn[Any, Geometry]

def st_castToLineString(geom: Column): TypedColumn[Any, LineString]

def st_castToPoint(geom: Column): TypedColumn[Any, Point]

def st_castToPolygon(geom: Column): TypedColumn[Any, Polygon]

def st_centroid(geom: Column): TypedColumn[Any, Point]

def st_closestPoint(left: Column, right: Column): TypedColumn[Any, Point]

def st_contains(left: Column, right: Column): TypedColumn[Any, Boolean]

def st_coordDim(geom: Column): TypedColumn[Any, Integer]

def st_covers(left: Column, right: Column): TypedColumn[Any, Boolean]

def st_crosses(left: Column, right: Column): TypedColumn[Any, Boolean]

def st_dimension(geom: Column): TypedColumn[Any, Integer]

def st_disjoint(left: Column, right: Column): TypedColumn[Any, Boolean]

def st_distance(left: Column, right: Column): TypedColumn[Any, Double]

def st_distanceSphere(left: Column, right: Column): TypedColumn[Any, Double]

def st_envelope(geom: Column): TypedColumn[Any, Geometry]

def st_equals(left: Column, right: Column): TypedColumn[Any, Boolean]

def st_extent(col: Column): TypedColumn[Any, Extent]

def st_exteriorRing(geom: Column): TypedColumn[Any, LineString]

def st_geoHash(geom: Column, precision: Int): TypedColumn[Any, String]

def st_geoHash(geom: Column, precision: Column): TypedColumn[Any, String]

def st_geomFromGeoHash(geohash: Column, precision: Int): TypedColumn[Any, Geometry]

def st_geomFromGeoHash(geohash: Column, precision: Column): TypedColumn[Any, Geometry]

def st_geomFromWKB(wkb: Array[Byte]): TypedColumn[Any, Geometry]

def st_geomFromWKB(wkb: Column): TypedColumn[Any, Geometry]

def st_geomFromWKT(wkt: String): TypedColumn[Any, Geometry]

def st_geomFromWKT(wkt: Column): TypedColumn[Any, Geometry]

def st_geometry(extent: Column): TypedColumn[Any, Geometry]

def st_geometryN(geom: Column, n: Column): TypedColumn[Any, Geometry]

def st_geometryType(geom: Column): TypedColumn[Any, String]

def st_interiorRingN(geom: Column, n: Column): TypedColumn[Any, Geometry]

def st_intersects(left: Column, right: Column): TypedColumn[Any, Boolean]

def st_isClosed(geom: Column): TypedColumn[Any, Boolean]

def st_isCollection(geom: Column): TypedColumn[Any, Boolean]

def st_isEmpty(geom: Column): TypedColumn[Any, Boolean]

def st_isRing(geom: Column): TypedColumn[Any, Boolean]

def st_isSimple(geom: Column): TypedColumn[Any, Boolean]

def st_isValid(geom: Column): TypedColumn[Any, Boolean]

def st_length(geom: Column): TypedColumn[Any, Double]

def st_lengthSphere(line: Column): TypedColumn[Any, Double]

def st_lineFromText(wkt: String): TypedColumn[Any, LineString]

def st_lineFromText(wkt: Column): TypedColumn[Any, LineString]

def st_mLineFromText(wkt: String): TypedColumn[Any, MultiLineString]

def st_mLineFromText(wkt: Column): TypedColumn[Any, MultiLineString]

def st_mPointFromText(wkt: String): TypedColumn[Any, MultiPoint]

def st_mPointFromText(wkt: Column): TypedColumn[Any, MultiPoint]

def st_mPolyFromText(wkt: String): TypedColumn[Any, MultiPolygon]

def st_mPolyFromText(wkt: Column): TypedColumn[Any, MultiPolygon]

def st_makeBBOX(lowerX: Double, lowerY: Double, upperX: Double, upperY: Double): TypedColumn[Any, Geometry]

def st_makeBBOX(lowerX: Column, lowerY: Column, upperX: Column, upperY: Column): TypedColumn[Any, Geometry]

def st_makeBox2D(lowerLeft: Point, upperRight: Point): TypedColumn[Any, Geometry]

def st_makeBox2D(lowerLeft: Column, upperRight: Column): TypedColumn[Any, Geometry]

def st_makeLine(pointSeq: Seq[Point]): TypedColumn[Any, LineString]

def st_makeLine(pointSeq: Column): TypedColumn[Any, LineString]

def st_makePoint(x: Double, y: Double): TypedColumn[Any, Point]

def st_makePoint(x: Column, y: Column): TypedColumn[Any, Point]

def st_makePointM(x: Double, y: Double, m: Double): TypedColumn[Any, Point]

def st_makePointM(x: Column, y: Column, m: Column): TypedColumn[Any, Point]

def st_makePolygon(lineString: LineString): TypedColumn[Any, Polygon]

def st_makePolygon(lineString: Column): TypedColumn[Any, Polygon]

def st_numGeometries(geom: Column): TypedColumn[Any, Integer]

def st_numPoints(geom: Column): TypedColumn[Any, Integer]

def st_overlaps(left: Column, right: Column): TypedColumn[Any, Boolean]

def st_point(x: Double, y: Double): TypedColumn[Any, Point]

def st_point(x: Column, y: Column): TypedColumn[Any, Point]

def st_pointFromGeoHash(geohash: Column, precision: Int): TypedColumn[Any, Point]

def st_pointFromGeoHash(geohash: Column, precision: Column): TypedColumn[Any, Point]

def st_pointFromText(wkt: String): TypedColumn[Any, Point]

def st_pointFromText(wkt: Column): TypedColumn[Any, Point]

def st_pointFromWKB(wkb: Array[Byte]): TypedColumn[Any, Point]

def st_pointFromWKB(wkb: Column): TypedColumn[Any, Point]

def st_pointN(geom: Column, n: Column): TypedColumn[Any, Point]

def st_polygon(lineString: LineString): TypedColumn[Any, Polygon]

def st_polygon(lineString: Column): TypedColumn[Any, Polygon]

def st_polygonFromText(wkt: String): TypedColumn[Any, Polygon]

def st_polygonFromText(wkt: Column): TypedColumn[Any, Polygon]

def st_relate(left: Column, right: Column): TypedColumn[Any, String]

def st_relateBool(left: Column, right: Column, pattern: Column): TypedColumn[Any, Boolean]

def st_reproject(sourceGeom: Column, srcCRSCol: Column, dstCRSCol: Column): TypedColumn[Any, Geometry]

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

def st_reproject(sourceGeom: Column, srcCRSCol: Column, dstCRS: CRS): TypedColumn[Any, Geometry]

def st_reproject(sourceGeom: Column, srcCRS: CRS, dstCRSCol: Column): TypedColumn[Any, Geometry]

def st_touches(left: Column, right: Column): TypedColumn[Any, Boolean]

def st_translate(geom: Column, deltaX: Double, deltaY: Double): TypedColumn[Any, Geometry]

def st_translate(geom: Column, deltaX: Column, deltaY: Column): TypedColumn[Any, Geometry]

def st_within(left: Column, right: Column): TypedColumn[Any, Boolean]

def st_x(geom: Column): TypedColumn[Any, Float]

def st_y(geom: Column): TypedColumn[Any, Float]

implicit def stkBoundsEncoder: ExpressionEncoder[KeyBounds[SpaceTimeKey]]

implicit def strMapEncoder: ExpressionEncoder[Map[String, String]]

implicit def temporalKeyEncoder: ExpressionEncoder[TemporalKey]

implicit def temporalProjectedExtentEncoder: ExpressionEncoder[TemporalProjectedExtent]

implicit def tileContextEncoder: ExpressionEncoder[TileContext]

implicit def tileDataContextEncoder: ExpressionEncoder[TileDataContext]

implicit def tileLayerMetadataEncoder[K](implicit arg0: scala.reflect.api.JavaUniverse.TypeTag[K]): ExpressionEncoder[TileLayerMetadata[K]]

implicit def tilelayoutEncoder: ExpressionEncoder[TileLayout]

implicit def timestampEncoder: ExpressionEncoder[Timestamp]

implicit def uriEncoder: ExpressionEncoder[URI]

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

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

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

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

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

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

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

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

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

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

def convertCellType(col: Column, cellTypeName: String): TypedColumn[Any, Tile]

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

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

def explodeTiles(cols: Column*): Column

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

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

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

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

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

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

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

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

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

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

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

def localAggStats(col: Column): Column

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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