IO Handler for Isis Cubes using the tile format. More...

#include <CubeTileHandler.h>

Inheritance diagram for Isis::CubeTileHandler:

Collaboration diagram for Isis::CubeTileHandler:

Public Member Functions
	CubeTileHandler (QFile dataFile, const QList< int > virtualBandList, const Pvl &label, bool alreadyOnDisk)
	Construct a tile handler.

	~CubeTileHandler ()
	Writes all data from memory to disk.

void	updateLabels (Pvl &label)
	Update the cube labels so that this cube indicates what tile size it used.

virtual void	read (Buffer &bufferToFill) const
	Read cube data from disk into the buffer.

virtual void	write (const Buffer &bufferToWrite)
	Write buffer data into the cube data on disk.

virtual void	addCachingAlgorithm (CubeCachingAlgorithm *algorithm)
	This will add the given caching algorithm to the list of attempted caching algorithms.

virtual void	clearCache (bool blockForWriteCache=true) const
	Free all cube chunks (cached cube data) from memory and write them to disk.

virtual BigInt	getDataSize () const

int	bandCount () const

int	getBandCountInChunk () const

BigInt	getBytesPerChunk () const

int	getChunkCountInBandDimension () const

int	getChunkCountInLineDimension () const

int	getChunkCountInSampleDimension () const

int	getChunkIndex (const RawCubeChunk &) const
	Given a chunk, what's its index in the file.

BigInt	getDataStartByte () const

int	lineCount () const

int	getLineCountInChunk () const

PixelType	pixelType () const

int	sampleCount () const

int	getSampleCountInChunk () const

void	setVirtualBands (const QList< int > *virtualBandList)
	This changes the virtual band list.

QMutex *	dataFileMutex ()
	Get the mutex that this IO handler is using around I/Os on the given data file.

Protected Member Functions
virtual void	readRaw (RawCubeChunk &chunkToFill)
	This needs to populate the chunkToFill with unswapped raw bytes from the disk.

virtual void	writeRaw (const RawCubeChunk &chunkToWrite)
	This needs to write the chunkToWrite directly to disk with no modifications to the data itself.

QFile *	getDataFile ()

void	setChunkSizes (int numSamples, int numLines, int numBands)
	This should be called once from the child constructor.

Protected Attributes
QMutex *	m_writeThreadMutex
	This enables us to block while the write thread is working.

QList< int > *	m_virtualBands
	Converts from virtual band to physical band.

Private Member Functions
	CubeTileHandler (const CubeTileHandler &other)
	Disallow copying of this object.

CubeTileHandler &	operator= (const CubeTileHandler &other)
	Disallow assignments of this object.

int	findGoodSize (int maxSize, int dimensionSize) const
	This is a helper method that tries to compute a good tile size for one of the cube's dimensions (sample or line).

BigInt	getTileStartByte (const RawCubeChunk &chunk) const
	This is a helper method that goes from chunk to file position.

void	blockUntilThreadPoolEmpty () const
	This blocks (doesn't return) until the number of active runnables in the thread pool goes to 0.

QPair< QList< RawCubeChunk * >, QList< int > >	findCubeChunks (int startSample, int numSamples, int startLine, int numLines, int startBand, int numBands) const
	Get the cube chunks that correspond to the given cube area.

void	findIntersection (const RawCubeChunk &cube1, const Buffer &cube2, int &startX, int &startY, int &startZ, int &endX, int &endY, int &endZ) const
	Find the intersection between the buffer area and the cube chunk.

void	flushWriteCache (bool force=false) const
	This attempts to write the so-far-unwritten buffers from m_writeCache into the cube's RawCubeChunk cache.

void	freeChunk (RawCubeChunk *chunkToFree) const
	If the chunk is dirty, then we write it to disk.

RawCubeChunk *	getChunk (int chunkIndex, bool allocateIfNecessary) const
	Retrieve the cached chunk at the given chunk index, if there is one.

int	getChunkCount () const

void	getChunkPlacement (int chunkIndex, int &startSample, int &startLine, int &startBand, int &endSample, int &endLine, int &endBand) const
	Get the X/Y/Z (Sample,Line,Band) range of the chunk at the given index.

RawCubeChunk *	getNullChunk (int chunkIndex) const
	This creates a chunk filled with NULLs whose placement is at chunkIndex's position.

void	minimizeCache (const QList< RawCubeChunk * > &justUsed, const Buffer &justRequested) const
	Apply the caching algorithms and get rid of excess cube data in memory.

void	synchronousWrite (const Buffer &bufferToWrite)
	This method takes the given buffer and synchronously puts it into the Cube's cache.

void	writeIntoDouble (const RawCubeChunk &chunk, Buffer &output, int startIndex) const
	Write the intersecting area of the chunk into the buffer.

void	writeIntoRaw (const Buffer &buffer, RawCubeChunk &output, int index) const
	Write the intersecting area of the buffer into the chunk.

void	writeNullDataToDisk () const
	Write all NULL cube chunks that have not yet been accessed to disk.

Static Private Member Functions
static bool	bufferLessThan (Buffer const &lhs, Buffer const &rhs)
	This is used for sorting buffers into the most efficient write order.

Private Attributes
QFile *	m_dataFile
	The file containing cube data.

BigInt	m_startByte
	The start byte of the cube data.

PixelType	m_pixelType
	The format of each DN in the cube.

double	m_base
	The additive offset of the data on disk.

double	m_multiplier
	The multiplicative factor of the data on disk.

ByteOrder	m_byteOrder
	The byte order (endianness) of the data on disk.

EndianSwapper *	m_byteSwapper
	A helper that swaps byte order to and from file order.

int	m_numSamples
	The number of samples in the cube.

int	m_numLines
	The number of lines in the cube.

int	m_numBands
	The number of physical bands in the cube.

QList< CubeCachingAlgorithm * > *	m_cachingAlgorithms
	The caching algorithms to use, in order of priority.

QMap< int, RawCubeChunk * > *	m_rawData
	The map from chunk index to chunk for cached data.

QMap< int, bool > *	m_dataIsOnDiskMap
	The map from chunk index to on-disk status, all true if not allocated.

int	m_samplesInChunk
	The number of samples in a cube chunk.

int	m_linesInChunk
	The number of lines in a cube chunk.

int	m_bandsInChunk
	The number of physical bands in a cube chunk.

QList< RawCubeChunk * > *	m_lastProcessByLineChunks
	This is an optimization for process by line.

QByteArray *	m_nullChunkData
	A raw cube chunk's data when it was all NULL's. Used for speed.

QPair< QMutex , QList< Buffer > > *	m_writeCache
	These are the buffers we need to write to raw cube chunks.

QThreadPool *	m_ioThreadPool
	This contains threads for doing cube writes (and later maybe cube reads).

bool	m_lastOperationWasWrite
	If the last operation was a write then we need to flush the cache when reading.

bool	m_useOptimizedCubeWrite
	This is true if the Isis preference for the cube write thread is optimized.

volatile int	m_idealFlushSize
	Ideal write cache flush size.

int	m_consecutiveOverflowCount
	How many times the write cache has overflown in a row.

Detailed Description

IO Handler for Isis Cubes using the tile format.

This class is used to open, create, read, and write data from Isis cube files.

Author: 2003-02-14 Jeff Anderson

History

2007-09-14 Stuart Sides - Fixed bug where pixels from a buffer outside the ns/nl were being transfered to the right most and bottom most tiles

2011-06-16 Jai Rideout and Steven Lambright - Refactored to work with the new parent.

2011-07-18 Jai Rideout and Steven Lambright - Added unimplemented copy constructor and assignment operator.

Definition at line 35 of file CubeTileHandler.h.

Constructor & Destructor Documentation

◆ CubeTileHandler() [1/2]

Isis::CubeTileHandler::CubeTileHandler	(	QFile *	dataFile,
		const QList< int > *	virtualBandList,
		const Pvl &	labels,
		bool	alreadyOnDisk )

Construct a tile handler.

This will determine a good chunk size to put into the output cube.

Parameters

dataFile	The file with cube DN data in it
virtualBandList	The mapping from virtual band to physical band, see CubeIoHandler's description.
labels	The Pvl labels for the cube
alreadyOnDisk	True if the cube is allocated on the disk, false otherwise

Definition at line 32 of file CubeTileHandler.cpp.

References Isis::CubeIoHandler::CubeIoHandler().

Referenced by CubeTileHandler(), and operator=().

◆ ~CubeTileHandler()

Isis::CubeTileHandler::~CubeTileHandler ( )

Writes all data from memory to disk.

Definition at line 56 of file CubeTileHandler.cpp.

References Isis::CubeIoHandler::clearCache().

◆ CubeTileHandler() [2/2]

Isis::CubeTileHandler::CubeTileHandler ( const CubeTileHandler & other )

private

Disallow copying of this object.

Parameters

other The object to copy.

References CubeTileHandler().

Member Function Documentation

◆ addCachingAlgorithm()

void Isis::CubeIoHandler::addCachingAlgorithm ( CubeCachingAlgorithm * algorithm )

virtualinherited

This will add the given caching algorithm to the list of attempted caching algorithms.

The algorithms are tried in the opposite order that they were added - the first algorithm added is the last algorithm tried.

This method takes ownership of algorithm.

Parameters

algorithm The caching algorithm to add to the Cube for I/O

Reimplemented from Isis::ImageIoHandler.

Definition at line 355 of file CubeIoHandler.cpp.

References m_cachingAlgorithms.

◆ bandCount()

int Isis::CubeIoHandler::bandCount ( ) const

inherited

Returns: the number of physical bands in the cube.

Definition at line 422 of file CubeIoHandler.cpp.

References m_numBands.

Referenced by findCubeChunks().

◆ blockUntilThreadPoolEmpty()

void Isis::CubeIoHandler::blockUntilThreadPoolEmpty ( ) const

privateinherited

This blocks (doesn't return) until the number of active runnables in the thread pool goes to 0.

This uses the m_writeThreadMutex, because the thread pool doesn't delete threads immediately, so runnables might actually still exist but are inconsequential/being deleted already.

Definition at line 627 of file CubeIoHandler.cpp.

References m_ioThreadPool, and Isis::ImageIoHandler::m_writeThreadMutex.

Referenced by flushWriteCache().

◆ bufferLessThan()

bool Isis::CubeIoHandler::bufferLessThan	(	Buffer *const &	lhs,
		Buffer *const &	rhs )

staticprivateinherited

This is used for sorting buffers into the most efficient write order.

Parameters

lhs	The left hand side of the '<' operator
rhs	The right hand side of the '<' operator

Returns: True if lhs is obviously earlier in a cube than rhs.

Definition at line 641 of file CubeIoHandler.cpp.

References Isis::Buffer::Band(), Isis::Buffer::BandDimension(), Isis::Area3D::intersect(), Isis::Area3D::isValid(), Isis::Buffer::Line(), Isis::Buffer::LineDimension(), Isis::Displacement::Pixels, Isis::Distance::Pixels, Isis::Buffer::Sample(), and Isis::Buffer::SampleDimension().

◆ clearCache()

void Isis::CubeIoHandler::clearCache ( bool blockForWriteCache = true ) const

virtualinherited

Free all cube chunks (cached cube data) from memory and write them to disk.

Child destructors need to call this method.

This method should only be called otherwise when lots of cubes are in memory and the many caches cause problems with system RAM limitations.

Parameters

blockForWriteCache This should be true unless this method is called from the write thread.

Reimplemented from Isis::ImageIoHandler.

Definition at line 370 of file CubeIoHandler.cpp.

References CubeIoHandler(), flushWriteCache(), m_dataIsOnDiskMap, m_lastProcessByLineChunks, m_rawData, writeNullDataToDisk(), and writeRaw().

Referenced by minimizeCache(), Isis::CubeBsqHandler::~CubeBsqHandler(), and Isis::CubeTileHandler::~CubeTileHandler().

◆ dataFileMutex()

QMutex * Isis::ImageIoHandler::dataFileMutex ( )

inherited

Get the mutex that this IO handler is using around I/Os on the given data file.

A lock should be acquired before doing any reads/writes on the data file externally.

Returns: A mutex that can guarantee exclusive access to the data file

Definition at line 58 of file ImageIoHandler.cpp.

References m_writeThreadMutex.

◆ findCubeChunks()

QPair< QList< RawCubeChunk * >, QList< int > > Isis::CubeIoHandler::findCubeChunks	(	int	startSample,
		int	numSamples,
		int	startLine,
		int	numLines,
		int	startBand,
		int	numBands ) const

privateinherited

Get the cube chunks that correspond to the given cube area.

This will create and initialize the chunks if they are not already in memory.

Parameters

startSample	The starting sample of the cube data
numSamples	The number of samples of cube data
startLine	The starting line of the cube data
numLines	The number of lines of cube data
startBand	The starting band of the cube data
numBands	The number of bands of cube data

Returns: The cube chunks that correspond to the given cube area

The user has requested a slice of a cube (a rectangle):

Cube
-----—

| | | <---------— Requested Area | | | | | -----— |

| |

But our cube is split into "chunks" which may not line up to what was requested:

| | | || |------------------—|| | -----— | || |—|---—|-------—|| (User requested area intersected with | | | | | || cube chunks) |------------------—||

| | | ||

| 1 | 2 | 3 || |------------------—|| | 4 | 5 | 6 || |------------------—|| (User requested area intersected with | 7 | 8 | 9 || cube chunks) |------------------—||

| 10 | 11 | 12 ||

(In this case we want chunks 4, 5, 7, and 8)

So we want to find which cube chunks line up to the requested area. To do this, we find which chunk intersects the top left of the requested cube area. That chunk is a given that we need it. Then we search in the positive X direction for more chunks that intersect the user-requested area until we no longer do. Then we know all of the chunks that intersect a whole y-range of the requested area. We shrink the requested area (remove the found y-range) and repeat.

Definition at line 690 of file CubeIoHandler.cpp.

References bandCount(), getChunk(), getChunkCountInLineDimension(), getChunkCountInSampleDimension(), lineCount(), m_bandsInChunk, m_linesInChunk, m_samplesInChunk, Isis::ImageIoHandler::m_virtualBands, and sampleCount().

Referenced by read(), and synchronousWrite().

◆ findGoodSize()

int Isis::CubeTileHandler::findGoodSize	(	int	maxSize,
		int	dimensionSize ) const

private

This is a helper method that tries to compute a good tile size for one of the cube's dimensions (sample or line).

Band tile size is always 1 for this format currently.

Parameters

maxSize	The largest allowed size
dimensionSize	The cube's size in the dimension we're figuring out (that is, number of samples or number of lines).

Returns: The tile size that should be used for the dimension

Definition at line 135 of file CubeTileHandler.cpp.

◆ findIntersection()

void Isis::CubeIoHandler::findIntersection	(	const RawCubeChunk &	cube1,
		const Buffer &	cube2,
		int &	startX,
		int &	startY,
		int &	startZ,
		int &	endX,
		int &	endY,
		int &	endZ ) const

privateinherited

Find the intersection between the buffer area and the cube chunk.

This accounts for virtual bands when considering the buffer and may return an area where all of the bands don't actually intersect due to virtual bands. This is implemented the way it is for performance reasons - so much as returning an Area3D or a QList<int> caused undesirable slowdowns.

Parameters

cube1	The cube chunk to intersect
cube2	The buffer (in virtual band space) to intersect
startX	(output) The leftmost sample position (inclusive)
startY	(output) The topmost line position (inclusive)
startZ	(output) The frontmost band position (inclusive)
endX	(output) The rightmost sample position (inclusive)
endY	(output) The bottommost line position (inclusive)
endZ	(output) The backmost band position (inclusive)

Definition at line 835 of file CubeIoHandler.cpp.

References Isis::Buffer::Band(), Isis::RawCubeChunk::bandCount(), Isis::Buffer::BandDimension(), Isis::RawCubeChunk::getStartBand(), Isis::RawCubeChunk::getStartLine(), Isis::RawCubeChunk::getStartSample(), Isis::Buffer::Line(), Isis::RawCubeChunk::lineCount(), Isis::Buffer::LineDimension(), Isis::ImageIoHandler::m_virtualBands, Isis::Buffer::Sample(), Isis::RawCubeChunk::sampleCount(), and Isis::Buffer::SampleDimension().

Referenced by writeIntoDouble(), and writeIntoRaw().

◆ flushWriteCache()

void Isis::CubeIoHandler::flushWriteCache ( bool force = false ) const

privateinherited

This attempts to write the so-far-unwritten buffers from m_writeCache into the cube's RawCubeChunk cache.

This will not do anything if there is a runnable and will block if the write cache grows to be too large.

Parameters

force Set to true to force start a flush

Definition at line 900 of file CubeIoHandler.cpp.

References blockUntilThreadPoolEmpty(), CubeIoHandler(), m_consecutiveOverflowCount, m_idealFlushSize, m_ioThreadPool, m_lastOperationWasWrite, m_useOptimizedCubeWrite, m_writeCache, Isis::ImageIoHandler::m_writeThreadMutex, and synchronousWrite().

Referenced by clearCache(), read(), and write().

◆ freeChunk()

void Isis::CubeIoHandler::freeChunk ( RawCubeChunk * chunkToFree ) const

privateinherited

If the chunk is dirty, then we write it to disk.

Regardless, we then free it from memory.

Parameters

chunkToFree The chunk we're removing from memory

Definition at line 977 of file CubeIoHandler.cpp.

References CubeIoHandler(), getChunkIndex(), Isis::RawCubeChunk::isDirty(), m_lastProcessByLineChunks, m_rawData, and writeRaw().

Referenced by minimizeCache().

◆ getBandCountInChunk()

int Isis::CubeIoHandler::getBandCountInChunk ( ) const

inherited

Returns: the number of bands per chunk for this cube.

Definition at line 430 of file CubeIoHandler.cpp.

References m_bandsInChunk.

Referenced by getChunkIndex(), getChunkPlacement(), read(), and synchronousWrite().

◆ getBytesPerChunk()

BigInt Isis::CubeIoHandler::getBytesPerChunk ( ) const

inherited

Returns: the byte size of each chunk in the cube. Currently they must be constant size, but this is planned to be changed at some point in time.; Number of bytes in a cube chunk

Definition at line 442 of file CubeIoHandler.cpp.

References m_bandsInChunk, m_linesInChunk, m_pixelType, and m_samplesInChunk.

Referenced by getChunk(), Isis::CubeBsqHandler::getChunkStartByte(), getDataSize(), getNullChunk(), Isis::CubeTileHandler::getTileStartByte(), and minimizeCache().

◆ getChunk()

RawCubeChunk * Isis::CubeIoHandler::getChunk	(	int	chunkIndex,
		bool	allocateIfNecessary ) const

privateinherited

Retrieve the cached chunk at the given chunk index, if there is one.

Parameters

chunkIndex	The position of the chunk in the cube
allocateIfNecessary	If true, the chunk will be read into cache when necessary and this method will not return NULL.

Returns: NULL if data is not cached, otherwise the cube file data

Definition at line 1005 of file CubeIoHandler.cpp.

References CubeIoHandler(), getBytesPerChunk(), getChunkPlacement(), getNullChunk(), m_dataIsOnDiskMap, m_rawData, readRaw(), and Isis::RawCubeChunk::setDirty().

Referenced by findCubeChunks(), read(), and synchronousWrite().

◆ getChunkCount()

int Isis::CubeIoHandler::getChunkCount ( ) const

privateinherited

Returns: The number of chunks that are required to encapsulate all of the cube data

Definition at line 1046 of file CubeIoHandler.cpp.

References getChunkCountInBandDimension(), getChunkCountInLineDimension(), and getChunkCountInSampleDimension().

Referenced by writeNullDataToDisk().

◆ getChunkCountInBandDimension()

int Isis::CubeIoHandler::getChunkCountInBandDimension ( ) const

inherited

Returns: the total number of chunks in the band (Z) dimension. This is always enough to contain every band in the cube.

Definition at line 452 of file CubeIoHandler.cpp.

References m_bandsInChunk, and m_numBands.

Referenced by getChunkCount(), and getDataSize().

◆ getChunkCountInLineDimension()

int Isis::CubeIoHandler::getChunkCountInLineDimension ( ) const

inherited

Returns: the total number of chunks in the line (Y) dimension. This is always enough to contain every line in the cube.

Definition at line 461 of file CubeIoHandler.cpp.

References m_linesInChunk, and m_numLines.

Referenced by findCubeChunks(), getChunkCount(), getChunkIndex(), getChunkPlacement(), getDataSize(), read(), and synchronousWrite().

◆ getChunkCountInSampleDimension()

int Isis::CubeIoHandler::getChunkCountInSampleDimension ( ) const

inherited

Returns: the total number of chunks in the sample (X) dimension. This is always enough to contain every sample in the cube.

Definition at line 470 of file CubeIoHandler.cpp.

References m_numSamples, and m_samplesInChunk.

Referenced by findCubeChunks(), getChunkCount(), getChunkIndex(), getChunkPlacement(), getDataSize(), read(), and synchronousWrite().

◆ getChunkIndex()

int Isis::CubeIoHandler::getChunkIndex ( const RawCubeChunk & chunk ) const

inherited

Given a chunk, what's its index in the file.

Chunks are ordered from left to right, then top to bottom, then front to back (BSQ). The first chunk is at the top left of band 1 and is index 0, for example. In other words, this is going from the value of m_rawData to the key.

Chunks which sit outside of the cube entirely must not be passed into this method; the results will be wrong.

Returns: The chunk's index into the file

Definition at line 486 of file CubeIoHandler.cpp.

References getBandCountInChunk(), getChunkCountInLineDimension(), getChunkCountInSampleDimension(), getLineCountInChunk(), getSampleCountInChunk(), Isis::RawCubeChunk::getStartBand(), Isis::RawCubeChunk::getStartLine(), and Isis::RawCubeChunk::getStartSample().

Referenced by freeChunk(), Isis::CubeBsqHandler::getChunkStartByte(), and Isis::CubeTileHandler::getTileStartByte().

◆ getChunkPlacement()

void Isis::CubeIoHandler::getChunkPlacement	(	int	chunkIndex,
		int &	startSample,
		int &	startLine,
		int &	startBand,
		int &	endSample,
		int &	endLine,
		int &	endBand ) const

privateinherited

Get the X/Y/Z (Sample,Line,Band) range of the chunk at the given index.

Parameters

chunkIndex	The chunk number in the cube file
startSample	(output) The leftmost sample position (inclusive)
startLine	(output) The topmost line position (inclusive)
startBand	(output) The frontmost band position (inclusive)
endSample	(output) The rightmost sample position (inclusive)
endLine	(output) The bottommost line position (inclusive)
endBand	(output) The backmost band position (inclusive)

Definition at line 1064 of file CubeIoHandler.cpp.

References getBandCountInChunk(), getChunkCountInLineDimension(), getChunkCountInSampleDimension(), getLineCountInChunk(), and getSampleCountInChunk().

Referenced by getChunk(), getNullChunk(), read(), and synchronousWrite().

◆ getDataFile()

QFile * Isis::CubeIoHandler::getDataFile ( )

protectedinherited

Returns: the QFile containing cube data. This is what should be read from and written to.; The data file for I/O

Definition at line 515 of file CubeIoHandler.cpp.

References m_dataFile.

Referenced by Isis::CubeBsqHandler::readRaw(), Isis::CubeTileHandler::readRaw(), Isis::CubeBsqHandler::writeRaw(), and Isis::CubeTileHandler::writeRaw().

◆ getDataSize()

BigInt Isis::CubeIoHandler::getDataSize ( ) const

virtualinherited

Returns: the number of bytes that the cube DNs will take up. This includes padding caused by the cube chunks not aligning with the cube dimensions.

Implements Isis::ImageIoHandler.

Definition at line 412 of file CubeIoHandler.cpp.

References getBytesPerChunk(), getChunkCountInBandDimension(), getChunkCountInLineDimension(), and getChunkCountInSampleDimension().

Referenced by setChunkSizes().

◆ getDataStartByte()

BigInt Isis::CubeIoHandler::getDataStartByte ( ) const

inherited

Returns: the byte offset to the beginning of the cube data.

Definition at line 504 of file CubeIoHandler.cpp.

References m_startByte.

Referenced by Isis::CubeBsqHandler::getChunkStartByte(), Isis::CubeTileHandler::getTileStartByte(), and setChunkSizes().

◆ getLineCountInChunk()

int Isis::CubeIoHandler::getLineCountInChunk ( ) const

inherited

Returns: the number of lines in each chunk of the cube.

Definition at line 532 of file CubeIoHandler.cpp.

References m_linesInChunk.

Referenced by getChunkIndex(), getChunkPlacement(), read(), synchronousWrite(), and Isis::CubeTileHandler::updateLabels().

◆ getNullChunk()

RawCubeChunk * Isis::CubeIoHandler::getNullChunk ( int chunkIndex ) const

privateinherited

This creates a chunk filled with NULLs whose placement is at chunkIndex's position.

This is used for getting NULL-filled chunks the first time the chunk is requested.

Ownership of the return value is given to the caller.

Parameters

chunkIndex The chunk's index which provides it's positioning.

Returns: A chunk filled with nulls at the chunkIndex position

Definition at line 1096 of file CubeIoHandler.cpp.

References Isis::RawCubeChunk::bandCount(), getBytesPerChunk(), getChunkPlacement(), Isis::RawCubeChunk::getRawData(), Isis::RawCubeChunk::getStartBand(), Isis::RawCubeChunk::getStartLine(), Isis::RawCubeChunk::getStartSample(), Isis::RawCubeChunk::lineCount(), m_nullChunkData, Isis::RawCubeChunk::sampleCount(), Isis::Brick::SetBasePosition(), Isis::RawCubeChunk::setDirty(), Isis::RawCubeChunk::setRawData(), Isis::Buffer::size(), and writeIntoRaw().

Referenced by getChunk(), and writeNullDataToDisk().

◆ getSampleCountInChunk()

int Isis::CubeIoHandler::getSampleCountInChunk ( ) const

inherited

Returns: the number of samples in each chunk of the cube.

Definition at line 557 of file CubeIoHandler.cpp.

References m_samplesInChunk.

Referenced by getChunkIndex(), getChunkPlacement(), read(), synchronousWrite(), and Isis::CubeTileHandler::updateLabels().

◆ getTileStartByte()

BigInt Isis::CubeTileHandler::getTileStartByte ( const RawCubeChunk & chunk ) const

private

This is a helper method that goes from chunk to file position.

Parameters

chunk The chunk to locate in the file.

Returns: The position to start reading or writing at

Definition at line 163 of file CubeTileHandler.cpp.

References Isis::CubeIoHandler::getBytesPerChunk(), Isis::CubeIoHandler::getChunkIndex(), and Isis::CubeIoHandler::getDataStartByte().

Referenced by readRaw(), and writeRaw().

◆ lineCount()

int Isis::CubeIoHandler::lineCount ( ) const

inherited

Returns: the number of lines in the cube. This does not include lines created by the chunk overflowing the line dimension.

Definition at line 524 of file CubeIoHandler.cpp.

References m_numLines.

Referenced by Isis::CubeBsqHandler::CubeBsqHandler(), and findCubeChunks().

◆ minimizeCache()

void Isis::CubeIoHandler::minimizeCache	(	const QList< RawCubeChunk * > &	justUsed,
		const Buffer &	justRequested ) const

privateinherited

Apply the caching algorithms and get rid of excess cube data in memory.

This is intended to be called after every IO operation.

Parameters

justUsed	The cube chunks that were used in the IO operation that is calling this method.
justRequested	The buffer that was used in the IO operation that is calling this method.

Definition at line 1148 of file CubeIoHandler.cpp.

References Isis::CubeCachingAlgorithm::CacheResult::algorithmUnderstoodData(), clearCache(), freeChunk(), getBytesPerChunk(), Isis::CubeCachingAlgorithm::CacheResult::getChunksToFree(), m_cachingAlgorithms, m_rawData, and Isis::CubeCachingAlgorithm::recommendChunksToFree().

Referenced by read(), and synchronousWrite().

◆ operator=()

CubeTileHandler & Isis::CubeTileHandler::operator= ( const CubeTileHandler & other )

private

Disallow assignments of this object.

Parameters

other The CubeTileHandler on the right-hand side of the assignment that we are copying into *this.

Returns: A reference to *this.

References CubeTileHandler().

◆ pixelType()

PixelType Isis::CubeIoHandler::pixelType ( ) const

inherited

Returns: the physical cube DN format.

Definition at line 540 of file CubeIoHandler.cpp.

References m_pixelType.

Referenced by Isis::CubeBsqHandler::CubeBsqHandler().

◆ read()

void Isis::CubeIoHandler::read ( Buffer & bufferToFill ) const

virtualinherited

Read cube data from disk into the buffer.

This is not const because it caches the read cube chunks from the disk.

Parameters

bufferToFill The buffer to populate with cube data.

Implements Isis::ImageIoHandler.

Definition at line 217 of file CubeIoHandler.cpp.

References Isis::Buffer::Band(), Isis::Buffer::BandDimension(), findCubeChunks(), flushWriteCache(), getBandCountInChunk(), getChunk(), getChunkCountInLineDimension(), getChunkCountInSampleDimension(), getChunkPlacement(), getLineCountInChunk(), getSampleCountInChunk(), Isis::Buffer::Line(), Isis::Buffer::LineDimension(), m_bandsInChunk, m_ioThreadPool, m_lastOperationWasWrite, m_linesInChunk, m_rawData, m_samplesInChunk, m_useOptimizedCubeWrite, Isis::ImageIoHandler::m_virtualBands, Isis::ImageIoHandler::m_writeThreadMutex, minimizeCache(), Isis::Buffer::Sample(), Isis::Buffer::SampleDimension(), Isis::Buffer::size(), and writeIntoDouble().

◆ readRaw()

void Isis::CubeTileHandler::readRaw ( RawCubeChunk & chunkToFill )

protectedvirtual

This needs to populate the chunkToFill with unswapped raw bytes from the disk.

See also: CubeTileHandler::readRaw()

Parameters

chunkToFill The container that needs to be filled with cube data.

Implements Isis::CubeIoHandler.

Definition at line 77 of file CubeTileHandler.cpp.

References Isis::RawCubeChunk::getByteCount(), Isis::CubeIoHandler::getDataFile(), getTileStartByte(), and Isis::RawCubeChunk::setRawData().

◆ sampleCount()

int Isis::CubeIoHandler::sampleCount ( ) const

inherited

Returns: the number of samples in the cube. This does not include samples created by the chunk overflowing the sample dimension.

Definition at line 549 of file CubeIoHandler.cpp.

References m_numSamples.

Referenced by Isis::CubeBsqHandler::CubeBsqHandler(), findCubeChunks(), and synchronousWrite().

◆ setChunkSizes()

void Isis::CubeIoHandler::setChunkSizes	(	int	numSamples,
		int	numLines,
		int	numBands )

protectedinherited

This should be called once from the child constructor.

This determines the chunk sizes used for the cube and often should remain constant for a particular cube (BSQ, for example, doesn't need it to be constant but Tile does). These being large can cause excessive use of disk space that stores no cube data. These being large can also drastically increase the amount of RAM consumed.

Parameters

numSamples	The chunk size in the sample dimension
numLines	The chunk size in the line dimension
numBands	The chunk size in the band dimension

Definition at line 574 of file CubeIoHandler.cpp.

References getDataSize(), getDataStartByte(), m_bandsInChunk, m_dataFile, m_dataIsOnDiskMap, m_linesInChunk, and m_samplesInChunk.

Referenced by Isis::CubeBsqHandler::CubeBsqHandler().

◆ setVirtualBands()

void Isis::ImageIoHandler::setVirtualBands ( const QList< int > * virtualBandList )

inherited

This changes the virtual band list.

Parameters

virtualBandList A list where the indices are the vbands and the values are the physical bands. The values are 1-based. This can be specified as NULL, in which case the vbands are the physical bands. The virtual band list is copied (the pointer provided isn't remembered).

Definition at line 41 of file ImageIoHandler.cpp.

References m_virtualBands.

◆ synchronousWrite()

void Isis::CubeIoHandler::synchronousWrite ( const Buffer & bufferToWrite )

privateinherited

This method takes the given buffer and synchronously puts it into the Cube's cache.

This includes reading missing cache areas and freeing extra cache areas. This is what the non-threaded CubeIoHandler::write used to do.

Parameters

bufferToWrite The buffer we're writing into this cube, synchronously

Definition at line 1197 of file CubeIoHandler.cpp.

References Isis::Buffer::Band(), Isis::Buffer::BandDimension(), findCubeChunks(), getBandCountInChunk(), getChunk(), getChunkCountInLineDimension(), getChunkCountInSampleDimension(), getChunkPlacement(), getLineCountInChunk(), getSampleCountInChunk(), Isis::Buffer::Line(), Isis::Buffer::LineDimension(), m_bandsInChunk, m_lastProcessByLineChunks, m_linesInChunk, m_samplesInChunk, minimizeCache(), Isis::Buffer::Sample(), sampleCount(), Isis::Buffer::SampleDimension(), and writeIntoRaw().

Referenced by flushWriteCache(), and write().

◆ updateLabels()

void Isis::CubeTileHandler::updateLabels ( Pvl & labels )

virtual

Update the cube labels so that this cube indicates what tile size it used.

Parameters

labels The "Core" object in this Pvl will be updated

Implements Isis::CubeIoHandler.

Definition at line 66 of file CubeTileHandler.cpp.

References Isis::CubeIoHandler::getLineCountInChunk(), Isis::CubeIoHandler::getSampleCountInChunk(), and Isis::toString().

◆ write()

void Isis::CubeIoHandler::write ( const Buffer & bufferToWrite )

virtualinherited

Write buffer data into the cube data on disk.

This could do no IO if the cube chunks required are already in memory and our caching algorithms say to not free any of the cube chunks afterwards.

Parameters

bufferToWrite The buffer to get cube data from.

Implements Isis::ImageIoHandler.

Definition at line 325 of file CubeIoHandler.cpp.

References flushWriteCache(), m_ioThreadPool, m_lastOperationWasWrite, m_writeCache, Isis::ImageIoHandler::m_writeThreadMutex, and synchronousWrite().

◆ writeIntoDouble()

void Isis::CubeIoHandler::writeIntoDouble	(	const RawCubeChunk &	chunk,
		Buffer &	output,
		int	index ) const

privateinherited

Write the intersecting area of the chunk into the buffer.

Parameters

chunk	The data source
output	The data destination
index	int

Definition at line 1312 of file CubeIoHandler.cpp.

References Isis::Buffer::Band(), Isis::Buffer::BandDimension(), Isis::Buffer::DoubleBuffer(), findIntersection(), Isis::RawCubeChunk::getRawData(), Isis::RawCubeChunk::getStartBand(), Isis::RawCubeChunk::getStartLine(), Isis::RawCubeChunk::getStartSample(), Isis::Buffer::Index(), Isis::RawCubeChunk::lineCount(), m_base, m_byteSwapper, m_multiplier, m_pixelType, Isis::Buffer::RawBuffer(), and Isis::RawCubeChunk::sampleCount().

Referenced by read().

◆ writeIntoRaw()

void Isis::CubeIoHandler::writeIntoRaw	(	const Buffer &	buffer,
		RawCubeChunk &	output,
		int	index ) const

privateinherited

Write the intersecting area of the buffer into the chunk.

Parameters

buffer	The data source
output	The data destination
index	int

Definition at line 1512 of file CubeIoHandler.cpp.

References Isis::Buffer::Band(), Isis::Buffer::BandDimension(), Isis::Buffer::DoubleBuffer(), findIntersection(), Isis::RawCubeChunk::getRawData(), Isis::RawCubeChunk::getStartBand(), Isis::RawCubeChunk::getStartLine(), Isis::RawCubeChunk::getStartSample(), Isis::Buffer::Index(), Isis::RawCubeChunk::lineCount(), m_base, m_byteSwapper, m_multiplier, m_pixelType, Isis::ImageIoHandler::m_virtualBands, Isis::RawCubeChunk::sampleCount(), and Isis::RawCubeChunk::setDirty().

Referenced by getNullChunk(), and synchronousWrite().

◆ writeNullDataToDisk()

void Isis::CubeIoHandler::writeNullDataToDisk ( ) const

privateinherited

Write all NULL cube chunks that have not yet been accessed to disk.

Definition at line 1791 of file CubeIoHandler.cpp.

References CubeIoHandler(), getChunkCount(), getNullChunk(), m_dataIsOnDiskMap, and writeRaw().

Referenced by clearCache().

◆ writeRaw()

void Isis::CubeTileHandler::writeRaw ( const RawCubeChunk & chunkToWrite )

protectedvirtual

This needs to write the chunkToWrite directly to disk with no modifications to the data itself.

See also: CubeTileHandler::writeRaw()

Parameters

chunkToWrite The container that needs to be put on disk.

Implements Isis::CubeIoHandler.

Definition at line 102 of file CubeTileHandler.cpp.

References Isis::RawCubeChunk::getByteCount(), Isis::CubeIoHandler::getDataFile(), Isis::RawCubeChunk::getRawData(), and getTileStartByte().

Member Data Documentation

◆ m_bandsInChunk

int Isis::CubeIoHandler::m_bandsInChunk

privateinherited

The number of physical bands in a cube chunk.

Definition at line 319 of file CubeIoHandler.h.

Referenced by CubeIoHandler(), findCubeChunks(), getBandCountInChunk(), getBytesPerChunk(), getChunkCountInBandDimension(), read(), setChunkSizes(), and synchronousWrite().

◆ m_base

double Isis::CubeIoHandler::m_base

privateinherited

The additive offset of the data on disk.

Definition at line 282 of file CubeIoHandler.h.

Referenced by CubeIoHandler(), writeIntoDouble(), and writeIntoRaw().

◆ m_byteOrder

ByteOrder Isis::CubeIoHandler::m_byteOrder

privateinherited

The byte order (endianness) of the data on disk.

Definition at line 288 of file CubeIoHandler.h.

◆ m_byteSwapper

EndianSwapper* Isis::CubeIoHandler::m_byteSwapper

privateinherited

A helper that swaps byte order to and from file order.

Definition at line 291 of file CubeIoHandler.h.

Referenced by CubeIoHandler(), writeIntoDouble(), writeIntoRaw(), and ~CubeIoHandler().

◆ m_cachingAlgorithms

QList<CubeCachingAlgorithm *>* Isis::CubeIoHandler::m_cachingAlgorithms

privateinherited

The caching algorithms to use, in order of priority.

Definition at line 303 of file CubeIoHandler.h.

Referenced by addCachingAlgorithm(), CubeIoHandler(), minimizeCache(), and ~CubeIoHandler().

◆ m_consecutiveOverflowCount

int Isis::CubeIoHandler::m_consecutiveOverflowCount

mutableprivateinherited

How many times the write cache has overflown in a row.

Definition at line 355 of file CubeIoHandler.h.

Referenced by CubeIoHandler(), and flushWriteCache().

◆ m_dataFile

QFile* Isis::CubeIoHandler::m_dataFile

privateinherited

The file containing cube data.

Definition at line 269 of file CubeIoHandler.h.

Referenced by CubeIoHandler(), getDataFile(), and setChunkSizes().

◆ m_dataIsOnDiskMap

QMap<int, bool>* Isis::CubeIoHandler::m_dataIsOnDiskMap

mutableprivateinherited

The map from chunk index to on-disk status, all true if not allocated.

Definition at line 309 of file CubeIoHandler.h.

Referenced by clearCache(), CubeIoHandler(), getChunk(), setChunkSizes(), writeNullDataToDisk(), and ~CubeIoHandler().

◆ m_idealFlushSize

volatile int Isis::CubeIoHandler::m_idealFlushSize

mutableprivateinherited

Ideal write cache flush size.

Definition at line 352 of file CubeIoHandler.h.

Referenced by CubeIoHandler(), and flushWriteCache().

◆ m_ioThreadPool

QThreadPool* Isis::CubeIoHandler::m_ioThreadPool

mutableprivateinherited

This contains threads for doing cube writes (and later maybe cube reads).

We're using a thread pool so that the same QThread is reused for performance reasons.

Definition at line 338 of file CubeIoHandler.h.

Referenced by blockUntilThreadPoolEmpty(), CubeIoHandler(), flushWriteCache(), read(), write(), and ~CubeIoHandler().

◆ m_lastOperationWasWrite

bool Isis::CubeIoHandler::m_lastOperationWasWrite

mutableprivateinherited

If the last operation was a write then we need to flush the cache when reading.

Keep track of this.

Definition at line 344 of file CubeIoHandler.h.

Referenced by CubeIoHandler(), flushWriteCache(), read(), and write().

◆ m_lastProcessByLineChunks

QList<RawCubeChunk *>* Isis::CubeIoHandler::m_lastProcessByLineChunks

mutableprivateinherited

This is an optimization for process by line.

It relies on chunks found often being the exact same between multiple reads or multiple writes.

Definition at line 325 of file CubeIoHandler.h.

Referenced by clearCache(), CubeIoHandler(), freeChunk(), synchronousWrite(), and ~CubeIoHandler().

◆ m_linesInChunk

int Isis::CubeIoHandler::m_linesInChunk

privateinherited

The number of lines in a cube chunk.

Definition at line 316 of file CubeIoHandler.h.

Referenced by CubeIoHandler(), findCubeChunks(), getBytesPerChunk(), getChunkCountInLineDimension(), getLineCountInChunk(), read(), setChunkSizes(), and synchronousWrite().

◆ m_multiplier

double Isis::CubeIoHandler::m_multiplier

privateinherited

The multiplicative factor of the data on disk.

Definition at line 285 of file CubeIoHandler.h.

Referenced by CubeIoHandler(), writeIntoDouble(), and writeIntoRaw().

◆ m_nullChunkData

QByteArray* Isis::CubeIoHandler::m_nullChunkData

mutableprivateinherited

A raw cube chunk's data when it was all NULL's. Used for speed.

Definition at line 328 of file CubeIoHandler.h.

Referenced by CubeIoHandler(), getNullChunk(), and ~CubeIoHandler().

◆ m_numBands

int Isis::CubeIoHandler::m_numBands

privateinherited

The number of physical bands in the cube.

Definition at line 300 of file CubeIoHandler.h.

Referenced by bandCount(), CubeIoHandler(), and getChunkCountInBandDimension().

◆ m_numLines

int Isis::CubeIoHandler::m_numLines

privateinherited

The number of lines in the cube.

Definition at line 297 of file CubeIoHandler.h.

Referenced by CubeIoHandler(), getChunkCountInLineDimension(), and lineCount().

◆ m_numSamples

int Isis::CubeIoHandler::m_numSamples

privateinherited

The number of samples in the cube.

Definition at line 294 of file CubeIoHandler.h.

Referenced by CubeIoHandler(), getChunkCountInSampleDimension(), and sampleCount().

◆ m_pixelType

PixelType Isis::CubeIoHandler::m_pixelType

privateinherited

The format of each DN in the cube.

Definition at line 279 of file CubeIoHandler.h.

Referenced by CubeIoHandler(), getBytesPerChunk(), pixelType(), writeIntoDouble(), and writeIntoRaw().

◆ m_rawData

QMap<int, RawCubeChunk *>* Isis::CubeIoHandler::m_rawData

mutableprivateinherited

The map from chunk index to chunk for cached data.

Definition at line 306 of file CubeIoHandler.h.

Referenced by clearCache(), CubeIoHandler(), freeChunk(), getChunk(), minimizeCache(), read(), and ~CubeIoHandler().

◆ m_samplesInChunk

int Isis::CubeIoHandler::m_samplesInChunk

privateinherited

The number of samples in a cube chunk.

Definition at line 313 of file CubeIoHandler.h.

Referenced by CubeIoHandler(), findCubeChunks(), getBytesPerChunk(), getChunkCountInSampleDimension(), getSampleCountInChunk(), read(), setChunkSizes(), and synchronousWrite().

◆ m_startByte

BigInt Isis::CubeIoHandler::m_startByte

privateinherited

The start byte of the cube data.

This is 0-based (i.e. a value of 0 means write data into the first byte of the file). Usually the label is between 0 and m_startByte.

Definition at line 276 of file CubeIoHandler.h.

Referenced by CubeIoHandler(), and getDataStartByte().

◆ m_useOptimizedCubeWrite

bool Isis::CubeIoHandler::m_useOptimizedCubeWrite

privateinherited

This is true if the Isis preference for the cube write thread is optimized.

Definition at line 349 of file CubeIoHandler.h.

Referenced by CubeIoHandler(), flushWriteCache(), and read().

◆ m_virtualBands

QList<int>* Isis::ImageIoHandler::m_virtualBands

protectedinherited

Converts from virtual band to physical band.

Definition at line 124 of file ImageIoHandler.h.

Referenced by Isis::CubeIoHandler::findCubeChunks(), Isis::CubeIoHandler::findIntersection(), Isis::CubeIoHandler::read(), setVirtualBands(), and Isis::CubeIoHandler::writeIntoRaw().

◆ m_writeCache

QPair< QMutex *, QList<Buffer *> >* Isis::CubeIoHandler::m_writeCache

privateinherited

These are the buffers we need to write to raw cube chunks.

Definition at line 331 of file CubeIoHandler.h.

Referenced by CubeIoHandler(), flushWriteCache(), write(), and ~CubeIoHandler().

◆ m_writeThreadMutex

QMutex* Isis::ImageIoHandler::m_writeThreadMutex

protectedinherited

This enables us to block while the write thread is working.

Definition at line 121 of file ImageIoHandler.h.

Referenced by Isis::CubeIoHandler::blockUntilThreadPoolEmpty(), Isis::CubeIoHandler::CubeIoHandler(), dataFileMutex(), Isis::CubeIoHandler::flushWriteCache(), Isis::CubeIoHandler::read(), and Isis::CubeIoHandler::write().

The documentation for this class was generated from the following files:

src/base/objs/Cube/CubeTileHandler.h
src/base/objs/Cube/CubeTileHandler.cpp

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ CubeTileHandler() [1/2]

◆ ~CubeTileHandler()

◆ CubeTileHandler() [2/2]

Member Function Documentation

◆ addCachingAlgorithm()

◆ bandCount()

◆ blockUntilThreadPoolEmpty()

◆ bufferLessThan()

◆ clearCache()

◆ dataFileMutex()

◆ findCubeChunks()

The user has requested a slice of a cube (a rectangle):

| |

| | | ||

| 10 | 11 | 12 ||

◆ findGoodSize()

◆ findIntersection()

◆ flushWriteCache()

◆ freeChunk()

◆ getBandCountInChunk()

◆ getBytesPerChunk()

◆ getChunk()

◆ getChunkCount()

◆ getChunkCountInBandDimension()

◆ getChunkCountInLineDimension()

◆ getChunkCountInSampleDimension()

◆ getChunkIndex()

◆ getChunkPlacement()

◆ getDataFile()

◆ getDataSize()

◆ getDataStartByte()

◆ getLineCountInChunk()

◆ getNullChunk()

◆ getSampleCountInChunk()

◆ getTileStartByte()

◆ lineCount()

◆ minimizeCache()

◆ operator=()

◆ pixelType()

◆ read()

◆ readRaw()

◆ sampleCount()

◆ setChunkSizes()

◆ setVirtualBands()

◆ synchronousWrite()

◆ updateLabels()

◆ write()

◆ writeIntoDouble()

◆ writeIntoRaw()

◆ writeNullDataToDisk()

◆ writeRaw()

Member Data Documentation

◆ m_bandsInChunk

◆ m_base

◆ m_byteOrder

◆ m_byteSwapper

◆ m_cachingAlgorithms

◆ m_consecutiveOverflowCount

◆ m_dataFile

◆ m_dataIsOnDiskMap

◆ m_idealFlushSize

◆ m_ioThreadPool

◆ m_lastOperationWasWrite

◆ m_lastProcessByLineChunks

◆ m_linesInChunk

◆ m_multiplier

◆ m_nullChunkData

◆ m_numBands

◆ m_numLines

◆ m_numSamples

◆ m_pixelType

◆ m_rawData