void Hdf5Handler::getColumnEntries(
void* data,
const std::string& dataSetName,
const hsize_t numEntries,
const hsize_t offset) const
{
try
{
const ColumnData& columnData(getColumnData(dataSetName));
columnData.dataSpace.selectHyperslab(
H5S_SELECT_SET,
&numEntries,
&offset);
const hsize_t outOffset = 0;
const H5::DataSpace outSpace(1, &numEntries);
outSpace.selectHyperslab(H5S_SELECT_SET, &numEntries, &outOffset);
columnData.dataSet.read(
data,
columnData.predType,
outSpace,
columnData.dataSpace);
}
catch (const H5::Exception&)
{
throw hdf5_error("Could not read from dataset");
}
}
void addrow( H5::DataSet& ds, const std::vector<double>& rowtowrite )
{
//Get the space (since it may have grown in length since last time of course )
H5::DataSpace origspace = ds.getSpace();
//get the rank, even though I know it is 2
int rank = origspace.getSimpleExtentNdims();
//Get the actual dimensions of the ranks.
hsize_t dims[rank];
int ndims = origspace.getSimpleExtentDims( dims, NULL);
//Want to ADD a row, so need to offset at row = nrows, and col = 0;
hsize_t offset[rank] = { dims[0], 0 };
hsize_t dims_toadd[rank] = { 1, rowtowrite.size() }; //will write 1 row, ncols columns.
//Compute "new" size (extended by 1 row).
hsize_t size[rank] = { dims[0]+dims_toadd[0], rowtowrite.size() };
//Do the extension.
ds.extend( size );
//Get the new (extended) space, and select the hyperslab to write the row to.
origspace = ds.getSpace();
origspace.selectHyperslab( H5S_SELECT_SET, dims_toadd, offset );
//Make the "memory" data space?
H5::DataSpace toaddspace(rank, dims_toadd);
ds.write( rowtowrite.data(), H5::PredType::NATIVE_DOUBLE, toaddspace, origspace );
//Can close toaddspace/origspace with no effect.
//Can also close/open data set at the beginning of each time with no effect.
}
inline void
read_values(H5::DataSet& dataset, H5::DataSpace& data_space,
dimension const& dimx, dimension const& dimy, dimension const& dimz,
double* values)
{
using namespace H5;
// Define the hyperslab for file based data.
hsize_t data_offset[dimension::dim] = {
dimx.offset_, dimy.offset_, dimz.offset_
};
hsize_t data_count[dimension::dim] = {
dimx.count_, dimy.count_, dimz.count_
};
data_space.selectHyperslab(H5S_SELECT_SET, data_count, data_offset);
// Memory dataspace.
DataSpace mem_space (dimension::dim, data_count);
// Define the hyperslab for data in memory.
hsize_t mem_offset[dimension::dim] = { 0, 0, 0 };
mem_space.selectHyperslab(H5S_SELECT_SET, data_count, mem_offset);
// Read data to memory.
dataset.read(values, PredType::NATIVE_DOUBLE, mem_space, data_space);
}
/**
* @brief Returns a pointer to a std::vector<float> containing the values of the selected variable
*
* This allocates a new std::vector<float> pointer. Make sure you
* delete the contents when you done using it, or you will have a memory leak.
*
* @param variable
* @return std::vector<float> containing the values of the selected variable.
*/
std::vector<float>* HDF5FileReader::getVariable(const std::string& variable)
{
std::vector<float>* variableData = new std::vector<float>();
if (this->doesVariableExist(variable))
{
//std::cout << "reading " << variable << std::endl;
//get variable number
// long variableNum = this->getVariableID(variable);
//std::cout << "variableNum for " << variable << ": " << variableNum << std::endl;
//get dim sizes
H5::Group group = this->current_file->openGroup("Variables");
//cout << "variable: " << variable << ": " << counts[0] << endl;
H5::DataSet * dataset = new H5::DataSet(group.openDataSet(variable));
H5::DataSpace dataspace = dataset->getSpace();
int rank = dataspace.getSimpleExtentNdims(); //should be 1
hsize_t count[1];
hsize_t offset[1] = {0};
// int ndims = dataspace.getSimpleExtentDims(count, NULL);
//std::cout << "count[0]: " << count[0] << std::endl;
float * buffer = new float[count[0]];
dataspace.selectHyperslab(H5S_SELECT_SET, count, offset);
H5::DataSpace memspace( rank, count);
memspace.selectHyperslab(H5S_SELECT_SET, count, offset);
dataset->read(buffer, H5::PredType::NATIVE_FLOAT, memspace, dataspace);
//std::cout << "after read" << std::endl;
//add data to vector type, and delete original array
variableData->reserve(count[0]);
for (int i = 0; i < count[0]; i++)
{
variableData->push_back(buffer[i]);
}
//std::cout << "after adding to variableData vector" << std::endl;
delete[] buffer;
delete dataset;
//std::cout << "finished reading " << variable << std::endl;
//std::cout << "size of variable: " << variableData.size() << std::endl;
//std::cout << "dimSizes[0]: " << dimSizes[0] << std::endl;
}
return variableData;
}
H5::DataSpace dataspace_from_LS (
mini_vector<hsize_t, R> const & Ltot,
mini_vector<hsize_t, R> const & L,
mini_vector<hsize_t, R> const & S,
mini_vector<hsize_t, R> const & offset = mini_vector<hsize_t,R>() )
{
static const unsigned int rank = R + (IsComplex ? 1 : 0);
hsize_t totdimsf[rank], dimsf [rank], stridesf[rank], offsetf[rank]; // dataset dimensions
for (size_t u=0; u<R ; ++u) { offsetf[u] = offset[u]; dimsf[u] = L[u]; totdimsf[u] = Ltot[u]; stridesf[u] = S[u]; }
if (IsComplex) { offsetf[rank-1]=0; dimsf[rank-1]=2; totdimsf[rank-1] = 2; stridesf[rank-1]=1; }
H5::DataSpace ds ( rank, totdimsf );
ds.selectHyperslab (H5S_SELECT_SET , dimsf, offsetf, stridesf);
return ds;
}
/**
* @brief Returns a value in the flat array of the variable and index requested.
*
* Use this method on variables that have a type of int
*
* @param variable The variable in the file
* @param index The index in the variable's array in the file
*
* @return int of the value in the array.
*/
int HDF5FileReader::getVariableIntAtIndex(const std::string& variable, long index)
{
// long counts[1];
int value = std::numeric_limits<int>::min();
if (this->doesVariableExist(variable))
{
//std::cout << "reading " << variable << std::endl;
//get variable number
// long variableNum = this->getVariableID(variable);
//get dim sizes
H5::Group group = this->current_file->openGroup("Variables");
//cout << "variable: " << variable << ": " << counts[0] << endl;
H5::DataSet * dataset = new H5::DataSet(group.openDataSet(variable));
H5::DataSpace dataspace = dataset->getSpace();
int rank = dataspace.getSimpleExtentNdims(); //should be 1
hsize_t count[1] = {1};
hsize_t offset[1] = {0};
//int ndims = dataspace.getSimpleExtentDims(count, NULL);
float * buffer = new float[count[0]];
dataspace.selectHyperslab(H5S_SELECT_SET, count, offset);
hsize_t dim[] = {count[0]};
H5::DataSpace memspace( rank, dim);
memspace.selectHyperslab(H5S_SELECT_SET, dim, offset);
dataset->read(buffer, H5::PredType::NATIVE_INT, memspace, dataspace);
//add data to vector type, and delete original array
value = buffer[0];
delete[] buffer;
delete dataset;
}
return value;
//std::cout << "finished reading " << variable << std::endl;
//std::cout << "size of variable: " << variableData.size() << std::endl;
//std::cout << "dimSizes[0]: " << dimSizes[0] << std::endl;
}
/**
* Returns a pointer to a std::vector<float> containing the values of the selected variable
* in the range specified by the startIndex and count (the number of records to read) stored
* in the selected file. This allocates a new std::vector<float> pointer. Make sure you
* delete the contents when you done using it, or you will have a memory leak.
* @param variableID
* @param startIndex
* @param count
* @return std::vector<float> containing the values of the selected variable.
*/
std::vector<float>* HDF5FileReader::getVariable(long variable, long indexOffset, long count)
{
std::vector<float>* variableData = new std::vector<float>();
//get dim sizes
H5::Group group = this->current_file->openGroup("Variables");
//cout << "variable: " << variable << ": " << counts[0] << endl;
H5::DataSet * dataset = new H5::DataSet(group.openDataSet(group.getObjnameByIdx(variable)));
H5::DataSpace dataspace = dataset->getSpace();
int rank = dataspace.getSimpleExtentNdims(); //should be 1
hsize_t length[1] = {count};
hsize_t offset[1] = {indexOffset};
//int ndims = dataspace.getSimpleExtentDims(count, NULL);
float * buffer = new float[length[0]];
dataspace.selectHyperslab(H5S_SELECT_SET, length, offset);
hsize_t dim[] = {length[0]};
H5::DataSpace memspace( rank, dim);
memspace.selectHyperslab(H5S_SELECT_SET, dim, offset);
dataset->read(buffer, H5::PredType::NATIVE_FLOAT, memspace, dataspace);
//add data to vector type, and delete original array
variableData->reserve(length[0]);
for (int i = 0; i < length[0]; i++)
{
variableData->push_back(buffer[i]);
}
delete[] buffer;
delete dataset;
//std::cout << "finished reading " << variable << std::endl;
//std::cout << "size of variable: " << variableData.size() << std::endl;
//std::cout << "dimSizes[0]: " << dimSizes[0] << std::endl;
return variableData;
}
std::vector<double> readlastrow( H5::DataSet& ds )
{
H5::DataSpace origspace = ds.getSpace();
int rank = origspace.getSimpleExtentNdims();
hsize_t dims[rank];
int ndims = origspace.getSimpleExtentDims( dims, NULL);
hsize_t nrows=dims[0];
hsize_t ncols=dims[1];
std::vector<double> returnvect( ncols );
hsize_t targrowoffset = nrows-1;
hsize_t targcoloffset = 0;
hsize_t dimsmem[rank] = {1, ncols};
H5::DataSpace memspace(rank, dimsmem);
hsize_t offset[rank] = { targrowoffset, targcoloffset };
origspace.selectHyperslab( H5S_SELECT_SET, dimsmem, offset );
ds.read( returnvect.data(), H5::PredType::NATIVE_DOUBLE, memspace, origspace );
return returnvect;
}
inline void
read_values(H5::DataSet& dataset, H5::DataSpace& data_space,
hsize_t offset, hsize_t count, double* values)
{
using namespace H5;
// Define hyperslab for file based data
hsize_t data_offset[1] = { offset };
hsize_t data_count[1] = { count };
data_space.selectHyperslab(H5S_SELECT_SET, data_count, data_offset);
// memory dataspace
hsize_t mem_dims[1] = { count };
DataSpace mem_space (1, mem_dims);
// Define hyperslab for data in memory
hsize_t mem_offset[1] = { 0 };
hsize_t mem_count[1] = { count };
mem_space.selectHyperslab(H5S_SELECT_SET, mem_count, mem_offset);
// read data to memory
dataset.read(values, PredType::NATIVE_DOUBLE, mem_space, data_space);
}
void BufferedHDF2DArray<T>::Flush(int destRow) {
//
// A default writeRow of -1 implies append
//
int numDataRows;
//
// this->bufferIndex points after the end of the last data in the
// buffer (full rows), so this->bufferIndex / rowLength is the
// number of number of rows to create.
//
numDataRows = this->bufferIndex / rowLength;
if (numDataRows > 0) {
assert(fileDataSpaceInitialized);
H5::DataSpace fileSpace;
fileSpace = dataset.getSpace();
//
// Load the current size of the array on disk.
//
hsize_t fileArraySize[2], fileArrayMaxSize[2], blockStart[2];
fileSpace.getSimpleExtentDims(fileArraySize, fileArrayMaxSize);
// Save this for later to determine the offsets
blockStart[0] = fileArraySize[0];
blockStart[1] = fileArraySize[1];
//
// Calculate the number of rows to create. This is dependent
// on the current file size, the destination of where the data
// will go, and how much to write.
//
if (destRow == -1) {
fileArraySize[0] += numDataRows;
}
else {
// If the data cannot fit in the current file size, extend
// it, otherwise, do not toch the file array size.
if (destRow + numDataRows > fileArraySize[0]) {
fileArraySize[0] = destRow + numDataRows;
}
}
//
// Make room in the file for the array.
//
dataset.extend(fileArraySize);
H5::DataSpace extendedSpace = dataset.getSpace();
//
// Store the newly dimensioned dataspaces.
//
fileSpace.getSimpleExtentDims(fileArraySize, fileArrayMaxSize);
//
// Configure the proper addressing to append to the array.
//
hsize_t dataSize[2];
dataSize[0] = numDataRows;
dataSize[1] = rowLength;
hsize_t offset[2];
//
// Determine which row to write to.
//
if (destRow == -1) {
offset[0] = blockStart[0];
}
else {
offset[0] = destRow;
}
offset[1] = 0;
extendedSpace.selectHyperslab(H5S_SELECT_SET, dataSize, offset);
H5::DataSpace memorySpace(2, dataSize);
//
// Finally, write out the data.
// This uses a generic function which is specialized with
// templates later on to t
// memorySpace addresses the entire array in linear format
// fileSpace addresses the last dataLength blocks of dataset.
//
TypedWriteRow(this->writeBuffer, memorySpace, extendedSpace);
memorySpace.close();
extendedSpace.close();
fileSpace.close();
}
this->ResetWriteBuffer();
}
bool ossim_hdf5::getValidBoundingRect( H5::DataSet& dataset,
const std::string& name,
ossimIrect& rect )
{
bool result = false;
H5::DataSpace imageDataspace = dataset.getSpace();
const ossim_int32 IN_DIM_COUNT = imageDataspace.getSimpleExtentNdims();
if ( IN_DIM_COUNT == 2 )
{
// Get the extents. Assuming dimensions are same for lat lon dataset.
std::vector<hsize_t> dimsOut(IN_DIM_COUNT);
imageDataspace.getSimpleExtentDims( &dimsOut.front(), 0 );
if ( dimsOut[0] && dimsOut[1] )
{
//---
// Capture the rectangle:
// dimsOut[0] is height, dimsOut[1] is width:
//---
rect = ossimIrect( 0, 0,
static_cast<ossim_int32>( dimsOut[1]-1 ),
static_cast<ossim_int32>( dimsOut[0]-1 ) );
const ossim_int32 WIDTH = rect.width();
std::vector<hsize_t> inputCount(IN_DIM_COUNT);
std::vector<hsize_t> inputOffset(IN_DIM_COUNT);
inputOffset[0] = 0;
inputOffset[1] = 0;
inputCount[0] = 1;
inputCount[1] = WIDTH;
// Output dataspace dimensions.
const ossim_int32 OUT_DIM_COUNT = 3;
std::vector<hsize_t> outputCount(OUT_DIM_COUNT);
outputCount[0] = 1; // single band
outputCount[1] = 1; // single line
outputCount[2] = WIDTH; // whole line
// Output dataspace offset.
std::vector<hsize_t> outputOffset(OUT_DIM_COUNT);
outputOffset[0] = 0;
outputOffset[1] = 0;
outputOffset[2] = 0;
ossimScalarType scalar = ossim_hdf5::getScalarType( &dataset );
if ( scalar == OSSIM_FLOAT32 )
{
// See if we need to swap bytes:
ossimEndian* endian = 0;
if ( ( ossim::byteOrder() != ossim_hdf5::getByteOrder( &dataset ) ) )
{
endian = new ossimEndian();
}
// Native type:
H5::DataType datatype = dataset.getDataType();
// Output dataspace always the same one line.
H5::DataSpace bufferDataSpace( OUT_DIM_COUNT, &outputCount.front());
bufferDataSpace.selectHyperslab( H5S_SELECT_SET,
&outputCount.front(),
&outputOffset.front() );
//---
// Dataset sample has NULL lines at the end so scan for valid rect.
// Use "<= -999" for test as per NOAA as it seems the NULL value is
// fuzzy. e.g. -999.3.
//---
const ossim_float32 NULL_VALUE = -999.0;
//---
// VIIRS Radiance data has a -1.5e-9 in the first column.
// Treat this as a null.
//---
const ossim_float32 NULL_VALUE2 = ( name == "/All_Data/VIIRS-DNB-SDR_All/Radiance" )
? -1.5e-9 : NULL_VALUE;
const ossim_float32 TOLERANCE = 0.1e-9; // For ossim::almostEqual()
// Hold one line:
std::vector<ossim_float32> values( WIDTH );
// Find the ul pixel:
ossimIpt ulIpt = rect.ul();
bool found = false;
// Line loop to find upper left pixel:
while ( ulIpt.y <= rect.lr().y )
{
inputOffset[0] = static_cast<hsize_t>(ulIpt.y);
imageDataspace.selectHyperslab( H5S_SELECT_SET,
&inputCount.front(),
&inputOffset.front() );
// Read data from file into the buffer.
dataset.read( (void*)&values.front(), datatype, bufferDataSpace, imageDataspace );
if ( endian )
{
// If the endian pointer is initialized(not zero) swap the bytes.
endian->swap( scalar, (void*)&values.front(), WIDTH );
}
// Sample loop:
ulIpt.x = rect.ul().x;
ossim_int32 index = 0;
while ( ulIpt.x <= rect.lr().x )
{
if ( !ossim::almostEqual(values[index], NULL_VALUE2, TOLERANCE) &&
( values[index] > NULL_VALUE ) )
{
found = true; // Found valid pixel.
break;
}
++ulIpt.x;
++index;
} // End: sample loop
if ( found )
{
break;
}
++ulIpt.y;
} // End line loop to find ul pixel:
// Find the lower right pixel:
ossimIpt lrIpt = rect.lr();
found = false;
// Line loop to find last pixel:
while ( lrIpt.y >= rect.ul().y )
{
inputOffset[0] = static_cast<hsize_t>(lrIpt.y);
imageDataspace.selectHyperslab( H5S_SELECT_SET,
&inputCount.front(),
&inputOffset.front() );
// Read data from file into the buffer.
dataset.read( (void*)&values.front(), datatype, bufferDataSpace, imageDataspace );
if ( endian )
{
// If the endian pointer is initialized(not zero) swap the bytes.
endian->swap( scalar, (void*)&values.front(), WIDTH );
}
// Sample loop:
lrIpt.x = rect.lr().x;
ossim_int32 index = WIDTH-1;
while ( lrIpt.x >= rect.ul().x )
{
if ( !ossim::almostEqual(values[index], NULL_VALUE2, TOLERANCE) &&
( values[index] > NULL_VALUE ) )
{
found = true; // Found valid pixel.
break;
}
--lrIpt.x;
--index;
} // End: sample loop
if ( found )
{
break;
}
--lrIpt.y;
} // End line loop to find lower right pixel.
rect = ossimIrect( ulIpt, lrIpt );
// Cleanup:
if ( endian )
{
delete endian;
endian = 0;
}
result = true;
}
else // Matches: if ( scalar == OSSIM_FLOAT32 ){...}
{
ossimNotify(ossimNotifyLevel_WARN)
<< "ossim_hdf5::getBoundingRect WARNING!"
<< "\nUnhandled scalar type: "
<< ossimScalarTypeLut::instance()->getEntryString( scalar )
<< std::endl;
}
} // Matches: if ( dimsOut...
} // Matches: if ( IN_DIM_COUNT == 2 )
imageDataspace.close();
return result;
} // End: ossim_hdf5::getBoundingRect(...)
bool ossimH5GridModel::setGridNodes( H5::DataSet* latDataSet,
H5::DataSet* lonDataSet,
const ossimIrect& validRect )
{
bool status = false;
if ( latDataSet && lonDataSet )
{
m_crossesDateline = ossim_hdf5::crossesDateline( *lonDataSet, validRect );
if ( m_crossesDateline )
{
theLonGrid.setDomainType(ossimDblGrid::WRAP_360);
}
else
{
theLonGrid.setDomainType(ossimDblGrid::WRAP_180);
}
// Get dataspace of the dataset.
H5::DataSpace latDataSpace = latDataSet->getSpace();
H5::DataSpace lonDataSpace = lonDataSet->getSpace();
const ossim_int32 LAT_DIM_COUNT = latDataSpace.getSimpleExtentNdims();
const ossim_int32 LON_DIM_COUNT = lonDataSpace.getSimpleExtentNdims();
// Number of dimensions of the input dataspace:
if ( ( LAT_DIM_COUNT == 2 ) && ( LON_DIM_COUNT == 2 ) )
{
const ossim_uint32 ROWS = validRect.height();
const ossim_uint32 COLS = validRect.width();
const ossim_uint32 GRID_SIZE = 4; // Only grab every 4th value.
//---
// Get the extents:
// dimsOut[0] is height, dimsOut[1] is width:
//---
std::vector<hsize_t> latDimsOut(LAT_DIM_COUNT);
latDataSpace.getSimpleExtentDims( &latDimsOut.front(), 0 );
std::vector<hsize_t> lonDimsOut(LON_DIM_COUNT);
lonDataSpace.getSimpleExtentDims( &lonDimsOut.front(), 0 );
// Verify valid rect within our bounds:
if ( (ROWS <= latDimsOut[0] ) && (ROWS <= lonDimsOut[0] ) &&
(COLS <= latDimsOut[1] ) && (COLS <= lonDimsOut[1] ) )
{
//----
// Initialize the ossimDblGrids:
//---
ossimDpt dspacing (GRID_SIZE, GRID_SIZE);
ossim_uint32 gridRows = ROWS / GRID_SIZE + 1;
ossim_uint32 gridCols = COLS / GRID_SIZE + 1;
// Round up if size doesn't fall on end pixel.
if ( ROWS % GRID_SIZE) ++gridRows;
if ( COLS % GRID_SIZE) ++gridCols;
ossimIpt gridSize (gridCols, gridRows);
// The grid as used in base class, has UV-space always at 0,0 origin
ossimDpt gridOrigin(0.0,0.0);
const ossim_float64 NULL_VALUE = -999.0;
theLatGrid.setNullValue(ossim::nan());
theLonGrid.setNullValue(ossim::nan());
theLatGrid.initialize(gridSize, gridOrigin, dspacing);
theLonGrid.initialize(gridSize, gridOrigin, dspacing);
std::vector<hsize_t> inputCount(LAT_DIM_COUNT);
std::vector<hsize_t> inputOffset(LAT_DIM_COUNT);
inputOffset[0] = 0; // row is set below.
inputOffset[1] = validRect.ul().x; // col
inputCount[0] = 1; // row
inputCount[1] = (hsize_t)COLS; // col
// Output dataspace dimensions. Reading a line at a time.
const ossim_int32 OUT_DIM_COUNT = 3;
std::vector<hsize_t> outputCount(OUT_DIM_COUNT);
outputCount[0] = 1; // band
outputCount[1] = 1; // row
outputCount[2] = COLS; // col
// Output dataspace offset.
std::vector<hsize_t> outputOffset(OUT_DIM_COUNT);
outputOffset[0] = 0;
outputOffset[1] = 0;
outputOffset[2] = 0;
ossimScalarType scalar = ossim_hdf5::getScalarType( latDataSet );
if ( scalar == OSSIM_FLOAT32 )
{
// Set the return status to true if we get here...
status = true;
// See if we need to swap bytes:
ossimEndian* endian = 0;
if ( ( ossim::byteOrder() != ossim_hdf5::getByteOrder( latDataSet ) ) )
{
endian = new ossimEndian();
}
// Native type:
H5::DataType latDataType = latDataSet->getDataType();
H5::DataType lonDataType = lonDataSet->getDataType();
// Output dataspace always the same, width of one line.
H5::DataSpace bufferDataSpace( OUT_DIM_COUNT, &outputCount.front());
bufferDataSpace.selectHyperslab( H5S_SELECT_SET,
&outputCount.front(),
&outputOffset.front() );
// Arrays to hold a single line of latitude longitude values.
vector<ossim_float32> latValue(COLS);
vector<ossim_float32> lonValue(COLS);
hsize_t row = 0;
// Line loop:
for ( ossim_uint32 y = 0; y < gridRows; ++y )
{
// row = line in image space
row = y*GRID_SIZE;
if ( row < ROWS )
{
inputOffset[0] = row + validRect.ul().y;
latDataSpace.selectHyperslab( H5S_SELECT_SET,
&inputCount.front(),
&inputOffset.front() );
lonDataSpace.selectHyperslab( H5S_SELECT_SET,
&inputCount.front(),
&inputOffset.front() );
// Read data from file into the buffer.
latDataSet->read( &(latValue.front()), latDataType,
bufferDataSpace, latDataSpace );
lonDataSet->read( &(lonValue.front()), lonDataType,
bufferDataSpace, lonDataSpace );
if ( endian )
{
// If the endian pointer is initialized(not zero) swap the bytes.
endian->swap( &(latValue.front()), COLS );
endian->swap( &(lonValue.front()), COLS );
}
// Sample loop:
hsize_t col = 0;
for ( ossim_uint32 x = 0; x < gridCols; ++x )
{
ossim_float32 lat = ossim::nan();
ossim_float32 lon = ossim::nan();
// col = sample in image space
col = x*GRID_SIZE;
if ( col < COLS )
{
if ( (latValue[col] > NULL_VALUE)&&(lonValue[col] > NULL_VALUE) )
{
lat = latValue[col];
lon = lonValue[col];
if ( m_crossesDateline )
{
if ( lon < 0.0 ) lon += 360;
}
}
else // Nulls in grid!
{
std::string errMsg =
"ossimH5GridModel::setGridNodes encountered nans!";
throw ossimException(errMsg);
}
}
else // Last column is outside of image bounds.
{
// Get the last two latitude values:
ossim_float32 lat1 = theLatGrid.getNode( x-2, y );
ossim_float32 lat2 = theLatGrid.getNode( x-1, y );
// Get the last two longitude values
ossim_float32 lon1 = theLonGrid.getNode( x-2, y );
ossim_float32 lon2 = theLonGrid.getNode( x-1, y );
if ( ( lat1 > NULL_VALUE ) && ( lat2 > NULL_VALUE ) )
{
// Delta between last two latitude grid values.
ossim_float32 latSpacing = lat2 - lat1;
// Compute:
lat = lat2 + latSpacing;
}
else // Nulls in grid!
{
std::string errMsg =
"ossimH5GridModel::setGridNodes encountered nans!";
throw ossimException(errMsg);
}
if ( ( lon1 > NULL_VALUE ) && ( lon2 > NULL_VALUE ) )
{
// Delta between last two longitude values.
ossim_float32 lonSpacing = lon2 - lon1;
// Compute:
lon = lon2 + lonSpacing;
// Check for wrap:
if ( !m_crossesDateline && ( lon > 180 ) )
{
lon -= 360.0;
}
}
else // Nulls in grid!
{
std::string errMsg =
"ossimH5GridModel::setGridNodes encountered nans!";
throw ossimException(errMsg);
}
#if 0 /* Please leave for debug. (drb) */
cout << "lat1: " << lat1 << " lat2 " << lat2
<< " lon1 " << lon1 << " lon2 " << lon2
<< "\n";
#endif
}
// Assign the latitude and longitude.
theLatGrid.setNode( x, y, lat );
theLonGrid.setNode( x, y, lon );
#if 0 /* Please leave for debug. (drb) */
cout << "x,y,col,row,lat,lon:" << x << "," << y << ","
<< col << "," << row << ","
<< theLatGrid.getNode(x, y)
<< "," << theLonGrid.getNode( x, y) << "\n";
#endif
} // End sample loop.
}
else // Row is outside of image bounds:
{
// Sample loop:
for ( ossim_uint32 x = 0; x < gridCols; ++x )
{
ossim_float32 lat = ossim::nan();
ossim_float32 lon = ossim::nan();
ossim_float32 lat1 = theLatGrid.getNode( x, y-2 );
ossim_float32 lat2 = theLatGrid.getNode( x, y-1 );
ossim_float32 lon1 = theLonGrid.getNode( x, y-2 );
ossim_float32 lon2 = theLonGrid.getNode( x, y-1 );
if ( ( lon1 > NULL_VALUE ) && ( lon2 > NULL_VALUE ) )
{
// Delta between last two longitude values.
ossim_float32 lonSpacing = lon2 - lon1;
// Compute:
lon = lon2 + lonSpacing;
// Check for wrap:
if ( !m_crossesDateline && ( lon > 180 ) )
{
lon -= 360.0;
}
}
else // Nulls in grid!
{
std::string errMsg =
"ossimH5GridModel::setGridNodes encountered nans!";
throw ossimException(errMsg);
}
if ( ( lat1 > NULL_VALUE ) && ( lat2 > NULL_VALUE ) )
{
// Delta between last two latitude values.
ossim_float32 latSpacing = lat2 - lat1;
lat = lat2 + latSpacing;
}
else // Nulls in grid!
{
std::string errMsg =
"ossimH5GridModel::setGridNodes encountered nans!";
throw ossimException(errMsg);
}
#if 0 /* Please leave for debug. (drb) */
hsize_t col = x*GRID_SIZE; // Sample in image space
cout << "lat1: " << lat1 << " lat2 " << lat2
<< " lon1 " << lon1 << " lon2 " << lon2
<< "\nx,y,col,row,lat,lon:" << x << "," << y << ","
<< col << "," << row << "," << lat << "," << lon << "\n";
#endif
// Assign the latitude::
theLatGrid.setNode( x, y, lat );
// Assign the longitude.
theLonGrid.setNode( x, y, lon );
} // End sample loop.
} // Matches if ( row < imageRows ){...}else{
} // End line loop.
latDataSpace.close();
lonDataSpace.close();
if ( status )
{
theSeedFunction = ossim_hdf5::getBilinearProjection(
*latDataSet,*lonDataSet, validRect );
// Bileaner projection to handle
ossimDrect imageRect(validRect);
initializeModelParams(imageRect);
// debugDump();
}
if ( endian )
{
delete endian;
endian = 0;
}
} // Matches: if ( scalar == OSSIM_FLOAT32 )
} // Matches: if ( (latDimsOut[0] == imageRows) ...
} // Matches: if ( ( LAT_DIM_COUNT == 2 ) ...
} // Matches: if ( latDataSet && lonDataSet
return status;
} // End: bool ossimH5GridModel::setGridNodes( H5::DataSet* latDataSet, ... )
bool ossim_hdf5::crossesDateline( H5::DataSet& dataset, const ossimIrect& validRect )
{
bool result = false;
H5::DataSpace dataspace = dataset.getSpace();
// Number of dimensions of the input dataspace:
const ossim_int32 DIM_COUNT = dataspace.getSimpleExtentNdims();
if ( DIM_COUNT == 2 )
{
const ossim_uint32 ROWS = validRect.height();
const ossim_uint32 COLS = validRect.width();
// Get the extents. Assuming dimensions are same for lat lon dataset.
std::vector<hsize_t> dimsOut(DIM_COUNT);
dataspace.getSimpleExtentDims( &dimsOut.front(), 0 );
if ( (ROWS <= dimsOut[0]) && (COLS <= dimsOut[1]) )
{
std::vector<hsize_t> inputCount(DIM_COUNT);
std::vector<hsize_t> inputOffset(DIM_COUNT);
inputCount[0] = 1; // row
inputCount[1] = COLS; // col
// Output dataspace dimensions.
const ossim_int32 OUT_DIM_COUNT = 3;
std::vector<hsize_t> outputCount(OUT_DIM_COUNT);
outputCount[0] = 1; // single band
outputCount[1] = 1; // single line
outputCount[2] = COLS; // single sample
// Output dataspace offset.
std::vector<hsize_t> outputOffset(OUT_DIM_COUNT);
outputOffset[0] = 0;
outputOffset[1] = 0;
outputOffset[2] = 0;
ossimScalarType scalar = ossim_hdf5::getScalarType( &dataset );
if ( scalar == OSSIM_FLOAT32 )
{
// See if we need to swap bytes:
ossimEndian* endian = 0;
if ( ( ossim::byteOrder() != ossim_hdf5::getByteOrder( &dataset ) ) )
{
endian = new ossimEndian();
}
// Native type:
H5::DataType datatype = dataset.getDataType();
// Output dataspace always the same one line.
H5::DataSpace bufferDataSpace( OUT_DIM_COUNT, &outputCount.front());
bufferDataSpace.selectHyperslab( H5S_SELECT_SET,
&outputCount.front(),
&outputOffset.front() );
//---
// Dataset sample has NULL lines at the end so scan for valid rect.
// Use "<= -999" for test as per NOAA as it seems the NULL value is
// fuzzy. e.g. -999.3.
//---
// Buffer to hold a line:
std::vector<ossim_float32> lineBuffer(validRect.width());
// Read the first line:
inputOffset[0] = static_cast<hsize_t>(validRect.ul().y);
inputOffset[1] = static_cast<hsize_t>(validRect.ul().x);
dataspace.selectHyperslab( H5S_SELECT_SET,
&inputCount.front(),
&inputOffset.front() );
dataset.read( &(lineBuffer.front()), datatype, bufferDataSpace, dataspace );
if ( endian )
{
// If the endian pointer is initialized(not zero) swap the bytes.
endian->swap( &(lineBuffer.front()), COLS );
}
// Test the first line:
result = ossim_hdf5::crossesDateline( lineBuffer );
if ( !result )
{
// Test the last line:
inputOffset[0] = static_cast<hsize_t>(validRect.ll().y);
inputOffset[1] = static_cast<hsize_t>(validRect.ll().x);
dataspace.selectHyperslab( H5S_SELECT_SET,
&inputCount.front(),
&inputOffset.front() );
dataset.read( &(lineBuffer.front()), datatype, bufferDataSpace, dataspace );
result = ossim_hdf5::crossesDateline( lineBuffer );
}
if ( endian )
{
delete endian;
endian = 0;
}
}
else // Matches: if ( scalar == OSSIM_FLOAT32 ){...}
{
ossimNotify(ossimNotifyLevel_WARN)
<< "ossim_hdf5::crossesDateline WARNING!"
<< "\nUnhandled scalar type: "
<< ossimScalarTypeLut::instance()->getEntryString( scalar )
<< std::endl;
}
} // Matches: if ( dimsOut...
} // Matches: if ( IN_DIM_COUNT == 2 )
dataspace.close();
return result;
} // End: ossim_hdf5::crossesDateline(...)
void ossimH5ImageDataset::getTileBuf(void* buffer, const ossimIrect& rect, ossim_uint32 band)
{
static const char MODULE[] = "ossimH5ImageDataset::getTileBuf";
if ( m_dataset )
{
try
{
// Shift rectangle by the sub image offse (if any) from the m_validRect.
ossimIrect irect = rect + m_validRect.ul();
//--
// Turn off the auto-printing when failure occurs so that we can
// handle the errors appropriately
//---
// H5::Exception::dontPrint();
// NOTE: rank == array dimensions in hdf5 documentation lingo.
// Get dataspace of the dataset.
H5::DataSpace imageDataSpace = m_dataset->getSpace();
// Number of dimensions of the input dataspace.:
const ossim_int32 IN_DIM_COUNT = imageDataSpace.getSimpleExtentNdims();
// Native type:
H5::DataType dataType = m_dataset->getDataType();
std::vector<hsize_t> inputCount(IN_DIM_COUNT);
std::vector<hsize_t> inputOffset(IN_DIM_COUNT);
if ( IN_DIM_COUNT == 2 )
{
inputOffset[0] = irect.ul().y;
inputOffset[1] = irect.ul().x;
inputCount[0] = irect.height();
inputCount[1] = irect.width();
}
else
{
inputOffset[0] = band;
inputOffset[1] = irect.ul().y;
inputOffset[2] = irect.ul().x;
inputCount[0] = 1;
inputCount[1] = irect.height();
inputCount[2] = irect.width();
}
// Define hyperslab in the dataset; implicitly giving strike strike and block NULL.
imageDataSpace.selectHyperslab( H5S_SELECT_SET,
&inputCount.front(),
&inputOffset.front() );
// Output dataspace dimensions.
const ossim_int32 OUT_DIM_COUNT = 3;
std::vector<hsize_t> outputCount(OUT_DIM_COUNT);
outputCount[0] = 1; // single band
outputCount[1] = irect.height(); // lines
outputCount[2] = irect.width(); // samples
// Output dataspace offset.
std::vector<hsize_t> outputOffset(OUT_DIM_COUNT);
outputOffset[0] = 0;
outputOffset[1] = 0;
outputOffset[2] = 0;
// Output dataspace.
H5::DataSpace bufferDataSpace( OUT_DIM_COUNT, &outputCount.front());
bufferDataSpace.selectHyperslab( H5S_SELECT_SET,
&outputCount.front(),
&outputOffset.front() );
// Read data from file into the buffer.
m_dataset->read( buffer, dataType, bufferDataSpace, imageDataSpace );
if ( m_endian )
{
// If the m_endian pointer is initialized(not zero) swap the bytes.
m_endian->swap( m_scalar, buffer, irect.area() );
}
// Cleanup:
bufferDataSpace.close();
dataType.close();
imageDataSpace.close();
// memSpace.close();
// dataType.close();
// dataSpace.close();
}
catch( const H5::FileIException& error )
{
ossimNotify(ossimNotifyLevel_WARN)
<< MODULE << " caught H5::FileIException!" << std::endl;
error.printError();
}
// catch failure caused by the DataSet operations
catch( const H5::DataSetIException& error )
{
ossimNotify(ossimNotifyLevel_WARN)
<< MODULE << " caught H5::DataSetIException!" << std::endl;
error.printError();
}
// catch failure caused by the DataSpace operations
catch( const H5::DataSpaceIException& error )
{
ossimNotify(ossimNotifyLevel_WARN)
<< MODULE << " caught H5::DataSpaceIException!" << std::endl;
error.printError();
}
// catch failure caused by the DataSpace operations
catch( const H5::DataTypeIException& error )
{
ossimNotify(ossimNotifyLevel_WARN)
<< MODULE << " caught H5::DataTypeIException!" << std::endl;
error.printError();
}
catch( ... )
{
ossimNotify(ossimNotifyLevel_WARN)
<< MODULE << " caught unknown exception !" << std::endl;
}
} // Matches: if ( m_dataset )
} // End: ossimH5ImageDataset::getTileBuf
void Bundle2::saveGeometry(const boost::filesystem::path& fileName) const {
H5::H5File bundleFile;
bundleFile.openFile(fileName.string(), H5F_ACC_RDWR);
H5::Group rootGroup = bundleFile.openGroup("/");
// If the group "Geometry" exists, delete it!
if(checkGeometry_(bundleFile)) {
rootGroup.unlink("Geometry");
}
// Creating group Geometry
H5::Group geometryGroup = rootGroup.createGroup("Geometry");
// Saving poses
const hsize_t posesChunkDim[] = { 3, 12 };
H5::DSetCreatPropList posesPropList;
posesPropList.setLayout(H5D_CHUNKED);
posesPropList.setChunk(2, posesChunkDim);
posesPropList.setDeflate(9);
const hsize_t posesMaxDim[] = { H5S_UNLIMITED, 12 };
const hsize_t posesCurDim[] = { frames_.size(), 12 };
H5::DataSpace posesDS(2, posesCurDim, posesMaxDim);
H5::DataSet posesDataSet = geometryGroup.createDataSet("Poses", H5::PredType::IEEE_F64LE, posesDS, posesPropList);
double* posesData = (double*)malloc(frames_.size()*12*sizeof(double));
size_t i = 0;
for(deque<Frame*>::const_iterator it = frames_.begin(); it != frames_.end(); it++) {
posesData[i*12] = (*it)->pose()->t().x();
posesData[i*12 + 1] = (*it)->pose()->t().y();
posesData[i*12 + 2] = (*it)->pose()->t().z();
core::Matrix<double> R = (*it)->pose()->R();
posesData[i*12 + 3] = R[0][0];
posesData[i*12 + 4] = R[1][0];
posesData[i*12 + 5] = R[2][0];
posesData[i*12 + 6] = R[0][1];
posesData[i*12 + 7] = R[1][1];
posesData[i*12 + 8] = R[2][1];
posesData[i*12 + 9] = R[0][2];
posesData[i*12 + 10] = R[1][2];
posesData[i*12 + 11] = R[2][2];
++i;
}
posesDataSet.write((const void*)posesData, H5::PredType::NATIVE_DOUBLE, H5::DataSpace::ALL, H5::DataSpace::ALL);
free((void*)posesData);
posesDataSet.close();
posesDS.close();
// Saving points
const hsize_t pointsChunkDim[] = {10, 3};
H5::DSetCreatPropList pointsPropList;
pointsPropList.setLayout(H5D_CHUNKED);
pointsPropList.setChunk(2, pointsChunkDim);
pointsPropList.setDeflate(9);
const hsize_t pointsMaxDim[] = { H5S_UNLIMITED, 3 };
const hsize_t pointsCurDim[] = { tracks_.size(), 3 };
H5::DataSpace pointsDS(2, pointsCurDim, pointsMaxDim);
H5::DataSet pointsDataSet = geometryGroup.createDataSet("Points", H5::PredType::IEEE_F64LE, pointsDS, pointsPropList);
double* pointsData = (double*)malloc(tracks_.size()*3*sizeof(double));
i = 0;
for(deque<Track*>::const_iterator it = tracks_.begin(); it != tracks_.end(); it++) {
pointsData[i*3] = (*it)->point()->coords().x();
pointsData[i*3 + 1] = (*it)->point()->coords().y();
pointsData[i*3 + 2] = (*it)->point()->coords().z();
++i;
}
pointsDataSet.write((const void*)pointsData, H5::PredType::NATIVE_DOUBLE, H5::DataSpace::ALL, H5::DataSpace::ALL);
free((void*)pointsData);
pointsDataSet.close();
pointsDS.close();
// Saving inlier information
const hsize_t inliersChunkDim[] = { 3 };
H5::DSetCreatPropList inliersPropList;
inliersPropList.setLayout(H5D_CHUNKED);
inliersPropList.setChunk(1, inliersChunkDim);
inliersPropList.setDeflate(9);
const hsize_t inliersMaxDim[] = { H5S_UNLIMITED };
const hsize_t inliersCurDim[] = { frames_.size() };
H5::DataSpace inliersDS(1, inliersCurDim, inliersMaxDim);
H5::VarLenType inliersType(&H5::PredType::STD_U8LE);
H5::DataSet inliersDataSet = geometryGroup.createDataSet("Inliers", inliersType, inliersDS, inliersPropList);
i = 0;
for(deque<Frame*>::const_iterator it = frames_.begin(); it != frames_.end(); it++) {
hvl_t inliersLine;
size_t inliersLineSize = 0;
for(size_t j = 0; j < (*it)->size(); ++j) {
View& v = (**it)[j];
for(unsigned int cam = 0; cam < v.numCameras(); ++cam) {
if(v.inCamera(cam)) ++inliersLineSize;
}
}
inliersLine.len = inliersLineSize;
inliersLine.p = malloc(inliersLineSize*sizeof(unsigned char));
size_t k = 0;
for(size_t j = 0; j < (*it)->size(); ++j) {
View& v = (**it)[j];
for(unsigned int cam = 0; cam < v.numCameras(); ++cam) {
if(v.inCamera(cam)) {
((unsigned char*)(inliersLine.p))[k] = v.ray(cam).inlier()?1:0;
++k;
}
}
}
const hsize_t dsOffset[] = { i };
const hsize_t dsCount[] = { 1 };
H5::DataSpace inliersCurDS = inliersDataSet.getSpace();
inliersCurDS.selectHyperslab(H5S_SELECT_SET, dsCount, dsOffset);
const hsize_t memDim[] = { 1 };
H5::DataSpace memDS(1, memDim, memDim);
H5::VarLenType memType(&H5::PredType::NATIVE_UCHAR);
inliersDataSet.write((const void*)&inliersLine, memType, memDS, inliersCurDS);
memType.close();
memDS.close();
inliersCurDS.close();
free(inliersLine.p);
++i;
}
inliersDataSet.close();
inliersType.close();
inliersDS.close();
// Saving curves
if(!curves_.empty()) {
const hsize_t chunkDim[] = { 5 };
H5::DSetCreatPropList propList;
propList.setLayout(H5D_CHUNKED);
propList.setChunk(1, chunkDim);
propList.setDeflate(9);
H5::VarLenType curveDatasetType(&H5::PredType::STD_U64LE);
hsize_t curvesDim[] = { curves_.size() };
hsize_t curvesMaxDim[] = { H5S_UNLIMITED };
H5::DataSpace curvesDataspace(1, curvesDim, curvesMaxDim);
H5::DataSet curvesDataset = geometryGroup.createDataSet("Curves", curveDatasetType, curvesDataspace, propList);
for(size_t i = 0; i < curves_.size(); ++i) {
hvl_t curveLine;
curveLine.len = curves_[i].size();
curveLine.p = malloc(curves_[i].size()*sizeof(size_t));
for(size_t j = 0; j < curves_[i].size(); ++j) ((size_t*)(curveLine.p))[j] = curves_[i].track(j);
const hsize_t dsOffset[] = { i };
const hsize_t dsCount[] = { 1 };
H5::DataSpace curDS = curvesDataset.getSpace();
curDS.selectHyperslab(H5S_SELECT_SET, dsCount, dsOffset);
const hsize_t memDim[] = { 1 };
H5::DataSpace memDS(1, memDim, memDim);
H5::VarLenType memType(&H5::PredType::NATIVE_HSIZE);
curvesDataset.write((const void*)&curveLine, memType, memDS, curDS);
memType.close();
memDS.close();
curDS.close();
free(curveLine.p);
}
curvesDataset.close();
curvesDataspace.close();
curveDatasetType.close();
propList.close();
}
geometryGroup.close();
rootGroup.close();
bundleFile.close();
}
ossimRefPtr<ossimProjection> ossim_hdf5::getBilinearProjection(
H5::DataSet& latDataSet, H5::DataSet& lonDataSet, const ossimIrect& validRect )
{
ossimRefPtr<ossimProjection> proj = 0;
// Get dataspace of the dataset.
H5::DataSpace latDataSpace = latDataSet.getSpace();
H5::DataSpace lonDataSpace = lonDataSet.getSpace();
// Number of dimensions of the input dataspace:
const ossim_int32 DIM_COUNT = latDataSpace.getSimpleExtentNdims();
if ( DIM_COUNT == 2 )
{
// Get the extents. Assuming dimensions are same for lat lon dataset.
std::vector<hsize_t> dimsOut(DIM_COUNT);
latDataSpace.getSimpleExtentDims( &dimsOut.front(), 0 );
if ( dimsOut[0] && dimsOut[1] )
{
std::vector<hsize_t> inputCount(DIM_COUNT);
std::vector<hsize_t> inputOffset(DIM_COUNT);
inputOffset[0] = 0;
inputOffset[1] = 0;
inputCount[0] = 1;
inputCount[1] = 1;
// Output dataspace dimensions.
const ossim_int32 OUT_DIM_COUNT = 3;
std::vector<hsize_t> outputCount(OUT_DIM_COUNT);
outputCount[0] = 1; // single band
outputCount[1] = 1; // single line
outputCount[2] = 1; // single sample
// Output dataspace offset.
std::vector<hsize_t> outputOffset(OUT_DIM_COUNT);
outputOffset[0] = 0;
outputOffset[1] = 0;
outputOffset[2] = 0;
ossimScalarType scalar = ossim_hdf5::getScalarType( &latDataSet );
if ( scalar == OSSIM_FLOAT32 )
{
// See if we need to swap bytes:
ossimEndian* endian = 0;
if ( ( ossim::byteOrder() != ossim_hdf5::getByteOrder( &latDataSet ) ) )
{
endian = new ossimEndian();
}
// Native type:
H5::DataType latDataType = latDataSet.getDataType();
H5::DataType lonDataType = lonDataSet.getDataType();
std::vector<ossimDpt> ipts;
std::vector<ossimGpt> gpts;
ossimGpt gpt(0.0, 0.0, 0.0); // Assuming WGS84...
ossim_float32 latValue = 0.0;
ossim_float32 lonValue = 0.0;
// Only grab every 256th value.:
const ossim_int32 GRID_SIZE = 256;
// Output dataspace always the same one pixel.
H5::DataSpace bufferDataSpace( OUT_DIM_COUNT, &outputCount.front());
bufferDataSpace.selectHyperslab( H5S_SELECT_SET,
&outputCount.front(),
&outputOffset.front() );
//---
// Dataset sample has NULL lines at the end so scan for valid rect.
// Use "<= -999" for test as per NOAA as it seems the NULL value is
// fuzzy. e.g. -999.3.
//---
const ossim_float32 NULL_VALUE = -999.0;
//---
// Get the tie points within the valid rect:
//---
ossimDpt ipt = validRect.ul();
while ( ipt.y <= validRect.lr().y )
{
inputOffset[0] = static_cast<hsize_t>(ipt.y);
// Sample loop:
ipt.x = validRect.ul().x;
while ( ipt.x <= validRect.lr().x )
{
inputOffset[1] = static_cast<hsize_t>(ipt.x);
latDataSpace.selectHyperslab( H5S_SELECT_SET,
&inputCount.front(),
&inputOffset.front() );
lonDataSpace.selectHyperslab( H5S_SELECT_SET,
&inputCount.front(),
&inputOffset.front() );
// Read data from file into the buffer.
latDataSet.read( &latValue, latDataType, bufferDataSpace, latDataSpace );
lonDataSet.read( &lonValue, lonDataType, bufferDataSpace, lonDataSpace );
if ( endian )
{
// If the endian pointer is initialized(not zero) swap the bytes.
endian->swap( latValue );
endian->swap( lonValue );
}
if ( ( latValue > NULL_VALUE ) && ( lonValue > NULL_VALUE ) )
{
gpt.lat = latValue;
gpt.lon = lonValue;
gpts.push_back( gpt );
// Add the image point subtracting the image offset.
ossimIpt shiftedIpt = ipt - validRect.ul();
ipts.push_back( shiftedIpt );
}
// Go to next point:
if ( ipt.x < validRect.lr().x )
{
ipt.x += GRID_SIZE;
if ( ipt.x > validRect.lr().x )
{
ipt.x = validRect.lr().x; // Clamp to last sample.
}
}
else
{
break; // At the end:
}
} // End sample loop.
if ( ipt.y < validRect.lr().y )
{
ipt.y += GRID_SIZE;
if ( ipt.y > validRect.lr().y )
{
ipt.y = validRect.lr().y; // Clamp to last line.
}
}
else
{
break; // At the end:
}
} // End line loop.
if ( ipts.size() )
{
// Create the projection:
ossimRefPtr<ossimBilinearProjection> bp = new ossimBilinearProjection();
// Add the tie points:
bp->setTiePoints( ipts, gpts );
// Assign to output projection:
proj = bp.get();
}
// Cleanup:
if ( endian )
{
delete endian;
endian = 0;
}
}
else // Matches: if ( scalar == OSSIM_FLOAT32 ){...}
{
ossimNotify(ossimNotifyLevel_WARN)
<< "ossim_hdf5::getBilinearProjection WARNING!"
<< "\nUnhandled scalar type: "
<< ossimScalarTypeLut::instance()->getEntryString( scalar )
<< std::endl;
}
} // Matches: if ( dimsOut...
} // Matches: if ( IN_DIM_COUNT == 2 )
latDataSpace.close();
lonDataSpace.close();
return proj;
} // End: ossim_hdf5::getBilinearProjection()
bool ossimHdfGridModel::setGridNodes( H5::DataSet* latDataSet,
H5::DataSet* lonDataSet,
ossim_uint32 imageRows,
ossim_uint32 imageCols )
{
bool status = false;
if ( latDataSet && lonDataSet )
{
const ossim_uint32 GRID_SIZE = 32; // Only grab every 32nd value.
// Get dataspace of the dataset.
H5::DataSpace latDataSpace = latDataSet->getSpace();
H5::DataSpace lonDataSpace = lonDataSet->getSpace();
const ossim_int32 LAT_DIM_COUNT = latDataSpace.getSimpleExtentNdims();
const ossim_int32 LON_DIM_COUNT = latDataSpace.getSimpleExtentNdims();
// Number of dimensions of the input dataspace:
if ( ( LAT_DIM_COUNT == 2 ) && ( LON_DIM_COUNT == 2 ) )
{
//---
// Get the extents:
// dimsOut[0] is height, dimsOut[1] is width: //---
std::vector<hsize_t> latDimsOut(LAT_DIM_COUNT);
latDataSpace.getSimpleExtentDims( &latDimsOut.front(), 0 );
std::vector<hsize_t> lonDimsOut(LON_DIM_COUNT);
lonDataSpace.getSimpleExtentDims( &lonDimsOut.front(), 0 );
// Verify same as image:
if ( (latDimsOut[0] == imageRows) &&
(lonDimsOut[0] == imageRows) &&
(latDimsOut[1] == imageCols) &&
(lonDimsOut[1] == imageCols) )
{
//---
// Capture the rectangle:
// dimsOut[0] is height, dimsOut[1] is width:
//---
ossimIrect rect = ossimIrect( 0, 0,
static_cast<ossim_int32>( latDimsOut[1]-1 ),
static_cast<ossim_int32>( latDimsOut[0]-1 ) );
//----
// Initialize the ossimDblGrids:
//---
ossimDpt dspacing (GRID_SIZE, GRID_SIZE);
ossim_uint32 gridRows = imageRows / GRID_SIZE + 1;
ossim_uint32 gridCols = imageCols / GRID_SIZE + 1;
// Round up if size doesn't fall on end pixel.
if ( imageRows % GRID_SIZE) ++gridRows;
if ( imageCols % GRID_SIZE) ++gridCols;
ossimIpt gridSize (gridCols, gridRows);
// The grid as used in base class, has UV-space always at 0,0 origin
ossimDpt gridOrigin(0.0,0.0);
const ossim_float64 NULL_VALUE = -999.0;
theLatGrid.setNullValue(ossim::nan());
theLonGrid.setNullValue(ossim::nan());
theLatGrid.initialize(gridSize, gridOrigin, dspacing);
theLonGrid.initialize(gridSize, gridOrigin, dspacing);
std::vector<hsize_t> inputCount(LAT_DIM_COUNT);
std::vector<hsize_t> inputOffset(LAT_DIM_COUNT);
inputOffset[0] = 0; // row
inputOffset[1] = 0; // col
inputCount[0] = 1; // row
inputCount[1] = (hsize_t)imageCols; // col
// Output dataspace dimensions. Reading a line at a time.
const ossim_int32 OUT_DIM_COUNT = 3;
std::vector<hsize_t> outputCount(OUT_DIM_COUNT);
outputCount[0] = 1; // band
outputCount[1] = 1; // row
outputCount[2] = imageCols; // col
// Output dataspace offset.
std::vector<hsize_t> outputOffset(OUT_DIM_COUNT);
outputOffset[0] = 0;
outputOffset[1] = 0;
outputOffset[2] = 0;
ossimScalarType scalar = ossim_hdf5::getScalarType( latDataSet );
if ( scalar == OSSIM_FLOAT32 )
{
// Set the return status to true if we get here...
status = true;
// See if we need to swap bytes:
ossimEndian* endian = 0;
if ( ( ossim::byteOrder() != ossim_hdf5::getByteOrder( latDataSet ) ) )
{
endian = new ossimEndian();
}
// Native type:
H5::DataType latDataType = latDataSet->getDataType();
H5::DataType lonDataType = lonDataSet->getDataType();
// Output dataspace always the same, width of one line.
H5::DataSpace bufferDataSpace( OUT_DIM_COUNT, &outputCount.front());
bufferDataSpace.selectHyperslab( H5S_SELECT_SET,
&outputCount.front(),
&outputOffset.front() );
// Arrays to hold a single line of latitude longitude values.
vector<ossim_float32> latValue(imageCols);
vector<ossim_float32> lonValue(imageCols);
hsize_t row = 0;
// Line loop:
for ( ossim_uint32 y = 0; y < gridRows; ++y )
{
// row = line in image space
row = y*GRID_SIZE;
bool hitNans = false;
if ( row < imageRows )
{
inputOffset[0] = row;
latDataSpace.selectHyperslab( H5S_SELECT_SET,
&inputCount.front(),
&inputOffset.front() );
lonDataSpace.selectHyperslab( H5S_SELECT_SET,
&inputCount.front(),
&inputOffset.front() );
// Read data from file into the buffer.
latDataSet->read( &(latValue.front()), latDataType,
bufferDataSpace, latDataSpace );
lonDataSet->read( &(lonValue.front()), lonDataType,
bufferDataSpace, lonDataSpace );
if ( endian )
{
// If the endian pointer is initialized(not zero) swap the bytes.
endian->swap( &(latValue.front()), imageCols );
endian->swap( &(lonValue.front()), imageCols );
}
// Sample loop:
hsize_t col = 0;
for ( ossim_uint32 x = 0; x < gridCols; ++x )
{
ossim_float32 lat = ossim::nan();
ossim_float32 lon = ossim::nan();
// col = sample in image space
col = x*GRID_SIZE;
if ( col < imageCols )
{
if ( (latValue[col] > NULL_VALUE)&&(lonValue[col] > NULL_VALUE) )
{
lat = latValue[col];
lon = lonValue[col];
}
else
{
hitNans = true;
}
}
else // Last column is outside of image bounds.
{
ossim_float32 latSpacing = ossim::nan();
ossim_float32 lonSpacing = ossim::nan();
// Get the last two latitude values:
ossim_float32 lat1 = latValue[imageCols-2];
ossim_float32 lat2 = latValue[imageCols-1];
// Get the last two longitude values
ossim_float32 lon1 = lonValue[imageCols-2];
ossim_float32 lon2 = lonValue[imageCols-1];
if ( ( lat1 > NULL_VALUE ) && ( lat2 > NULL_VALUE ) )
{
// Delta between last two latitude values.
latSpacing = lat2 - lat1;
// Compute:
lat = lat2 + ( col - (imageCols-1) ) * latSpacing;
}
else
{
hitNans = true;
}
if ( ( lon1 > NULL_VALUE ) && ( lon2 > NULL_VALUE ) )
{
// Consider dateline crossing.
if ( (lon1 > 0.0) && ( lon2 < 0.0 ) )
{
lon2 += 360.0;
}
// Delta between last two longitude values.
lonSpacing = lon2 - lon1;
// Compute:
lon = lon2 + ( col - (imageCols-1) ) * lonSpacing;
// Check for wrap:
if ( lon > 180 )
{
lon -= 360.0;
}
}
else
{
hitNans = true;
}
#if 0 /* Please leave for debug. (drb) */
cout << "lat1: " << lat1 << " lat2 " << lat2
<< " lon1 " << lon1 << " lon2 " << lon2
<< "\n";
#endif
}
if ( hitNans )
{
std::string errMsg =
"ossimHdfGridModel::setGridNodes encountered nans!";
throw ossimException(errMsg);
}
// Assign the latitude and longitude.
theLatGrid.setNode( x, y, lat );
theLonGrid.setNode( x, y, lon );
#if 0 /* Please leave for debug. (drb) */
cout << "x,y,col,row,lat,lon:" << x << "," << y << ","
<< col << "," << row << ","
<< theLatGrid.getNode(x, y)
<< "," << theLonGrid.getNode( x, y) << "\n";
#endif
} // End sample loop.
}
else // Row is outside of image bounds:
{
// Read the last two rows in.
vector<ossim_float32> latValue2(imageCols);
vector<ossim_float32> lonValue2(imageCols);
inputOffset[0] = imageRows-2; // 2nd to last line
latDataSpace.selectHyperslab( H5S_SELECT_SET,
&inputCount.front(),
&inputOffset.front() );
lonDataSpace.selectHyperslab( H5S_SELECT_SET,
&inputCount.front(),
&inputOffset.front() );
// Read data from file into the buffer.
latDataSet->read( &(latValue.front()), latDataType,
bufferDataSpace, latDataSpace );
lonDataSet->read( &(lonValue.front()), lonDataType,
bufferDataSpace, lonDataSpace );
inputOffset[0] = imageRows-1; // last line
latDataSpace.selectHyperslab( H5S_SELECT_SET,
&inputCount.front(),
&inputOffset.front() );
lonDataSpace.selectHyperslab( H5S_SELECT_SET,
&inputCount.front(),
&inputOffset.front() );
// Read data from file into the buffer.
latDataSet->read( &(latValue2.front()), latDataType,
bufferDataSpace, latDataSpace );
lonDataSet->read( &(lonValue2.front()), lonDataType,
bufferDataSpace, lonDataSpace );
if ( endian )
{
// If the endian pointer is initialized(not zero) swap the bytes.
endian->swap( &(latValue.front()), imageCols );
endian->swap( &(lonValue.front()), imageCols );
endian->swap( &(latValue2.front()), imageCols );
endian->swap( &(lonValue2.front()), imageCols );
}
// Sample loop:
hsize_t col = 0;
for ( ossim_uint32 x = 0; x < gridCols; ++x )
{
col = x*GRID_SIZE; // Sample in image space.
ossim_float32 lat = ossim::nan();
ossim_float32 lat1 = ossim::nan();
ossim_float32 lat2 = ossim::nan();
ossim_float32 latSpacing = ossim::nan();
ossim_float32 lon = ossim::nan();
ossim_float32 lon1 = ossim::nan();
ossim_float32 lon2 = ossim::nan();
ossim_float32 lonSpacing = ossim::nan();
if ( col < imageCols )
{
lat1 = latValue[col];
lat2 = latValue2[col];
lon1 = lonValue[col];
lon2 = lonValue2[col];
}
else // Very last grid point.
{
// Compute the missing column for the last two image lines:
lat1 = latValue[imageCols-1] + ( col - (imageCols-1)) *
( latValue[imageCols-1] - latValue[imageCols-2] );
lat2 = latValue2[imageCols-1] + ( col - (imageCols-1)) *
( latValue2[imageCols-1] - latValue2[imageCols-2] );
lon1 = lonValue[imageCols-1] + ( col - (imageCols-1)) *
( lonValue[imageCols-1] - lonValue[imageCols-2] );
lon2 = lonValue2[imageCols-1] + ( col - (imageCols-1)) *
( lonValue2[imageCols-1] - lonValue2[imageCols-2] );
}
#if 0 /* Please leave for debug. (drb) */
cout << "lat1: " << lat1 << " lat2 " << lat2
<< " lon1 " << lon1 << " lon2 " << lon2
<< "\n";
#endif
if ( ( lon1 > NULL_VALUE ) && ( lon2 > NULL_VALUE ) )
{
// Consider dateline crossing.
if ( (lon1 > 0.0) && ( lon2 < 0.0 ) )
{
lon2 += 360.0;
}
// Delta between last two longitude values.
lonSpacing = lon2 - lon1;
// Compute:
lon = lon2 + ( row - (imageRows-1) ) * lonSpacing;
// Check for wrap:
if ( lon > 180 )
{
lon -= 360.0;
}
}
else
{
hitNans = true;
}
if ( ( lat1 > NULL_VALUE ) && ( lat2 > NULL_VALUE ) )
{
// Delta between last two latitude values.
latSpacing = lat2 - lat1;
// Compute:
lat = lat2 + ( row - (imageRows-1) ) * latSpacing;
}
else
{
hitNans = true;
}
if ( hitNans )
{
std::string errMsg =
"ossimHdfGridModel::setGridNodes encountered nans!";
throw ossimException(errMsg);
}
// Assign the latitude::
theLatGrid.setNode( x, y, lat );
// Assign the longitude.
theLonGrid.setNode( x, y, lon );
#if 0 /* Please leave for debug. (drb) */
cout << "x,y,col,row,lat,lon:" << x << "," << y << ","
<< col << "," << row << "," << lat << "," << lon << "\n";
#endif
} // End sample loop.
} // Matches if ( row < imageRows ){...}else{
} // End line loop.
latDataSpace.close();
lonDataSpace.close();
if ( status )
{
theLatGrid.enableExtrapolation();
theLonGrid.enableExtrapolation();
theHeightEnabledFlag = false;
ossimDrect imageRect(rect);
initializeModelParams(imageRect);
// debugDump();
}
} // Matches: if ( scalar == OSSIM_FLOAT32 )
} // Matches: if ( (latDimsOut[0] == imageRows) ...
} // Matches: if ( ( LAT_DIM_COUNT == 2 ) ...
} // Matches: if ( latDataSet && lonDataSet
return status;
} // End: bool ossimHdfGridModel::setGridNodes( H5::DataSet* latDataSet, ... )
