TLcdEarthGXYRasterPainter (LuciadLightspeed API documentation)

java.lang.Object
- com.luciad.view.gxy.ALcdGXYPainter
- - com.luciad.earth.view.gxy.ALcdEarthGXYPainter
  - - com.luciad.earth.view.gxy.TLcdEarthGXYRasterPainter

All Implemented Interfaces:

ILcdCloneable, ILcdPropertyChangeSource, ILcdStatusSource, ILcdGXYPainter, ILcdGXYPainterProvider, Serializable, Cloneable

Direct Known Subclasses:

TLcdEarthGXYSinglevaluedRasterPainter, TLcdHypsometricEarthPainter
```
public class TLcdEarthGXYRasterPainter
extends ALcdEarthGXYPainter
implements ILcdStatusSource
```
This ILcdGXYPainter can paint the raster data of ILcdEarthTileSet instances in a 2D view.
This painter has been replaced by TLcdGXYImagePainter. Please consider using it instead of this one.

Supported objects
This painter can visualize any ILcdEarthTileSet that can produce tiles with raster data. The tile data should however be supported by the createRasterTile(com.luciad.earth.tileset.ALcdEarthTile) implementation. The default implementation only supports RenderedImages as tile data. The first coverage in the tile set that can produce tiles with a RenderedImage will be used (see chooseTileSetCoverage(com.luciad.earth.tileset.ILcdEarthTileSet)).

Visualization
By default the tile level is chosen such that each pixel in the view maps to at least one raster value, if possible. This avoids pixelation effects (e.g. that individual pixels are visible). To achieve this a tile level is chosen with a higher pixel density than the view. This behavior can be changed by either setting the quality or by overriding the chooseTileSetLevel(java.awt.Graphics, int, com.luciad.view.gxy.ILcdGXYContext, com.luciad.shape.ILcdBounds) method.
If some tiles are not available, the tiles at lower levels will be used automatically to avoid gaps.
If required this painter will warp the raster data between different coordinate systems, otherwise it will just paint their linearly scaled images.
The bounds of the tile set will be painted instead of the tiles if the pixel density of the least detailed level is too high. There is no limit on the pixel density by default so the bounds of a tile set will never be painted unless the start resolution factor is set to a lower value. Typically this is fine for tile sets that cover the entire world but it may be necessary to lower the start resolution factor if there are multiple smaller tile sets in a view.

Incremental visualization
If the tile set supports asynchronous tile production, the visualization can be done incrementally. This means that the tiles will be requested asynchronously and the view will be repainted as the tiles become available. To enable this the ALcdEarthGXYPainter.isAsynchronousTileRequestAllowed() and ALcdEarthGXYPainter.isRepaintViewWhenTileAvailable() should be set to true (default).

Caching
By default only the tiles necessary for the view will be cached using hard references (see setCacheSize(int)). Other tiles will also be cached if there is enough memory (see isSoftCachingEnabled()). Tiles that reside in either of these caches will be updated automatically every minute (see getUpdateInterval()). You can use the updateTiles(com.luciad.view.gxy.ILcdGXYView) method to update all tiles that are currently cached immediately.

Performance considerations
- To achieve optimal performance the reference of the tile set and the world reference should match. If this is not the case the raster data will need to be warped on-the-fly.
- When incremental visualization is enabled other layers may also be repainted more frequently. This could result in reduced performance if this takes too much time.
- When incremental visualization is enabled in combination with asynchronous painting it may sometimes take a significant amount of time before a paint is completed. More specifically this situation occurs if the painting is interrupted before it can finish due to a repaint for tile that has just become available. To avoid this you can disable the interruption of paints (see TLcdGXYAsynchronousPaintQueue.setInterruptPainting(boolean))
Since:

8.2

See Also:

Serialized Form

Field Summary
- Fields inherited from class com.luciad.view.gxy.ALcdGXYPainter
  defaultCreationFillStyle, defaultCreationLineStyle, defaultFillStyle, defaultLineStyle, fWorkBounds
- Fields inherited from interface com.luciad.view.gxy.ILcdGXYPainter
  BODY, CREATING, DEFAULT, HANDLES, RESHAPING, SELECTED, SNAPS, TRANSLATING

Constructor Summary

Constructors
Constructor and Description
`TLcdEarthGXYRasterPainter()` Creates a new earth 2D raster painter with the default cache size.
`TLcdEarthGXYRasterPainter(int aCacheSize)` Creates a new earth 2D raster painter with the given cache size.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addStatusListener(ILcdStatusListener aStatusListener)` Registers the given listener so it will receive status events from this source.
`protected TLcdEarthTileFormat`	`chooseTileFormat(ILcdEarthTileSet aTileSet, ILcdEarthTileSetCoverage aCoverage)` Chooses a tile format from the given tile set and coverage to be used for producing tiles.
`protected ILcdEarthTileSetCoverage`	`chooseTileSetCoverage(ILcdEarthTileSet aTileSet)` Chooses a coverage from the given tile set to be drawn by this painter.
`protected int`	`chooseTileSetLevel(Graphics aGraphics, int aMode, ILcdGXYContext aContext, ILcdBounds aViewModelBounds)` Called by `paint(java.awt.Graphics, int, com.luciad.view.gxy.ILcdGXYContext)` to choose the level in the tile set that should be painted.
`void`	`clearCache()` Clears both the fixed cached cache and the soft cache if it is enabled.
`void`	`clearCache(Object aObject)` Clears both the fixed cached cache and the soft cache, if it is enabled, for an object.
`Object`	`clone()` Makes `Object.clone()` public.
`protected ILcdEarthTileSet`	`configureBaseTileSet(Object aObject, ILcdEarthTileSet aTileSet)` Configures the base tile set.
`protected ILcdEarthTileSet`	`createAsynchronousTileSet(Object aObject, ILcdEarthTileSet aTileSet)` Creates a tile set that can produce tiles asynchronously.
`protected ILcdTile`	`createRasterTile(ALcdEarthTile aTile)` Creates an `ILcdTile` corresponding to the specified `ALcdEarthTile`.
`ILcdGXYPainterStyle`	`getBoundsFillStyle()` Returns the style that is used when painting the fill of the bounds of tile set.
`ILcdGXYPainterStyle`	`getBoundsLineStyle()` Returns the style that is used when painting the outline of the bounds of tile set.
`float`	`getBrightness()`
`int`	`getCacheSize()` Returns the size of the fixed cache which uses hard references (in #tiles).
`ColorModel`	`getColorModel()`
`float`	`getContrast()`
`String`	`getDisplayName()` Returns the display name of this `ILcdGXYPainter`.
`protected ILcdTile`	`getEmptyTile()` Returns a representative empty tile for this painter.
`int`	`getOversamplingRate()` Returns the sampling rate used when transforming the raster.
`boolean`	`getPaintCache()` Returns whether this painter caches the warped raster images it has painted.
`protected double`	`getPixelDensity(int aLevel)` Returns the pixel density of the data (in the tile set reference) at the given level.
`double`	`getQuality()` Returns the current painting quality.
`protected TLcdEarthTileFormat`	`getRequestFormat()` Returns the tile format used to request tiles.
`RGBImageFilter`	`getRGBImageFilter()`
`double`	`getStartResolutionFactor()` Returns the highest pixel density (number of raster pixels per screen pixel) at which a tile set is painted.
`TLcdEarthTileContext`	`getTileContext(Object aObject)` Returns the tile context for the most recent paint of an object.
`protected ILcdEarthTileSet`	`getTileSet(Object aObject)` The first time the tile set for an object is retrieved this base tile set is `configured` and then `wrapped` with an asynchronous tile set to ensure smooth painting.
`float`	`getTransparency()`
`long`	`getUpdateInterval()` Returns the time between two updates for a tile.
`int`	`getWarpBlockSize()` Returns the width and height of the block in which the raster transformation is approximated using bilinear interpolation.
`boolean`	`isAllowOutdatedTiles()` Returns whether outdated tiles may be returned if an exception occurs while retrieving a tile.
`boolean`	`isAutoIncreaseCacheSize()` Returns whether the size of the fixed cache will be increased automatically if it is too small to contain all visible tiles at the optimal level of detail.
`boolean`	`isPaintBoundsFill()` Returns whether the fill of the bounds of a tile set is painted.
`boolean`	`isPaintBoundsOutline()` Returns whether the outline of the bounds of a tile set is painted.
`boolean`	`isParentTileRequestAllowed()` Returns whether a request for parent tiles may be made when tiles are requested.
`boolean`	`isSoftCachingEnabled()` Returns whether the soft cache is enabled or not.
`protected boolean`	`isValidCoverage(ILcdEarthTileSetCoverage aCoverage)` Returns whether the given coverage can be drawn by this painter.
`void`	`paint(Graphics aGraphics, int aMode, ILcdGXYContext aContext)` Displays the representation of the object in the given mode on the Graphics passed, taking into account the supplied context.
`void`	`releaseHardReferencedCache()` Releases the hard references to all tiles of all objects painted by this painter.
`void`	`releaseHardReferencedCache(Object aObject)` Releases the hard references to all tiles for a particular object Normally the painter keeps a hard reference to the set of tiles needed in the last paint.
`void`	`removeStatusListener(ILcdStatusListener aStatusListener)` Removes the specified listener so it is no longer notified.
`void`	`setAllowOutdatedTiles(boolean aAllowOutdatedTiles)` Sets whether outdated tiles may be returned if an exception occurs while retrieving a tile.
`void`	`setAsynchronousTileRequestAllowed(boolean aAsynchronousTileRequestAllowed)` Sets whether the tiles can be requested asynchronously.
`void`	`setAutoIncreaseCacheSize(boolean aAutoIncreaseCacheSize)` Sets whether the size of the fixed cache should be increased automatically if it is too small to contain all visible tiles at the optimal level of detail.
`void`	`setBoundsFillStyle(ILcdGXYPainterStyle aFillStyle)` Sets the style that is used when painting the fill of the bounds of tile set.
`void`	`setBoundsLineStyle(ILcdGXYPainterStyle aLineStyle)` Sets the style that is used when painting the outline of the bounds of tile set.
`void`	`setBrightness(float aBrightness)` Sets the brightness factor that is applied to painted tiles.
`void`	`setCacheSize(int aCacheSize)` Sets the size of the fixed cache which uses hard references (in #tiles).
`void`	`setColorModel(ColorModel aColorModel)` Sets the ColorModel that determines how a tile pixel is transformed into color components for a screen pixel.
`void`	`setContrast(float aContrast)` Sets the gamma correction that is applied to painted rasters.
`void`	`setExceptionHandler(ILcdExceptionHandler aExceptionHandler)` Sets the exception handler that is used to handle exceptions that occur during tile retrieval.
`void`	`setObject(Object aObject)` Sets the `tile set` to the specified object, chooses a `coverage` in it and chooses a `tile format`.
`void`	`setOversamplingRate(int aOverSamplingRate)` Sets the number of samples used per pixel when transforming a raster.
`void`	`setPaintBoundsFill(boolean aPaint)` Sets whether the fill of the bounds of a tile set is painted when the `pixel density is too high`.
`void`	`setPaintBoundsOutline(boolean aPaint)` Sets whether the outline of the bounds of a tile set is painted when the `pixel density is too high`.
`void`	`setPaintCache(boolean aCache)` Specifies whether this painter should cache the warped raster images it has painted.
`void`	`setParentTileRequestAllowed(boolean aParentTileRequestAllowed)` Sets whether parent tiles of the visible tiles may be requested.
`void`	`setQuality(double aQuality)` Sets the quality of the painted result.
`void`	`setRepaintViewWhenTileAvailable(boolean aRepaintViewWhenTileAvailable)` Sets whether the view is repainted when a tile becomes available.
`void`	`setRGBImageFilter(RGBImageFilter aRGBImageFilter)` Sets the optional filter that is applied to painted tiles.
`void`	`setSoftCachingEnabled(boolean aSoftCachingEnabled)` Enables or disables the soft cache.
`void`	`setStartResolutionFactor(double aStartResolutionFactor)` Sets the highest pixel density (number of raster pixels per screen pixel) at which a tile set is painted.
`void`	`setTransparency(float aTransparency)` Sets the transparency factor that is applied to painted tiles.
`void`	`setUpdateInterval(long aTime)` Sets the time between two updates for a tile.
`void`	`setWarpBlockSize(int aWarpBlockSize)` Sets the width and height of the block in which the raster transformation is approximated using bilinear interpolation.
`void`	`updateTiles(ILcdGXYView aGXYView)` Updates all tiles that are cached in both the fixed cache and the soft cache.
`void`	`updateTiles(Object aObject, ILcdGXYView aGXYView)` Updates all tiles that are cached in both the fixed cache and the soft cache for an object.

Methods inherited from class com.luciad.earth.view.gxy.ALcdEarthGXYPainter
boundsSFCT, getExceptionHandler, getObject, getTileSet, getTileSetCoverage, isAsynchronousTileRequestAllowed, isRepaintViewWhenTileAvailable, isTouched

Methods inherited from class com.luciad.view.gxy.ALcdGXYPainter
addPropertyChangeListener, anchorPointSFCT, firePropertyChangeEvent, firePropertyChangeEvent, getCursor, getGXYPainter, isTraceOn, removePropertyChangeListener, setClassTraceOn, setDisplayName, setTraceOn, snapTarget, supportSnap

Methods inherited from class java.lang.Object
equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - TLcdEarthGXYRasterPainter
```
public TLcdEarthGXYRasterPainter(int aCacheSize)
```
    Creates a new earth 2D raster painter with the given cache size. The cache size will be increased automatically if it is too small to contain all visible tiles.
    
    Parameters:
    
    aCacheSize - the maximum number of entries in the cache
    
    See Also:
    
    getCacheSize()
  - TLcdEarthGXYRasterPainter
```
public TLcdEarthGXYRasterPainter()
```
    Creates a new earth 2D raster painter with the default cache size. The cache size will be increased automatically if it is too small to contain all visible tiles.
- Method Detail
  - getColorModel
```
public ColorModel getColorModel()
```
    Returns:
    
    the color model
    
    See Also:
    
    setColorModel(java.awt.image.ColorModel)
  - setColorModel
```
public void setColorModel(ColorModel aColorModel)
```
    Sets the ColorModel that determines how a tile pixel is transformed into color components for a screen pixel. If it is not set, the raster tiles created by createRasterTile(com.luciad.earth.tileset.ALcdEarthTile) determine the ColorModel.
    
    Parameters:
    
    aColorModel - the color model
  - getRGBImageFilter
```
public RGBImageFilter getRGBImageFilter()
```
    Returns:
    
    the image filter
    
    See Also:
    
    setRGBImageFilter(java.awt.image.RGBImageFilter)
  - setRGBImageFilter
```
public void setRGBImageFilter(RGBImageFilter aRGBImageFilter)
```
    Sets the optional filter that is applied to painted tiles. The filter should be spatially invariant. Any brightness and transparency settings are applied on top of it.
    
    Parameters:
    
    aRGBImageFilter - the new image filter or null
  - getTransparency
```
public float getTransparency()
```
    Returns:
    
    the transparency
    
    See Also:
    
    setTransparency(float)
  - setTransparency
```
public void setTransparency(float aTransparency)
```
    Sets the transparency factor that is applied to painted tiles. It is an alpha value between 0 and 1, with 0 being perfectly transparent, and 1 (the default) being perfectly opaque.
    
    Parameters:
    
    aTransparency - the transparency
  - getBrightness
```
public float getBrightness()
```
    Returns:
    
    the brightness
    
    See Also:
    
    setBrightness(float)
  - setBrightness
```
public void setBrightness(float aBrightness)
```
    Sets the brightness factor that is applied to painted tiles. It is a value between 0 and 1, with 0 being black, and 1 (the default) being the original brightness.
    
    Parameters:
    
    aBrightness - the brightness
  - getContrast
```
public float getContrast()
```
    Returns:
    
    the contrast
    
    See Also:
    
    setContrast(float)
  - setContrast
```
public void setContrast(float aContrast)
```
    Sets the gamma correction that is applied to painted rasters. A value of 1 (the default) leaves the contrast unchanged. A value larger than 1 enhances the contrast of dark colors by making them brighter, while a value smaller than 1 enhances the contrast of bright colors by making them darker.
    
    Parameters:
    
    aContrast - the contrast
  - setWarpBlockSize
```
public void setWarpBlockSize(int aWarpBlockSize)
```
    Sets the width and height of the block in which the raster transformation is approximated using bilinear interpolation. This transformation is only applied if the reference of the tile set and view do not match. Smaller values result in more accurate results, but also larger computation times. The default is 64. With a value of 1, every pixel is transformed without approximation.
    
    Parameters:
    
    aWarpBlockSize - the width and height, expressed in pixels.
  - getWarpBlockSize
```
public int getWarpBlockSize()
```
    Returns the width and height of the block in which the raster transformation is approximated using bilinear interpolation.
    
    Returns:
    
    the warp block size
    
    See Also:
    
    setWarpBlockSize(int)
  - setOversamplingRate
```
public void setOversamplingRate(int aOverSamplingRate)
```
    Sets the number of samples used per pixel when transforming a raster. The default is 1. The total number of samples used per pixel equals (aOverSamplingRate * aOverSamplingRate). For instance, if the oversampling rate is set to 2, the painter will take 4 samples per pixel and average their values. This increases the image quality, especially if the raster contains sharp edges, but it also increases the computational cost.
    This property is only relevant for rasters that have to be warped, that is, when the model reference of the raster is different from the world reference of the view.
    
    Parameters:
    
    aOverSamplingRate - the number of samples used per pixel in one direction.
  - getOversamplingRate
```
public int getOversamplingRate()
```
    Returns the sampling rate used when transforming the raster. The returned value equals the number of samples used per pixel in one direction.
    
    Returns:
    
    the oversampling rate
    
    See Also:
    
    setOversamplingRate(int)
  - getCacheSize
```
public int getCacheSize()
```
    Returns the size of the fixed cache which uses hard references (in #tiles).
    This painter will never paint more tiles for a view than fit in this cache. So if it is too small coarse data may be painted instead of the data at the optimal level of detail. To avoid this you can set the setAutoIncreaseCacheSize(boolean) property.
    Next to this cache there is also an optional cache that uses soft references (see isSoftCachingEnabled()).
    
    Overrides:
    
    getCacheSize in class ALcdEarthGXYPainter
    
    Returns:
    
    the cache size
  - setCacheSize
```
public void setCacheSize(int aCacheSize)
```
    Sets the size of the fixed cache which uses hard references (in #tiles).
    
    Overrides:
    
    setCacheSize in class ALcdEarthGXYPainter
    
    Parameters:
    
    aCacheSize - the new cache size
    
    See Also:
    
    getCacheSize()
  - clearCache
```
public void clearCache()
```
    Clears both the fixed cached cache and the soft cache if it is enabled.
    
    Overrides:
    
    clearCache in class ALcdEarthGXYPainter
    
    See Also:
    
    setCacheSize(int), isSoftCachingEnabled()
  - clearCache
```
public void clearCache(Object aObject)
```
    Clears both the fixed cached cache and the soft cache, if it is enabled, for an object.
    
    Parameters:
    
    aObject - the object whose cache should be cleared
    
    See Also:
    
    setCacheSize(int), isSoftCachingEnabled()
  - releaseHardReferencedCache
```
public void releaseHardReferencedCache()
```
    Releases the hard references to all tiles of all objects painted by this painter.
    
    See Also:
    
    releaseHardReferencedCache(Object)
  - releaseHardReferencedCache
```
public void releaseHardReferencedCache(Object aObject)
```
    Releases the hard references to all tiles for a particular object
    Normally the painter keeps a hard reference to the set of tiles needed in the last paint. This ensures that this data is immediately available in subsequent paints. Doing this is essential when using incremental visualization, otherwise data might disappear. However this cache is not cleaned up automatically when the data is not painted anymore (ex. the layer is set to invisible). In this case you can use this method to allow garbage collection of this data when the memory is needed for other purposes. So calling this indicates the data may be garbage collected but usually this will only happen if there is memory pressure.
    Typically this method should only be invoked when the object no longer needs to be painted. For example when the layer is set to invisible.
    
    Parameters:
    
    aObject - the object whose tiles should not be hard-referenced anymore
  - setAsynchronousTileRequestAllowed
```
public void setAsynchronousTileRequestAllowed(boolean aAsynchronousTileRequestAllowed)
```
    Description copied from class: ALcdEarthGXYPainter
    
    Sets whether the tiles can be requested asynchronously.
    
    Overrides:
    
    setAsynchronousTileRequestAllowed in class ALcdEarthGXYPainter
    
    Parameters:
    
    aAsynchronousTileRequestAllowed - True if the tiles can be requested asynchronously
    
    See Also:
    
    ALcdEarthGXYPainter.isAsynchronousTileRequestAllowed()
  - setRepaintViewWhenTileAvailable
```
public void setRepaintViewWhenTileAvailable(boolean aRepaintViewWhenTileAvailable)
```
    Description copied from class: ALcdEarthGXYPainter
    
    Sets whether the view is repainted when a tile becomes available.
    
    Overrides:
    
    setRepaintViewWhenTileAvailable in class ALcdEarthGXYPainter
    
    Parameters:
    
    aRepaintViewWhenTileAvailable - whether the view should repainted when a tile becomes available
  - updateTiles
```
public void updateTiles(ILcdGXYView aGXYView)
```
    Updates all tiles that are cached in both the fixed cache and the soft cache.
    
    Parameters:
    
    aGXYView - the view that this painter is painting in
    
    See Also:
    
    setCacheSize(int), isSoftCachingEnabled()
  - updateTiles
```
public void updateTiles(Object aObject,
                        ILcdGXYView aGXYView)
```
    Updates all tiles that are cached in both the fixed cache and the soft cache for an object.
    
    Parameters:
    
    aObject - the object whose tiles should be updated
    
    aGXYView - the view that this painter is painting in
    
    See Also:
    
    setCacheSize(int), isSoftCachingEnabled()
  - isAutoIncreaseCacheSize
```
public boolean isAutoIncreaseCacheSize()
```
    Returns whether the size of the fixed cache will be increased automatically if it is too small to contain all visible tiles at the optimal level of detail.
    
    Returns:
    
    true if the size of the fixed cache will be increased automatically if it is too small to contain
    
    See Also:
    
    setCacheSize(int)
  - setAutoIncreaseCacheSize
```
public void setAutoIncreaseCacheSize(boolean aAutoIncreaseCacheSize)
```
    Sets whether the size of the fixed cache should be increased automatically if it is too small to contain all visible tiles at the optimal level of detail.
    
    Parameters:
    
    aAutoIncreaseCacheSize - whether if the size of the fixed cache should be increased automatically if it is too small to contain
    
    See Also:
    
    setCacheSize(int)
  - isSoftCachingEnabled
```
public boolean isSoftCachingEnabled()
```
    Returns whether the soft cache is enabled or not.
    If the soft cache is enabled all tiles that have been retrieved will be cached, even those outside the view, as long as there is enough memory available.
    The soft cache is disabled by default.
    
    Returns:
    
    true if the soft cache is enabled
    
    See Also:
    
    setCacheSize(int)
  - setSoftCachingEnabled
```
public void setSoftCachingEnabled(boolean aSoftCachingEnabled)
```
    Enables or disables the soft cache.
    
    Parameters:
    
    aSoftCachingEnabled - whether the soft cache should be enabled
    
    See Also:
    
    isSoftCachingEnabled()
  - setPaintCache
```
public void setPaintCache(boolean aCache)
```
    Specifies whether this painter should cache the warped raster images it has painted. Caching it may improve performance if it can be reused but increases memory usage. The default is false.
    This property is only relevant for rasters that have to be warped, that is, when the model reference of the raster is different from the world reference of the view.
  - getPaintCache
```
public boolean getPaintCache()
```
    Returns whether this painter caches the warped raster images it has painted.
    
    See Also:
    
    setPaintCache(boolean)
  - setUpdateInterval
```
public void setUpdateInterval(long aTime)
```
    Sets the time between two updates for a tile.
    
    Parameters:
    
    aTime - the time in milliseconds
    
    See Also:
    
    getUpdateInterval()
  - getUpdateInterval
```
public long getUpdateInterval()
```
    Returns the time between two updates for a tile.
    The tiles in the internal cache and the soft cache will be updated by invoking ILcdEarthTileSet.updateTile(com.luciad.earth.tileset.ALcdEarthTile, com.luciad.earth.tileset.TLcdEarthTileOperationMode, com.luciad.earth.tileset.ILcdEarthTileSetCallback, java.lang.Object) if they are older than this time. The tiles will never be updated automatically if Long.MAX_VALUE is set as the time. The tiles will be updated continuously if 0 is set as the time.
    The default time is 1 minute.
    
    Returns:
    
    the time in milliseconds
  - isAllowOutdatedTiles
```
public boolean isAllowOutdatedTiles()
```
    Returns whether outdated tiles may be returned if an exception occurs while retrieving a tile.
    If enabled, any cached version of the requested tile may be returned if an exception occurs. Otherwise the tile will not be painted.
    The default value is true.
    
    Returns:
    
    true if outdated tiles may be returned if an exception occurs while retrieving a tile
  - setAllowOutdatedTiles
```
public void setAllowOutdatedTiles(boolean aAllowOutdatedTiles)
```
    Sets whether outdated tiles may be returned if an exception occurs while retrieving a tile.
    
    Parameters:
    
    aAllowOutdatedTiles - true if outdated tiles may be returned if an exception occurs while retrieving a tile
    
    See Also:
    
    isAllowOutdatedTiles()
  - getQuality
```
public double getQuality()
```
    Returns the current painting quality.
    
    Returns:
    
    the current painting quality
    
    See Also:
    
    setQuality(double)
  - setQuality
```
public void setQuality(double aQuality)
```
    Sets the quality of the painted result. The quality influences how quickly the level of detail changes when zooming in or out. The value should be between 0 and 1. A value of 1 means that the tile level is chosen such that each pixel in the view maps to at least one raster value, if possible. This avoids pixelation effects (e.g. that individual pixels are visible). A value of 0.25 means that 4 pixels in the view will map to one raster value on average. A value of 0 means that you only the least detailed level will be painted.
    The default value is 1.0.
    
    Parameters:
    
    aQuality - the new quality
  - setExceptionHandler
```
public void setExceptionHandler(ILcdExceptionHandler aExceptionHandler)
```
    Description copied from class: ALcdEarthGXYPainter
    
    Sets the exception handler that is used to handle exceptions that occur during tile retrieval.
    
    Overrides:
    
    setExceptionHandler in class ALcdEarthGXYPainter
    
    Parameters:
    
    aExceptionHandler - the exception handler
  - setStartResolutionFactor
```
public void setStartResolutionFactor(double aStartResolutionFactor)
```
    Sets the highest pixel density (number of raster pixels per screen pixel) at which a tile set is painted. If the pixel density is too high, the bounds may be painted instead. This can avoid having to load a large number of tiles to fill a relatively small view.
    The default value is Double.POSITIVE_INFINITY which result in always painting the tiles.
    
    Parameters:
    
    aStartResolutionFactor - the start resolution factor
    
    See Also:
    
    setPaintBoundsOutline(boolean), setPaintBoundsFill(boolean)
  - getStartResolutionFactor
```
public double getStartResolutionFactor()
```
    Returns the highest pixel density (number of raster pixels per screen pixel) at which a tile set is painted.
    
    Returns:
    
    the start resolution factor
    
    See Also:
    
    setStartResolutionFactor(double)
  - isParentTileRequestAllowed
```
public boolean isParentTileRequestAllowed()
```
    Returns whether a request for parent tiles may be made when tiles are requested.
    
    Returns:
    
    whether the parent tiles of the visible tiles may be requested
    
    Since:
    
    2018.0
    
    See Also:
    
    setParentTileRequestAllowed(boolean)
  - setParentTileRequestAllowed
```
public void setParentTileRequestAllowed(boolean aParentTileRequestAllowed)
```
    Sets whether parent tiles of the visible tiles may be requested. This is true by default, because it benefits user experience (e.g. data is immediately available when zooming out). Disabling this might be required to support stringent operation conditions that require the minimum possible amount of tile requests; in this case, only the visible tiles will be requested.
    
    Parameters:
    
    aParentTileRequestAllowed - whether the parent tiles of the visible tiles may be requested
    
    Since:
    
    2018.0
  - setPaintBoundsOutline
```
public void setPaintBoundsOutline(boolean aPaint)
```
    Sets whether the outline of the bounds of a tile set is painted when the pixel density is too high.
    Note that if this flag is set to true then the bounds line style must be valid.
    The default value is true.
    
    Parameters:
    
    aPaint - true if the outline of the bounds of a tile set should be painted.
    
    See Also:
    
    setBoundsLineStyle(com.luciad.view.gxy.ILcdGXYPainterStyle), setStartResolutionFactor(double)
  - setPaintBoundsFill
```
public void setPaintBoundsFill(boolean aPaint)
```
    Sets whether the fill of the bounds of a tile set is painted when the pixel density is too high.
    Note that if this flag is set to true then the bounds fill style must be valid.
    The default value is true.
    
    Parameters:
    
    aPaint - true if the fill of the bounds of a tile set should be painted.
    
    See Also:
    
    setBoundsFillStyle(com.luciad.view.gxy.ILcdGXYPainterStyle), setStartResolutionFactor(double)
  - isPaintBoundsOutline
```
public boolean isPaintBoundsOutline()
```
    Returns whether the outline of the bounds of a tile set is painted.
    
    Returns:
    
    whether the outline of the bounds of a tile set is painted.
    
    See Also:
    
    setPaintBoundsOutline(boolean)
  - isPaintBoundsFill
```
public boolean isPaintBoundsFill()
```
    Returns whether the fill of the bounds of a tile set is painted.
    
    Returns:
    
    whether the fill of the bounds of a tile set is painted.
    
    See Also:
    
    setPaintBoundsFill(boolean)
  - setBoundsLineStyle
```
public void setBoundsLineStyle(ILcdGXYPainterStyle aLineStyle)
```
    Sets the style that is used when painting the outline of the bounds of tile set. If the outline style is set to null and paint bounds outline is enabled the result visual result on screen is undefined.
    The default value is a red line style.
    
    Parameters:
    
    aLineStyle - the line style to use
    
    See Also:
    
    setPaintBoundsOutline(boolean)
  - setBoundsFillStyle
```
public void setBoundsFillStyle(ILcdGXYPainterStyle aFillStyle)
```
    Sets the style that is used when painting the fill of the bounds of tile set. If the fill style is set to null and paint bounds fill is enabled the result visual result on screen is undefined.
    The default value is a red hatched fill style.
    
    Parameters:
    
    aFillStyle - the fill style to use
    
    See Also:
    
    setPaintBoundsFill(boolean)
  - getBoundsLineStyle
```
public ILcdGXYPainterStyle getBoundsLineStyle()
```
    Returns the style that is used when painting the outline of the bounds of tile set.
    
    Returns:
    
    the line style
    
    See Also:
    
    setBoundsLineStyle(com.luciad.view.gxy.ILcdGXYPainterStyle)
  - getBoundsFillStyle
```
public ILcdGXYPainterStyle getBoundsFillStyle()
```
    Returns the style that is used when painting the fill of the bounds of tile set.
    
    Returns:
    
    the fill style
    
    See Also:
    
    setBoundsFillStyle(com.luciad.view.gxy.ILcdGXYPainterStyle)
  - getTileContext
```
public TLcdEarthTileContext getTileContext(Object aObject)
```
    Returns the tile context for the most recent paint of an object.
    This method may return null if the specified object has never been painted, if its cache as been cleared.
    The set of painted tiles may or may not contain some painted tiles if they are no longer available (for example due to garbage collection).
    The returned map will never change and is thread-safe for reading.
    
    Parameters:
    
    aObject - the object
    
    Returns:
    
    the context or null
  - setObject
```
public void setObject(Object aObject)
```
    Sets the tile set to the specified object, chooses a coverage in it and chooses a tile format.
    
    Specified by:
    
    setObject in interface ILcdGXYPainter
    
    Overrides:
    
    setObject in class ALcdEarthGXYPainter
    
    Parameters:
    
    aObject - the object for which the representation shall be handled by this painter.
    
    See Also:
    
    ILcdGXYPainter.getObject()
  - getTileSet
```
protected ILcdEarthTileSet getTileSet(Object aObject)
```
    The first time the tile set for an object is retrieved this base tile set is configured and then wrapped with an asynchronous tile set to ensure smooth painting.
    
    Overrides:
    
    getTileSet in class ALcdEarthGXYPainter
    
    Parameters:
    
    aObject - the object being painted
    
    Returns:
    
    the tile set
  - configureBaseTileSet
```
protected ILcdEarthTileSet configureBaseTileSet(Object aObject,
                                                ILcdEarthTileSet aTileSet)
```
    Configures the base tile set.
    The default implementation just returns the base tile set.
    This method can be overridden to add custom tile set wrappers to the tile set.
    
    Parameters:
    
    aObject - the object being painted
    
    aTileSet - the base tile set
    
    Returns:
    
    the configured tile set
    
    See Also:
    
    chooseTileSetCoverage(com.luciad.earth.tileset.ILcdEarthTileSet), getTileSet(Object)
  - createAsynchronousTileSet
```
protected ILcdEarthTileSet createAsynchronousTileSet(Object aObject,
                                                     ILcdEarthTileSet aTileSet)
```
    Creates a tile set that can produce tiles asynchronously.
    The default implementation creates a new asynchronous tile set that uses 1 thread for tile production unless the tile set already is an asynchronous tile set.
    
    Parameters:
    
    aObject - the object being painted
    
    aTileSet - the tile set
    
    Returns:
    
    the asynchronous tile set
    
    See Also:
    
    TLcdEarthAsynchronousTileSet, getTileSet(Object)
  - getRequestFormat
```
protected TLcdEarthTileFormat getRequestFormat()
```
    Returns the tile format used to request tiles.
    
    Returns:
    
    the tile format used to request tiles.
  - chooseTileSetCoverage
```
protected ILcdEarthTileSetCoverage chooseTileSetCoverage(ILcdEarthTileSet aTileSet)
```
    Chooses a coverage from the given tile set to be drawn by this painter.
    The default implementation returns the first coverage that is valid.
    
    Specified by:
    
    chooseTileSetCoverage in class ALcdEarthGXYPainter
    
    Parameters:
    
    aTileSet - the tile set whose tiles are being painted
    
    Returns:
    
    the coverage from which tiles should be obtained
    
    See Also:
    
    isValidCoverage(com.luciad.earth.tileset.ILcdEarthTileSetCoverage)
  - isValidCoverage
```
protected boolean isValidCoverage(ILcdEarthTileSetCoverage aCoverage)
```
    Returns whether the given coverage can be drawn by this painter. The returned coverage should support a format that can be handled by createRasterTile(com.luciad.earth.tileset.ALcdEarthTile).
    The default implementation returns true if the coverage is a raster coverage and the tiles set supports a format with RenderedImage as format class and no format name with the specified coverage.
    
    Parameters:
    
    aCoverage - the candidate coverage
    
    Returns:
    
    true if the given coverage can be painted
    
    See Also:
    
    ILcdEarthRasterTileSetCoverage, ILcdEarthTileSet.isFormatSupported(com.luciad.earth.tileset.ILcdEarthTileSetCoverage, com.luciad.earth.tileset.TLcdEarthTileFormat)
  - chooseTileFormat
```
protected TLcdEarthTileFormat chooseTileFormat(ILcdEarthTileSet aTileSet,
                                               ILcdEarthTileSetCoverage aCoverage)
```
    Chooses a tile format from the given tile set and coverage to be used for producing tiles. The format should be supported by createRasterTile(com.luciad.earth.tileset.ALcdEarthTile).
    The default implementation returns a format with RenderedImage as format class and no format name.
    
    Parameters:
    
    aTileSet - the tile set whose tiles are being painted
    
    aCoverage - the coverage whose tiles are being painted.
    
    Returns:
    
    the format in which tiles should be obtained
  - paint
```
public void paint(Graphics aGraphics,
                  int aMode,
                  ILcdGXYContext aContext)
```
    Description copied from interface: ILcdGXYPainter
    Displays the representation of the object in the given mode on the Graphics passed, taking into account the supplied context.
    The visual representation of an object depends on the context. Depending on the context (e.g. is the location covered by the view), an object may or may not have a representation. The context contains:
    - transformations which allow to compute the location in view space of points and bounds given in model, space
    - a pen which can connect points with a line or create arcs around a point,
    - the view for which the object's representation must be painted. This can be useful when the painted object depends on the scale of the view, or the presence of other layers in the view.
    - the current location(s) of the mouse or input device and the last location(s) the mouse or input device was pressed.
    The mode passed in this method indicates what part of the object must be painted, whether it should be painted as selected or not, and whether user interaction (via mouse movements) must be taken into account.
    
    When the mode passed contains either TRANSLATING, RESHAPING or CREATING, this method is also responsible for interpreting interaction on the representation of an object and modifying the representation of the object accordingly. The painter is not responsible for modifying the object itself, this is done by a corresponding ILcdGXYEditor . Implementations of ILcdGXYPainter and ILcdGXYEditor interfaces must be consistent for an object: the painter must display the result of the user interaction on the object, while the editor is responsible for modifying the object as a result of the user interaction. A good practice to ensure a consistent implementation is to implement both the ILcdGXYPainter and ILcdGXYEditor interfaces in a single class.
    
    When the mode passed includes SNAPS, the part of the representation which corresponds to the object returned as snap target by the method snapTarget must be painted in order to provide the user with a visual indication of the snap target.
    
    The Graphics passed in this method can be different from the Graphics returned by a view due to techniques such as double buffering (as applied in Swing). Basic drawing operations must always be performed on the Graphics passed as an argument in this method.
    Specified by:
    
    paint in interface ILcdGXYPainter
    
    Parameters:
    
    aGraphics - the Graphics on which the representation of the object is painted
    
    aMode - the mode the object is represented in (see class documentation).
    
    aContext - the ILcdGXYContext the drawing depends on.
  - chooseTileSetLevel
```
protected int chooseTileSetLevel(Graphics aGraphics,
                                 int aMode,
                                 ILcdGXYContext aContext,
                                 ILcdBounds aViewModelBounds)
```
    Called by paint(java.awt.Graphics, int, com.luciad.view.gxy.ILcdGXYContext) to choose the level in the tile set that should be painted. Note that tiles at lower levels may still be painted (ex. if some tiles at the desired level are not available).
    The default implementation chooses a level such that each pixel in the view maps to at least one raster value, if possible. If the pixel density of the least detailed level is too high then -1 is returned.
    
    Parameters:
    
    aGraphics - the graphics
    
    aMode - the mode
    
    aContext - the context
    
    aViewModelBounds - the bounds of the view in model coordinates
    
    Returns:
    
    the level that should be painted or -1 if the bounds should be painted instead
  - getEmptyTile
```
protected ILcdTile getEmptyTile()
```
    Returns a representative empty tile for this painter. For example, the tile's default value may be used when painting missing data.
    
    Returns:
    
    an empty tile.
    
    Since:
    
    2022.0
  - createRasterTile
```
protected ILcdTile createRasterTile(ALcdEarthTile aTile)
```
    Creates an ILcdTile corresponding to the specified ALcdEarthTile. The resulting raster tile is used in order to draw the output of a tile set using TLcdRasterPainter.
    The default implementation can only create a tile for tiles with a RenderedImage as tile data.
    
    Parameters:
    
    aTile - the tile to convert into a raster tile
    
    Returns:
    
    a raster tile
  - getPixelDensity
```
protected double getPixelDensity(int aLevel)
```
    Returns the pixel density of the data (in the tile set reference) at the given level.
    The default implementation assumes that the coverage is a ILcdEarthRasterTileSetCoverage and returns its pixel density at the specified level.
    
    Parameters:
    
    aLevel - a level
    
    Returns:
    
    the pixel density
    
    See Also:
    
    ILcdEarthRasterTileSetCoverage.getPixelDensity(int)
  - getDisplayName
```
public String getDisplayName()
```
    Description copied from class: ALcdGXYPainter
    
    Returns the display name of this ILcdGXYPainter.
    
    Specified by:
    
    getDisplayName in interface ILcdGXYPainter
    
    Overrides:
    
    getDisplayName in class ALcdGXYPainter
    
    Returns:
    
    the name that has been set using setDisplayName(), or this.toString() if no name has been set.
  - clone
```
public Object clone()
```
    Description copied from interface: ILcdCloneable
    Makes Object.clone() public.
    When for example extending from java.lang.Object, it can be implemented like this:
```
 public Object clone() {
   try {
     return super.clone();
   } catch ( CloneNotSupportedException e ) {
     // Cannot happen: extends from Object and implements Cloneable (see also Object.clone)
     throw new RuntimeException( e );
   }
 }
 
```
    Specified by:
    
    clone in interface ILcdCloneable
    
    Specified by:
    
    clone in interface ILcdGXYPainterProvider
    
    Overrides:
    
    clone in class ALcdEarthGXYPainter
    
    Returns:
    
    a clone of this painter provider.
    
    See Also:
    
    Object.clone()
  - addStatusListener
```
public void addStatusListener(ILcdStatusListener aStatusListener)
```
    Description copied from interface: ILcdStatusSource
    
    Registers the given listener so it will receive status events from this source.
    
    In case you need to register a listener which keeps a reference to an object with a shorter life-time than this status source, you can use a ALcdWeakStatusListener instance as status listener.
    
    Specified by:
    
    addStatusListener in interface ILcdStatusSource
    
    Parameters:
    
    aStatusListener - The listener to be notified when the status has changed.
  - removeStatusListener
```
public void removeStatusListener(ILcdStatusListener aStatusListener)
```
    Description copied from interface: ILcdStatusSource
    
    Removes the specified listener so it is no longer notified.
    
    Specified by:
    
    removeStatusListener in interface ILcdStatusSource
    
    Parameters:
    
    aStatusListener - The listener to remove.

LuciadLightspeedClass TLcdEarthGXYRasterPainter

Supported objects

Visualization

Incremental visualization

Caching

Performance considerations

Field Summary

Fields inherited from class com.luciad.view.gxy.ALcdGXYPainter

Fields inherited from interface com.luciad.view.gxy.ILcdGXYPainter

Constructor Summary

Method Summary

Methods inherited from class com.luciad.earth.view.gxy.ALcdEarthGXYPainter

Methods inherited from class com.luciad.view.gxy.ALcdGXYPainter

Methods inherited from class java.lang.Object

Constructor Detail

TLcdEarthGXYRasterPainter

TLcdEarthGXYRasterPainter

Method Detail

getColorModel

setColorModel

getRGBImageFilter

setRGBImageFilter

getTransparency

setTransparency

getBrightness

setBrightness

getContrast

setContrast

setWarpBlockSize

getWarpBlockSize

setOversamplingRate

getOversamplingRate

getCacheSize

setCacheSize

clearCache

clearCache

releaseHardReferencedCache

releaseHardReferencedCache

setAsynchronousTileRequestAllowed

setRepaintViewWhenTileAvailable

updateTiles

updateTiles

isAutoIncreaseCacheSize

setAutoIncreaseCacheSize

isSoftCachingEnabled

setSoftCachingEnabled

setPaintCache

getPaintCache

setUpdateInterval

getUpdateInterval

isAllowOutdatedTiles

setAllowOutdatedTiles

getQuality

setQuality

setExceptionHandler

setStartResolutionFactor

getStartResolutionFactor

isParentTileRequestAllowed

setParentTileRequestAllowed

setPaintBoundsOutline

setPaintBoundsFill

isPaintBoundsOutline

isPaintBoundsFill

setBoundsLineStyle

setBoundsFillStyle

getBoundsLineStyle

getBoundsFillStyle

getTileContext

setObject

getTileSet

configureBaseTileSet

createAsynchronousTileSet

getRequestFormat

chooseTileSetCoverage

isValidCoverage

chooseTileFormat

paint

chooseTileSetLevel

getEmptyTile

createRasterTile