Package noaa.coastwatch.util.chunk


package noaa.coastwatch.util.chunk

Provides classes for holding and processing arbitrary chunks of data of various native types. Chunks have some similarities to tiles (see noaa.coastwatch.io.tile) but broader functionality.

  • Class
    Description
    The ByteChunk class holds primitive byte data with optional packing scheme and missing values.
    The ChunkCollector class assembles chunks from a list of producers and allows them to be accessed in one operation.
    The ChunkComputation class can be used to perform a computation on a set of input data chunks using a function and a list of chunk producers/consumers.
    The ChunkConsumer interface is implemented by all classes that consume data chunks.
    The ChunkDataAccessor class is a visitor that makes (possibly unpacked) data values available from any type of DataChunk instance.
    Performs data type casting operations to and from DataChunk objects.
    The ChunkDataCopier class copies raw data values between DataChunk instances.
    The ChunkDataFlagger class is a visitor that modifies any type of DataChunk instance by flagging specific data values as missing.
    The ChunkDataModifier class is a visitor that modifies data values in any type of DataChunk instance.
    The ChunkFunction interface is to be implemented by any class that performs some type of processing on a set of input data chunks to produce an output chunk.
    The ChunkingScheme class describes an overall set of chunks that fill an n-dimensional space and allows for iteration over the set.
    The ChunkOperation interface is implemented by any class that performs some unit of work on the chunk or chunks at a given position.
    The ChunkPosition class marks a position within a ChunkingScheme.
    The ChunkProducer interface is implemented by all classes that produce a data chunk on demand.
    The ChunkResampler class performs a resampling of 2D chunk data from a source coordinate system to a destination.
    The ChunkVisitor interface is implemented by any class that perticipates in the visitor pattern to perform operations on DataChunk instances.
    The CompositeFunction class implements a composite function that takes many chunks and collapses them into just one chunk using a reduction operator.
    The DataChunk interface is implemented by concrete classes that hold data of a specific internal primitive type.
    The enumeration of the possible chunk external data types.
    The DataChunkFactory class create appropriate instances of the DataChunk class using a primitive data array.
    The DoubleChunk class holds primitive double data with optional packing scheme and missing values.
    The DoublePackingScheme class implements a scale and offset packing scheme for primitive double data.
    The DoubleScalingScheme class implements a scale and offset for scaling double data.
    The ExpressionFunction class implements the ChunkFunction interface to perform mathematical expression calculations on chunk data.
    The FloatChunk class holds primitive float data with optional packing scheme and missing values.
    The FloatingPointValuedDataChunk interface is implemented by concrete classes that hold data of a specific primitive floating point type (float, double).
    The FloatPackingScheme class implements a scale and offset packing scheme for primitive float data.
    The FloatScalingScheme class implements a scale and offset for scaling float data.
    The GridChunkConsumer class consumes data chunks and places the chunk data into a Grid object.
    The GridChunkProducer class provides data chunks from a Grid object.
    The IntChunk class holds primitive int data with optional packing scheme and missing values.
    The IntegerValuedDataChunk interface is implemented by concrete classes that hold data of a specific primitive integer type (byte, short, int, long).
    The LongChunk class holds primitive long data with optional packing scheme and missing values.
    The PackingScheme interface is implemented by concrete classes that have a strategy to pack floating point data to integer data and unpack integer data to floating point data.
    The PackingSchemeVisitor interface is implemented by any class that participates in the visitor pattern to perform operations on PackingScheme instances.
    The ParallelChunkOperation interface is implemented by classes that perform a ChunkOperation on a set of chunk positions in parallel.
    The PoolProcessor class is a ParallelChunkOperation that operates using a pool of execution threads.
    The ResamplingOperation class performs a data resampling operation between pairs of ChunkProducer instances and ChunkConsumer instances.
    The ScalingScheme interface is implemented by concrete classes that have a way of scaling floating point data.
    The ScalingSchemeVisitor interface is implemented by any class that participates in the visitor pattern to perform operations on ScalingScheme instances.
    The ShortChunk class holds primitive short data with optional packing scheme and missing values.
    A SyntheticIntChunkProducer object creates 2D integer data chunks whose values are specified by a functional interface method that returns an integer value for each row and column in the chunk.
    The ValidChunkDetector class is a visitor that checks data chunks for missing values to determine if all the chunk's data values are missing, or if the chunk contains some valid data.