LocalFunctions

Value Members

1. final def !=(arg0: Any): Boolean

   

   Definition Classes

   AnyRef → Any

2. final def ##(): Int

   

   Definition Classes

   AnyRef → Any

3. final def ==(arg0: Any): Boolean

   

   Definition Classes

   AnyRef → Any

4. final def asInstanceOf[T0]: T0

   

   Definition Classes

   Any

5. def clone(): AnyRef

   

   Attributes

   protected[java.lang]

   Definition Classes

   AnyRef

   Annotations

   @throws( ... )

6. final def eq(arg0: AnyRef): Boolean

   

   Definition Classes

   AnyRef

7. def equals(arg0: Any): Boolean

   

   Definition Classes

   AnyRef → Any

8. def finalize(): Unit

   

   Attributes

   protected[java.lang]

   Definition Classes

   AnyRef

   Annotations

   @throws( classOf[java.lang.Throwable] )

9. final def getClass(): Class[_]

   

   Definition Classes

   AnyRef → Any

10. def hashCode(): Int

    

    Definition Classes

    AnyRef → Any

11. final def isInstanceOf[T0]: Boolean

    

    Definition Classes

    Any

12. final def ne(arg0: AnyRef): Boolean

    

    Definition Classes

    AnyRef

13. final def notify(): Unit

    

    Definition Classes

    AnyRef

14. final def notifyAll(): Unit

    

    Definition Classes

    AnyRef

15. def rf_abs(tileCol: Column): Column

    

    Compute the absolute value of each cell.

16. def rf_exp(tileCol: Column): Column

    

    Exponential of cell values

17. def rf_exp10(tileCol: Column): Column

    

    Ten to the power of cell values

18. def rf_exp2(tileCol: Column): Column

    

    Two to the power of cell values

19. def rf_expm1(tileCol: Column): Column

    

    Exponential of cell values, less one

20. def rf_identity(tileCol: Column): Column

    

    Return the incoming tile untouched.

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

    

    Where the maskTile does **not** contain NoData, replace values in the source tile with NoData

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

    

    Where the maskTile does **not** equal maskValue, replace values in the source tile with NoData

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

    

    Where the maskTile does **not** equal maskValue, replace values in the source tile with NoData

24. def rf_local_add[T](tileCol: Column, value: T)(implicit arg0: Numeric[T]): Column

    

    Cellwise addition of a scalar value to a tile.

25. def rf_local_add(left: Column, right: Column): Column

    

    Cellwise addition between two Tiles or Tile and scalar column.

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

    

    Perform an arbitrary GeoTrellis LocalTileBinaryOp between two Tile columns.

27. def rf_local_clamp[T](tile: Column, min: T, max: T)(implicit arg0: Numeric[T]): Column

    

    Return the tile with its values limited to a range defined by min and max.

28. def rf_local_clamp[T](tile: Column, min: Column, max: T)(implicit arg0: Numeric[T]): Column

    

    Return the tile with its values limited to a range defined by min and max.

29. def rf_local_clamp[T](tile: Column, min: T, max: Column)(implicit arg0: Numeric[T]): Column

    

    Return the tile with its values limited to a range defined by min and max.

30. def rf_local_clamp(tile: Column, min: Column, max: Column): Column

    

    Return the tile with its values limited to a range defined by min and max.

31. def rf_local_data(tileCol: Column): Column

    

    Return a tile with zeros where the input is NoData, otherwise one

32. def rf_local_divide[T](tileCol: Column, value: T)(implicit arg0: Numeric[T]): Column

    

    Cellwise division of a tile by a scalar value.

33. def rf_local_divide(left: Column, right: Column): Column

    

    Cellwise division between two Tiles.

34. def rf_local_equal[T](tileCol: Column, value: T)(implicit arg0: Numeric[T]): Column

    

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

35. def rf_local_equal(left: Column, right: Column): Column

    

    Cellwise equal to value comparison between two tiles.

36. def rf_local_extract_bits(tile: Column, bitPosition: Int): Column

    

    Extract value from specified bits of the cells' underlying binary data.

    Extract value from specified bits of the cells' underlying binary data. bitPosition is bit to consider, working from the right. It is zero indexed.

37. def rf_local_extract_bits(tile: Column, startBit: Int, numBits: Int): Column

    

    Extract value from specified bits of the cells' underlying binary data.

    Extract value from specified bits of the cells' underlying binary data. startBit is the first bit to consider, working from the right. It is zero indexed. numBits is the number of bits to take, moving further to the left.

38. def rf_local_extract_bits(tile: Column, bitPosition: Column): Column

    

    Extract value from specified bits of the cells' underlying binary data.

    Extract value from specified bits of the cells' underlying binary data. bitPosition is bit to consider, working from the right. It is zero indexed.

39. def rf_local_extract_bits(tile: Column, startBit: Column, numBits: Column): Column

    

    Extract value from specified bits of the cells' underlying binary data.

    Extract value from specified bits of the cells' underlying binary data. startBit is the first bit to consider, working from the right. It is zero indexed. numBits is the number of bits to take moving further to the left.

40. def rf_local_greater[T](tileCol: Column, value: T)(implicit arg0: Numeric[T]): Column

    

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

41. def rf_local_greater(left: Column, right: Column): Column

    

    Cellwise greater than value comparison between two tiles.

42. def rf_local_greater_equal[T](tileCol: Column, value: T)(implicit arg0: Numeric[T]): Column

    

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

43. def rf_local_greater_equal(left: Column, right: Column): Column

    

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

44. def rf_local_is_in(tileCol: Column, array: Array[Int]): Column

    

    Test if each cell value is in provided array

45. def rf_local_is_in(tileCol: Column, arrayCol: Column): Column

    

    Test if each cell value is in provided array

46. def rf_local_less[T](tileCol: Column, value: T)(implicit arg0: Numeric[T]): Column

    

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

47. def rf_local_less(left: Column, right: Column): Column

    

    Cellwise less than value comparison between two tiles.

48. def rf_local_less_equal[T](tileCol: Column, value: T)(implicit arg0: Numeric[T]): Column

    

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

49. def rf_local_less_equal(left: Column, right: Column): Column

    

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

50. def rf_local_max[T](left: Column, right: T)(implicit arg0: Numeric[T]): Column

    

    Cellwise maximum between Tiles.

51. def rf_local_max(left: Column, right: Column): Column

    

    Cellwise maximum between Tiles.

52. def rf_local_min[T](left: Column, right: T)(implicit arg0: Numeric[T]): Column

    

    Cellwise minimum between Tiles.

53. def rf_local_min(left: Column, right: Column): Column

    

    Cellwise minimum between Tiles.

54. def rf_local_multiply[T](tileCol: Column, value: T)(implicit arg0: Numeric[T]): Column

    

    Cellwise multiplication of a tile by a scalar value.

55. def rf_local_multiply(left: Column, right: Column): Column

    

    Cellwise multiplication between two Tiles.

56. def rf_local_no_data(tileCol: Column): Column

    

    Return a tile with ones where the input is NoData, otherwise zero

57. def rf_local_subtract[T](tileCol: Column, value: T)(implicit arg0: Numeric[T]): Column

    

    Cellwise subtraction of a scalar value from a tile.

58. def rf_local_subtract(left: Column, right: Column): Column

    

    Cellwise subtraction between two Tiles.

59. def rf_local_unequal[T](tileCol: Column, value: T)(implicit arg0: Numeric[T]): Column

    

    Cellwise inequality comparison between a tile and a scalar.

60. def rf_local_unequal(left: Column, right: Column): Column

    

    Cellwise inequality comparison between two tiles.

61. def rf_log(tileCol: Column): Column

    

    Take natural logarithm of cell values.

62. def rf_log10(tileCol: Column): Column

    

    Take base 10 logarithm of cell values.

63. def rf_log1p(tileCol: Column): Column

    

    Natural logarithm of one plus cell values.

64. def rf_log2(tileCol: Column): Column

    

    Take base 2 logarithm of cell values.

65. def rf_mask(sourceTile: Column, maskTile: Column, inverse: Boolean = false): TypedColumn[Any, Tile]

    

    Where the rf_mask tile contains NODATA, replace values in the source tile with NODATA

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

    

    Where the rf_mask tile contains NODATA, replace values in the source tile with NODATA

67. def rf_mask_by_bit(dataTile: Column, maskTile: Column, bitPosition: Column, valueToMask: Column): TypedColumn[Any, Tile]

    

    Applies a mask using bit values in the mask_tile.

    Applies a mask using bit values in the mask_tile. Working from the right, extract the bit at bitPosition from the maskTile. In all locations where these are equal to the valueToMask, the returned tile is set to NoData, else the original dataTile cell value.

68. def rf_mask_by_bit(dataTile: Column, maskTile: Column, bitPosition: Int, valueToMask: Boolean): TypedColumn[Any, Tile]

    

    Applies a mask using bit values in the mask_tile.

    Applies a mask using bit values in the mask_tile. Working from the right, extract the bit at bitPosition from the maskTile. In all locations where these are equal to the valueToMask, the returned tile is set to NoData, else the original dataTile cell value.

69. def rf_mask_by_bits(dataTile: Column, maskTile: Column, startBit: Int, numBits: Int, valuesToMask: Int*): TypedColumn[Any, Tile]

    

    Applies a mask from blacklisted bit values in the mask_tile.

    Applies a mask from blacklisted bit values in the mask_tile. Working from the right, the bits from start_bit to start_bit + num_bits are @ref:[extracted](reference.md#rf_local_extract_bits) from cell values of the mask_tile. In all locations where these are in the mask_values, the returned tile is set to NoData; otherwise the original tile cell value is returned.

70. def rf_mask_by_bits(dataTile: Column, maskTile: Column, startBit: Column, numBits: Column, valuesToMask: Column): TypedColumn[Any, Tile]

    

    Applies a mask from blacklisted bit values in the mask_tile.

    Applies a mask from blacklisted bit values in the mask_tile. Working from the right, the bits from start_bit to start_bit + num_bits are @ref:[extracted](reference.md#rf_local_extract_bits) from cell values of the mask_tile. In all locations where these are in the mask_values, the returned tile is set to NoData; otherwise the original tile cell value is returned.

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

    

    Where the maskTile equals maskValue, replace values in the source tile with NoData

72. def rf_mask_by_value(sourceTile: Column, maskTile: Column, maskValue: Int, inverse: Boolean): TypedColumn[Any, Tile]

    

    Where the maskTile equals maskValue, replace values in the source tile with NoData

73. def rf_mask_by_value(sourceTile: Column, maskTile: Column, maskValue: Column, inverse: Boolean = false): TypedColumn[Any, Tile]

    

    Where the maskTile equals maskValue, replace values in the source tile with NoData

74. def rf_mask_by_values(sourceTile: Column, maskTile: Column, maskValues: Int*): TypedColumn[Any, Tile]

    

    Generate a tile with the values from data_tile, but where cells in the mask_tile are in the mask_values list, replace the value with NODATA.

75. def rf_mask_by_values(sourceTile: Column, maskTile: Column, maskValues: Column): TypedColumn[Any, Tile]

    

    Generate a tile with the values from data_tile, but where cells in the mask_tile are in the mask_values list, replace the value with NODATA.

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

    

    Compute the normalized difference of two tile columns

77. def rf_rescale(tile: Column, min: Double, max: Double): Column

    

    Rescale cell values such that the minimum is zero and the maximum is one.

    Rescale cell values such that the minimum is zero and the maximum is one. Other values will be linearly interpolated into the range. The min parameter will become the zero value and the max parameter will become 1. Values outside the range will be set to 0 or 1.

78. def rf_rescale(tile: Column, min: Column, max: Column): Column

    

    Rescale cell values such that the minimum is zero and the maximum is one.

    Rescale cell values such that the minimum is zero and the maximum is one. Other values will be linearly interpolated into the range. The min parameter will become the zero value and the max parameter will become 1. Values outside the range will be set to 0 or 1.

79. def rf_rescale(tile: Column): Column

    

    Rescale cell values such that the minimum is zero and the maximum is one.

    Rescale cell values such that the minimum is zero and the maximum is one. Other values will be linearly interpolated into the range. Cells with the tile-wise minimum value will become the zero value and those at the tile-wise maximum value will become 1. This can result in inconsistent values across rows in a tile column.

80. def rf_round(tileCol: Column): Column

    

    Round cell values to nearest integer without chaning cell type.

81. def rf_sqrt(tileCol: Column): Column

    

    Square root of cell values

82. def rf_standardize(tile: Column): Column

    

    Standardize cell values such that the mean is zero and the standard deviation is one.

    Standardize cell values such that the mean is zero and the standard deviation is one. Each tile will be standardized according to the statistics of its cell values; this can result in inconsistent values across rows in a tile column.

83. def rf_standardize(tile: Column, mean: Double, stddev: Double): Column

    

    Standardize cell values such that the mean is zero and the standard deviation is one.

    Standardize cell values such that the mean is zero and the standard deviation is one. The mean and stddev are applied to all tiles in the column.

84. def rf_standardize(tile: Column, mean: Column, stddev: Column): Column

    

    Standardize cell values such that the mean is zero and the standard deviation is one.

    Standardize cell values such that the mean is zero and the standard deviation is one. The mean and stddev are applied to all tiles in the column.

85. def rf_where(condition: Column, x: Column, y: Column): Column

    

    Return a tile with cell values chosen from x or y depending on condition.

    Return a tile with cell values chosen from x or y depending on condition. Operates cell-wise in a similar fashion to Spark SQL when and otherwise.

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

    

    Definition Classes

    AnyRef

87. def toString(): String

    

    Definition Classes

    AnyRef → Any

88. final def wait(): Unit

    

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

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

    

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

90. final def wait(arg0: Long): Unit

    

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )