GeoTiffTile

abstract def bandType: BandType

abstract val cellType: CellType

abstract def decompressor: Decompressor

abstract def getSegment(i: Int): GeoTiffSegment

Returns the GeoTiffSegment of the corresponding index

abstract def getSegments(ids: Traversable[Int]): Iterator[(Int, GeoTiffSegment)]

abstract def interpretAs(newCellType: CellType): Tile

Changes the interpretation of the tile cells through changing NoData handling and optionally cell data type.

abstract def segmentBytes: SegmentBytes

abstract def withNoData(noDataValue: Option[Double]): Tile

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

val bandCount: Int

Count of the bands in the GeoTiff

def clone(): AnyRef

val cols: Int

def combine(other: Tile)(f: (Int, Int) ⇒ Int): Tile

Combines two GeoTiffTiles by applying a function to both and using the result to create a new Tile.

def combineDouble(other: Tile)(f: (Double, Double) ⇒ Double): Tile

Combines two GeoTiffTiles by applying a function to both and using the result to create a new Tile.

def convert(newCellType: CellType): GeoTiffTile

Converts the CellType of the GeoTiffTile to the given CellType

def crop(windows: Seq[GridBounds]): Iterator[(GridBounds, MutableArrayTile)]

Crop this tile to given pixel regions.

def crop(bounds: GridBounds): MutableArrayTile

Crop this tile to given pixel region.

def dimensions: (Int, Int)

def downsample(newCols: Int, newRows: Int)(f: (CellSet) ⇒ Int): Tile

Reduce the resolution of the present Tile to the given number of columns and rows.

def dualCombine(r2: Tile)(f: (Int, Int) ⇒ Int)(g: (Double, Double) ⇒ Double): Tile

Combine two Tiles together using one of two given functions.

def dualForeach(f: (Int) ⇒ Unit)(g: (Double) ⇒ Unit): Unit

Execute a function at each pixel of a Tile.

def dualMap(f: (Int) ⇒ Int)(g: (Double) ⇒ Double): Tile

Map one of the two given functions across the Tile to produce a new one.

def dualMapIfSet(f: (Int) ⇒ Int)(g: (Double) ⇒ Double): Tile

Conditionally map across the Tile with one of two functions, depending on whether the tile is an integer- or a floating-tile.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def findMinMax: (Int, Int)

Return tuple of highest and lowest value in raster.

def findMinMaxDouble: (Double, Double)

Return tuple of highest and lowest value in raster.

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

Takes a function that takes an Int and returns a Unit for each segment in the GeoTiffTile.

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

Execute the given function 'f' at every location in the tile.

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

Takes a function that takes a Double and returns a Unit for each segment in the GeoTiffTile.

macro def foreachDouble(f: (Int, Int, Double) ⇒ Unit): Unit

Execute the given function 'f' at every location in the tile.

def foreachDoubleVisitor(visitor: DoubleTileVisitor): Unit

Executes a DoubleTileVisitor at each cell of the GeoTiffTile.

def foreachIntVisitor(visitor: IntTileVisitor): Unit

Executes an IntTileVisitor at each cell of the GeoTiffTile.

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

Given a col and row, find the segment where this point resides.

final def getClass(): Class[_]

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

Given a col and row, find the segment that this point is within.

def getOverview(idx: Int): GeoTiffTile

def getOverviewsCount: Int

def getSegmentCoordinate(segmentIndex: Int): (Int, Int)

def getSegmentDimensions(segmentIndex: Int): (Int, Int)

Calculates pixel dimensions of a given segment in this layout.

def getSegmentSize(segmentIndex: Int): Int

Calculates the total pixel count for given segment in this layout.

def gridBounds: GridBounds

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def isNoDataTile: Boolean

lazy val logger: Logger

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

Takes a function that takes an Int and returns an Int on each segment in the GeoTiffTile.

macro def map(f: (Int, Int, Int) ⇒ Int): Tile

Map over the tiles using a function which accepts the column, row, and value at that position and returns an integer.

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

Takes a function that takes a Double and returns a Double on each segment in the GeoTiffTile.

macro def mapDouble(f: (Int, Int, Double) ⇒ Double): Tile

Map over the tiles using a function which accepts the column, row, and value at that position and returns a double.

def mapDoubleMapper(mapper: DoubleTileMapper): Tile

Map a DoubleTileMapper over the given tile.

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

Conditionally execute (or don't) the given function at each pixel of a Tile, depending on whether that pixel is NODATA or not.

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

Conditionally execute (or don't) the given function at each pixel of a Tile, depending on whether that pixel is NODATA or not.

def mapIntMapper(mapper: IntTileMapper): Tile

Map an IntTileMapper over the given tile.

def mutable: MutableArrayTile

Converts GeoTiffTile to a MutableArrayTile

final def ne(arg0: AnyRef): Boolean

def normalize(oldMin: Double, oldMax: Double, newMin: Double, newMax: Double): Tile

Normalizes the values of this raster, given the current min and max, to a new min and max.

def normalize(oldMin: Int, oldMax: Int, newMin: Int, newMax: Int): Tile

Normalizes the values of this raster, given the current min and max, to a new min and max.

final def notify(): Unit

final def notifyAll(): Unit

val overviews: List[GeoTiffTile]

def partitionWindowsBySegments(windows: Seq[GridBounds], maxPartitionSize: Long): Array[Array[GridBounds]]

Partition a list of pixel windows to localize required segment reads.

def rescale(newMin: Double, newMax: Double): Tile

Rescale the values in this Tile so that they are between the two given values.

def rescale(newMin: Int, newMax: Int): Tile

Rescale the values in this Tile so that they are between the two given values.

val rows: Int

val segmentCount: Int

val segmentLayout: GeoTiffSegmentLayout

def size: Int

The size of the grid, e.g.

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

def toArray(): Array[Int]

Converts the given implementation to an Array

def toArrayDouble(): Array[Double]

Converts the given implementation to an Array

def toArrayTile(): ArrayTile

Converts GeoTiffTile to an ArrayTile

def toBytes(): Array[Byte]

Converts the GeoTiffTile to an Array[Byte]

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit