rasterframes

def BOUNDS_COLUMN: TypedColumn[Any, Polygon]

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]

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

final val NOMINAL_TILE_SIZE: Int

val ROW_INDEX_COLUMN: TypedColumn[Any, Int]

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 agg_approx_histogram(col: Column): TypedColumn[Any, CellHistogram]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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]

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

implicit def cellsEncoder: ExpressionEncoder[Cells]

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

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

implicit def crsEncoder: ExpressionEncoder[CRS]

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

package datasource

Module utilities

def envelope(col: Column): TypedColumn[Any, Envelope]

implicit def envelopeEncoder: ExpressionEncoder[Envelope]

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

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

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

def explode_tiles(cols: Column*): Column

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

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

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

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

implicit def extentEncoder: ExpressionEncoder[Extent]

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

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

def initRF(sqlContext: SQLContext): Unit

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

def is_no_data_tile(tile: Column): TypedColumn[Any, 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]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 make_constant_tile(value: Number, cols: Int, rows: Int, cellType: String): TypedColumn[Any, Tile]

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

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

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

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

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

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

implicit def projectedExtentEncoder: ExpressionEncoder[ProjectedExtent]

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

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

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

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

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

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

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

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

def round(tileCol: Column): 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_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_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_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, upperX: Double, lowerY: Double, upperY: Double): TypedColumn[Any, Geometry]

def st_makeBBOX(lowerX: Column, upperX: Column, lowerY: 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_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]]

def tile_dimensions(col: Column): Column

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

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

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

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

def tile_ones(cols: Int, rows: Int, cellType: String): TypedColumn[Any, Tile]

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

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

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

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

def tile_zeros(cols: Int, rows: Int, cellType: String): TypedColumn[Any, Tile]

implicit def tilelayoutEncoder: ExpressionEncoder[TileLayout]

implicit def timestampEncoder: ExpressionEncoder[Timestamp]

implicit def uriEncoder: ExpressionEncoder[URI]

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

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]

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

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

def tileDimensions(col: Column): Column

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

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

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

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

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

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

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

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

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