void Bundle2::storeParameters(H5::H5File& file) const {
H5::Group root = file.openGroup("/");
H5::DataSpace scalar;
H5::Attribute attr = root.createAttribute("version", H5::PredType::STD_U32LE, scalar);
attr.write(H5::PredType::NATIVE_UINT, &version_);
attr.close();
unsigned char r2 = parameters_.reduce2?1:0;
attr = root.createAttribute("reduce2", H5::PredType::STD_U8LE, scalar);
attr.write(H5::PredType::NATIVE_UCHAR, &r2);
attr.close();
attr = root.createAttribute("xROI", H5::PredType::STD_U32LE, scalar);
attr.write(H5::PredType::NATIVE_UINT, ¶meters_.xROI);
attr.close();
attr = root.createAttribute("yROI", H5::PredType::STD_U32LE, scalar);
attr.write(H5::PredType::NATIVE_UINT, ¶meters_.yROI);
attr.close();
scalar.close();
root.close();
}
bool loadStackHDF5( const char* fileName, Image4DSimple& img )
{
#ifdef USE_HDF5
H5::Exception::dontPrint();
H5::H5File file( fileName, H5F_ACC_RDONLY );
for ( size_t i = 0; i < file.getObjCount(); i++ )
{
H5std_string name = file.getObjnameByIdx( i );
if ( name == "Channels" )
{
H5::Group channels = file.openGroup( name );
// Grab the attributes
H5::Attribute attr = channels.openAttribute( "width" );
H5::DataType type = attr.getDataType();
long width, height;
attr.read( type, &width );
attr.close();
attr = channels.openAttribute( "height" );
attr.read( type, &height );
attr.close();
int num_channels = 0;
// Count the number of channels
for ( size_t obj = 0; obj < channels.getNumObjs(); obj++ )
if ( channels.getObjTypeByIdx( obj ) == H5G_DATASET )
num_channels++;
int channel_idx = 0;
for ( size_t obj = 0; obj < channels.getNumObjs(); obj++ )
{
if ( channels.getObjTypeByIdx( obj ) == H5G_DATASET )
{
H5std_string ds_name = channels.getObjnameByIdx( obj );
H5::DataSet data = channels.openDataSet( ds_name );
uint8_t* buffer = new uint8_t[ data.getStorageSize() ];
data.read( buffer, data.getDataType() );
QByteArray qbarray( ( const char* )buffer, data.getStorageSize() );
data.close();
if ( !loadIndexedStackFFMpeg( &qbarray, img, channel_idx++, num_channels,
width, height ) )
{
v3d_msg( "Error happened in HDF file reading. Stop. \n", false );
return false;
}
delete [] buffer;
}
}
}
}
#endif
return true;
}
void WriteTAttrib(const std::string& name, const T& value,
const H5::DataType& dType, const H5::DataSpace& dSpace){
//attributes are clunky in HDF5++ implementation - this is a workaround
//template is required to pass the proper value type
//create a new data set attribute
H5::Attribute attrib = dSet_.createAttribute(name,dType,dSpace);
//write the value to the attribute and close
attrib.write(dType,&value);
attrib.close();
}
void ReadAttrib(const std::string& name, T& value, const H5::DataType& dType){
//attributes are clunky in HDF5++ implementation - this is a workaround
//template is required to pass the proper value type
//access the built-in root group and create a new attribute for it.
H5::Group rootGroup = file_->openGroup("/");
H5::Attribute attrib = rootGroup.openAttribute(name);
//write the value to the attribute and close
attrib.read(dType,reinterpret_cast<void*>(&value));
attrib.close();
}
bool ossim_hdf5::getGroupAttributeValue( H5::H5File* file,
const std::string& group,
const std::string& key,
std::string& value )
{
static const char MODULE[] = "ossim_hdf5::getGroupAttributeValue";
bool result = false;
if ( file )
{
try // HDF5 library throws exceptions so wrap with try{}catch...
{
// Open the root group:
H5::Group* h5Group = new H5::Group( file->openGroup( group ) );
// Lookw for key:
H5::Attribute attr = h5Group->openAttribute( key );
std::string name = attr.getName();
H5::DataType type = attr.getDataType();
H5T_class_t typeClass = attr.getTypeClass();
if ( ( name == key ) && ( typeClass == H5T_STRING ) )
{
attr.read( type, value );
result = true;
}
// Cleanup:
attr.close();
h5Group->close();
delete h5Group;
h5Group = 0;
}
catch( const H5::Exception& e )
{
if (traceDebug())
{
ossimNotify(ossimNotifyLevel_WARN)
<< MODULE << " WARNING: Caught exception!\n"
<< e.getDetailMsg() << std::endl;
}
}
catch( ... )
{
ossimNotify(ossimNotifyLevel_WARN)
<< MODULE << " WARNING: Caught unknown exception!" << std::endl;
}
}
return result;
} // End: ossim_hdf5::getGroupAttributeValue
void Bundle2::loadParameters(H5::H5File& file) {
H5::Group root = file.openGroup("/");
// Checking version
unsigned int fileVersion;
H5::Attribute attr = root.openAttribute("version");
attr.read(H5::PredType::NATIVE_UINT, &fileVersion);
attr.close();
if(fileVersion != version_) throw std::runtime_error("Incompatible bundle version!");
// Reading number of cameras
hsize_t count;
H5::Group frame0Group = root.openGroup("POI/Frame 0000");
attr = frame0Group.openAttribute("count");
attr.read(H5::PredType::NATIVE_HSIZE, &count);
attr.close();
frame0Group.close();
numCameras_ = count;
// Reading parameters
unsigned char r2;
attr = root.openAttribute("reduce2");
attr.read(H5::PredType::NATIVE_UCHAR, &r2);
attr.close();
parameters_.reduce2 = (r2 == 1);
attr = root.openAttribute("xROI");
attr.read(H5::PredType::NATIVE_UINT, ¶meters_.xROI);
attr.close();
attr = root.openAttribute("yROI");
attr.read(H5::PredType::NATIVE_UINT, ¶meters_.yROI);
attr.close();
root.close();
}
void WriteAttrib(const std::string& name, const T& value,
const H5::DataType& dType, const H5::DataSpace& dSpace){
//attributes are clunky in HDF5++ implementation - this is a workaround
//template is required to pass the proper value type
//access the built-in root group and create a new attribute for it.
H5::Group rootGroup = file_->openGroup("/");
H5::Attribute attrib = rootGroup.createAttribute(name,dType,dSpace);
//write the value to the attribute and close
attrib.write(dType,&value);
attrib.close();
}
bool ossim_hdf5::getDatasetAttributeValue( H5::H5File* file,
const std::string& objectName,
const std::string& key,
std::string& value )
{
static const char MODULE[] = "ossim_hdf5::getDatasetAttributeValue";
bool result = false;
if ( file )
{
try // HDF5 library throws exceptions so wrap with try{}catch...
{
// Open the dataset:
H5::DataSet dataset = file->openDataSet( objectName );
// Lookw for key:
H5::Attribute attr = dataset.openAttribute( key );
std::string name = attr.getName();
H5::DataType type = attr.getDataType();
H5T_class_t typeClass = attr.getTypeClass();
if ( ( name == key ) && ( typeClass == H5T_STRING ) )
{
attr.read( type, value );
result = true;
}
// Cleanup:
attr.close();
dataset.close();
}
catch( const H5::Exception& e )
{
ossimNotify(ossimNotifyLevel_WARN)
<< MODULE << " WARNING: Caught exception!\n"
<< e.getDetailMsg() << std::endl;
}
catch( ... )
{
ossimNotify(ossimNotifyLevel_WARN)
<< MODULE << " WARNING: Caught unknown exception!" << std::endl;
}
}
return result;
} // End: ossim_hdf5::getDatasetAttributeValue
void WriteTStrAttrib(const std::string& name, const std::string& value){
std::string str = value;
str.resize( STRING_ATTRIB_SIZE );
//define the data type as a string with the value's length
H5::StrType strType(0, STRING_ATTRIB_SIZE );
//open the data set and create a new attribute of type string
H5::Attribute attrib =
dSet_.createAttribute(name, strType, H5::DataSpace(H5S_SCALAR));
//write value to the attribute and close
attrib.write(strType, str );
attrib.close();
}
void ReadTAttrib(const int& tableNum, const std::string& name,
T& value, const H5::DataType& dType){
//attributes are clunky in HDF5++ implementation - this is a workaround
//template is required to pass the proper value type
//std::cout << "attribute read name = " << name << std::endl;
std::string tNum = Num2Table(tableNum);
//open data set and read attribute "name"
dSet_ = file_->openDataSet(tNum);
H5::Attribute attrib = dSet_.openAttribute(name);
//write the value to the attribute and close
attrib.read(dType,reinterpret_cast<void*>(&value));
attrib.close();
}
void Bundle2::closeSaveStream() {
H5::DataSpace scalar;
// Saving remaining POI information
H5::Group poiGroup = streamFile_->openGroup("/POI");
H5::Attribute attr = poiGroup.createAttribute("count", H5::PredType::STD_U64LE, scalar);
hsize_t count = poiFirstFrame_;
attr.write(H5::PredType::NATIVE_HSIZE, &count);
attr.close();
poiGroup.close();
scalar.close();
// Closing HDF5 file
streamFile_->close();
delete streamFile_;
streamFile_ = NULL;
}
size_t H5Signal::clock_size(void)
/*-----------------------------*/
{
try {
H5::Attribute attr = dataset.openAttribute("clock") ;
hobj_ref_t ref ;
attr.read(H5::PredType::STD_REF_OBJ, &ref) ;
attr.close() ;
H5::DataSet clk(H5Rdereference(H5Iget_file_id(dataset.getId()), H5R_OBJECT, &ref)) ;
H5::DataSpace cspace = clk.getSpace() ;
int cdims = cspace.getSimpleExtentNdims() ;
hsize_t cshape[cdims] ;
cspace.getSimpleExtentDims(cshape) ;
return cshape[0] ;
}
catch (H5::AttributeIException e) { }
return -1 ;
}
const std::string ReadStrAttrib(const std::string& name){
//attributes are clunky in HDF5++ implementation - this is a workaround
//template is required to pass the proper value type
std::string value;
value.resize( STRING_ATTRIB_SIZE );
H5::StrType strType(0, STRING_ATTRIB_SIZE );
//access the built-in root group and create a new attribute for it.
H5::Group rootGroup = file_->openGroup("/");
H5::Attribute attrib = rootGroup.openAttribute(name);
//write the value to the attribute and close
attrib.read(strType,value);
attrib.close();
return value;
}
void WriteStrAttrib(const std::string& name, const std::string& value){
//HDF5 has a mangled way of creating string attributes -
//this is a workaround
//create a string array of length 1 containing the value to be written
//std::string strBuf[1] = {value};
std::string str = value;
str.resize( STRING_ATTRIB_SIZE );
//define the data type as a string with the value's length
H5::StrType strType(0, STRING_ATTRIB_SIZE );
//open the root group and create a new attribute of type string
H5::Group rootGroup = file_->openGroup("/");
H5::Attribute attrib = rootGroup.createAttribute(name,
strType,H5::DataSpace());
//write value to the attribute and close
attrib.write(strType, str);
attrib.close();
}
const std::string ReadTStrAttrib(const int& tableNum, const std::string& name){
//attributes are clunky in HDF5++ implementation - this is a workaround
//template is required to pass the proper value type
std::string tNum = Num2Table(tableNum);
std::string value;
value.resize( STRING_ATTRIB_SIZE );
//std::cout << "attribute string read name = " << tNum << std::endl;
H5::StrType strType(0, STRING_ATTRIB_SIZE );
dSet_ = file_->openDataSet(tNum);
H5::Attribute attrib = dSet_.openAttribute(name);
//write the value to the attribute and close
attrib.read(strType,value);
attrib.close();
return value;
}
void Bundle2::streamPOI(size_t frame) {
H5::DataSpace scalar;
H5::Group poiGroup = streamFile_->openGroup("/POI");
for(size_t i = poiFirstFrame_; i <= frame; ++i) {
const std::string frameGroupName = boost::str(boost::format("Frame %1$04d") % i);
H5::Group frameGroup = poiGroup.createGroup(frameGroupName);
hsize_t count = poi_[(ptrdiff_t)i - (ptrdiff_t)poiFirstFrame_].size();
H5::Attribute attr = frameGroup.createAttribute("count", H5::PredType::STD_U64LE, scalar);
attr.write(H5::PredType::NATIVE_HSIZE, &count);
attr.close();
for(size_t camera = 0; camera < poi_[(ptrdiff_t)i - (ptrdiff_t)poiFirstFrame_].size(); ++camera)
poi_[(ptrdiff_t)i - (ptrdiff_t)poiFirstFrame_][camera].save(frameGroup, camera);
frameGroup.close();
}
poiGroup.close();
scalar.close();
poi_.erase(poi_.begin(), poi_.begin() + (ptrdiff_t)frame - (ptrdiff_t)poiFirstFrame_ + 1);
poiFirstFrame_ = frame + 1;
}
~HDFAtom() {
if (IsInitialized()) {
attribute.close();
}
}
H5RandomReader::H5RandomReader(const std::string fileName, const std::string groupPath) throw (InvalidFileException) {
try {
file.openFile(fileName, H5F_ACC_RDONLY);}
catch ( H5::FileIException ) {
throw InvalidFileException("Cannot acces file");}
try {
group = file.openGroup(groupPath);}
catch ( H5::GroupIException ) {
file.close();
throw InvalidFileException("Cannot access group");}
/*
* extract timeline. This is also necessary to get the nbSteps.
*/
try {
timeline = group.openDataSet("timeline");
nSteps = timeline.getSpace().getSimpleExtentNpoints();}
catch ( H5::DataSetIException error ) {
//error.printError();
group.close();
file.close();
throw InvalidFileException("Cannot access timeline dataset");}
if (logging::info)
std::cerr << "Opened group \"" << fileName << groupPath << "\" which has " << nSteps << " steps.\n";
/*
* extract objects names in the xpGroup
*/
std::vector<std::string> names;
H5Literate(group.getId(), H5_INDEX_NAME, H5_ITER_INC, NULL, iterInGroup, &names);
/*
* extract data from object in xpGroup
* these data can be of 3 types: matrix, translate or wrench
* each data are saved in related map
*/
for (unsigned int i=0; i<names.size(); i++){ //TODO: skip timeline
H5::DataSet dSet = group.openDataSet(names[i]);
if (H5Aexists(dSet.getId(), "ArborisViewerType")) {
H5::Attribute att = dSet.openAttribute("ArborisViewerType");
std::string type;
att.read(att.getDataType(), type);
if (type == "matrix"){
H5::DataSpace dSpace = dSet.getSpace();
bool dimension_ok = false;
if (dSpace.getSimpleExtentNdims()==3) {
hsize_t dims[3];
dSpace.getSimpleExtentDims (dims);
if (dims[0] == nSteps && dims[1] == 4 && dims[2] == 4)
dimension_ok = true;}
if (dimension_ok)
matrices[names[i]] = dSet;
else {
if (logging::warning)
std::cerr << "Skipping dataset \"" << names[i] << "\" which has wrong dimensions. I was expecting (" << nSteps << ",4,4).\n";
dSet.close();}}
else if (type == "translate"){
H5::DataSpace dSpace = dSet.getSpace();
bool dimension_ok = false;
if (dSpace.getSimpleExtentNdims()==2) {
hsize_t dims[2];
dSpace.getSimpleExtentDims (dims);
if (dims[0] == nSteps && dims[1] == 3)
dimension_ok = true;}
if (dimension_ok)
translates[names[i]] = dSet;
else {
if (logging::warning)
std::cerr << "Skipping dataset \"" << names[i] << "\" which has wrong dimensions. I was expecting (" << nSteps << ",3).\n";
dSet.close();}}
else if (type == "wrench") {
H5::DataSpace dSpace = dSet.getSpace();
bool dimension_ok = false;
if (dSpace.getSimpleExtentNdims()==2) {
hsize_t dims[2];
dSpace.getSimpleExtentDims (dims);
if (dims[0] == nSteps && dims[1] == 6)
dimension_ok = true;}
if (dimension_ok)
wrenches[names[i]] = dSet;
else {
if (logging::warning)
std::cerr << "Skipping dataset \"" << names[i] << "\" which as wrong dimensions. I was expecting (" << nSteps << ",6).\n";
dSet.close();}}
else {
if (logging::warning)
std::cerr << "Skipping dataset \"" << names[i] << "\" whose ArborisViewerType attribute as unknown value \"" << type << "\".\n";
dSet.close();}
att.close();
}
else {
if (logging::info)
std::cerr << "Skipping dataset \"" << names[i] << "\" which has no ArborisViewerType attribute.\n";
dSet.close();
}
}
};
Bundle2::Bundle2(const boost::filesystem::path& fileName, bool loadGeometry):
version_(BUNDLE_VERSION), poiFirstFrame_(0) {
// Opening file
H5::H5File bundleFile;
bundleFile.openFile(fileName.string(), H5F_ACC_RDONLY);
loadParameters(bundleFile);
// Loading POI
H5::Group poiGroup = bundleFile.openGroup("/POI");
hsize_t count;
H5::Attribute attr = poiGroup.openAttribute("count");
attr.read(H5::PredType::NATIVE_HSIZE, &count);
attr.close();
for(size_t frame = 0; frame < count; ++frame) {
cout.flush();
const std::string frameGroupName = boost::str(boost::format("Frame %1$04d") % frame);
H5::Group frameGroup = poiGroup.openGroup(frameGroupName);
addPOIFrame();
for(size_t camera = 0; camera < numCameras_; ++camera)
poi_[poi_.size() - 1][camera].load(frameGroup, camera);
frameGroup.close();
}
poiGroup.close();
// Loading frames
H5::Group bundleGroup = bundleFile.openGroup("/Bundle");
H5::Group framesGroup = bundleGroup.openGroup("Frames");
attr = framesGroup.openAttribute("count");
attr.read(H5::PredType::NATIVE_HSIZE, &count);
attr.close();
for(size_t frame = 0; frame < count; ++frame) {
Frame* f = new Frame(framesGroup, frame, numCameras_);
frames_.push_back(f);
}
framesGroup.close();
// Loading tracks
H5::DataSet tracksDataset = bundleGroup.openDataSet("Tracks");
hsize_t tracksDim[2];
H5::DataSpace tracksDS = tracksDataset.getSpace();
tracksDS.getSimpleExtentDims(tracksDim);
tracksDS.close();
for(size_t i = 0; i < tracksDim[0]; ++i) {
size_t j = addTrack();
tracks_[j]->load(tracksDataset, frames_, i);
}
tracksDataset.close();
bundleGroup.close();
if(loadGeometry && checkGeometry_(bundleFile)) loadGeometry_(bundleFile);
bundleFile.close();
}
void ossim_hdf5::printObject( H5::H5File* file,
const std::string& objectName,
const std::string& prefix,
std::ostream& out )
{
#if 0
std::cout << "printObject entered..."
<< "\nobjectName: " << objectName
<< "\nprefix: " << prefix
<< std::endl;
#endif
H5::DataSet dataset = file->openDataSet( objectName );
// Get the class of the datatype that is used by the dataset.
H5T_class_t type_class = dataset.getTypeClass();
out << prefix << ".class_type: "
<< ossim_hdf5::getDatatypeClassType( type_class ) << std::endl;
const ossim_uint32 ATTRS_COUNT = dataset.getNumAttrs();
for ( ossim_uint32 aIdx = 0; aIdx < ATTRS_COUNT; ++aIdx )
{
H5::Attribute attr = dataset.openAttribute( aIdx );
ossim_hdf5::printAttribute( attr, prefix, out );
attr.close();
}
// Extents:
std::vector<ossim_uint32> extents;
ossim_hdf5::getExtents( &dataset, extents );
for ( ossim_uint32 i = 0; i < extents.size(); ++i )
{
ossimString os;
std::string exStr = ".extent";
exStr += os.toString(i).string();
out << prefix << exStr << ": " << extents[i] << std::endl;
}
// ossimScalarType scalar = getScalarType( type_class, dataset.getId() );
ossimScalarType scalar = ossim_hdf5::getScalarType( dataset.getId() );
if ( scalar != OSSIM_SCALAR_UNKNOWN)
{
out << prefix << "." << ossimKeywordNames::SCALAR_TYPE_KW << ": "
<< ossimScalarTypeLut::instance()->getEntryString( scalar ) << std::endl;
if ( ossim::scalarSizeInBytes( scalar ) > 1 )
{
ossimByteOrder byteOrder = ossim_hdf5::getByteOrder( &dataset );
std::string byteOrderString = "little_endian";
if ( byteOrder == OSSIM_BIG_ENDIAN )
{
byteOrderString = "big_endian";
}
out << prefix << "." <<ossimKeywordNames::BYTE_ORDER_KW << ": "
<< byteOrderString << std::endl;
}
}
#if 0
// Attributes:
int numberOfAttrs = dataset.getNumAttrs();
cout << "numberOfAttrs: " << numberOfAttrs << endl;
for ( ossim_int32 attrIdx = 0; attrIdx < numberOfAttrs; ++attrIdx )
{
H5::Attribute attribute = dataset.openAttribute( attrIdx );
cout << "attribute.from class: " << attribute.fromClass() << endl;
}
#endif
dataset.close();
} // End: printObject
void Bundle2::initFrameStream_() {
H5::DataSpace scalar;
// Creating datasets for each frame
H5::Group bundleGroup = streamFile_->createGroup("/Bundle");
H5::Group framesGroup = bundleGroup.createGroup("Frames");
hsize_t count = frames_.size();
H5::Attribute attr = framesGroup.createAttribute("count", H5::PredType::STD_U64LE, scalar);
attr.write(H5::PredType::NATIVE_HSIZE, &count);
attr.close();
// Defining frame dataset property
hsize_t chunkDim[] = { 1, 2, 10 };
H5::DSetCreatPropList propList;
propList.setLayout(H5D_CHUNKED);
propList.setChunk(3, chunkDim);
propList.setDeflate(9);
// Definig dataset dataspace
hsize_t max_dim[] = { numCameras_, 2, H5S_UNLIMITED };
hsize_t dim[] = { numCameras_, 2, 0 };
H5::DataSpace ds(3, dim, max_dim);
for(deque<Frame*>::const_iterator it = frames_.begin(); it != frames_.end(); it++) {
const std::string datasetName = boost::str(boost::format("Frame %1$04d") % (*it)->number());
// Creating dataset
H5::DataSet frameData = framesGroup.createDataSet(datasetName, H5::PredType::IEEE_F32LE, ds, propList);
// Writing global number
attr = frameData.createAttribute("globalNumber", H5::PredType::STD_U64LE, scalar);
count = (*it)->globalNumber();
attr.write(H5::PredType::NATIVE_HSIZE, &count);
attr.close();
// Clean up!
frameData.close();
}
// Clean up!
ds.close();
propList.close();
// Creating tracks dataset
hsize_t chunkDim2[] = { 2, 10 };
propList = H5::DSetCreatPropList();
propList.setLayout(H5D_CHUNKED);
propList.setChunk(2, chunkDim);
propList.setDeflate(9);
H5::VarLenType tracksDatasetType(&H5::PredType::STD_U64LE);
hsize_t tracksDim[] = { 0, 2 };
hsize_t tracksMaxDim[] = { H5S_UNLIMITED, 2 };
H5::DataSpace tracksDataspace(2, tracksDim, tracksMaxDim);
H5::DataSet tracksDataset = bundleGroup.createDataSet("Tracks", tracksDatasetType, tracksDataspace, propList);
tracksDataset.close();
tracksDataspace.close();
tracksDatasetType.close();
propList.close();
framesGroup.close();
bundleGroup.close();
scalar.close();
}
// Bundle management
void Bundle2::save(const boost::filesystem::path& fileName) const {
// Creating HDF5 file
H5::H5File bundleFile(fileName.string(), H5F_ACC_TRUNC);
storeParameters(bundleFile);
H5::DataSpace scalar;
// Saving POI
H5::Group poiGroup = bundleFile.createGroup("/POI");
H5::Attribute attr = poiGroup.createAttribute("count", H5::PredType::STD_U64LE, scalar);
hsize_t count = poi_.size();
attr.write(H5::PredType::NATIVE_HSIZE, &count);
attr.close();
for(size_t frame = 0; frame < poi_.size(); ++frame) {
const std::string frameGroupName = boost::str(boost::format("Frame %1$04d") % frame);
H5::Group frameGroup = poiGroup.createGroup(frameGroupName);
count = poi_[frame].size();
attr = frameGroup.createAttribute("count", H5::PredType::STD_U64LE, scalar);
attr.write(H5::PredType::NATIVE_HSIZE, &count);
attr.close();
for(size_t camera = 0; camera < poi_[frame].size(); ++camera)
poi_[frame][camera].save(frameGroup, camera);
frameGroup.close();
}
poiGroup.close();
// Saving key frames
H5::Group bundleGroup = bundleFile.createGroup("/Bundle");
H5::Group framesGroup = bundleGroup.createGroup("Frames");
count = frames_.size();
attr = framesGroup.createAttribute("count", H5::PredType::STD_U64LE, scalar);
attr.write(H5::PredType::NATIVE_HSIZE, &count);
attr.close();
for(deque<Frame*>::const_iterator it = frames_.begin(); it != frames_.end(); it++) {
(*it)->save(framesGroup);
}
framesGroup.close();
// Saving tracks
const hsize_t chunkDim[] = { 2, 1 };
H5::DSetCreatPropList propList;
propList.setLayout(H5D_CHUNKED);
propList.setChunk(2, chunkDim);
propList.setDeflate(9);
H5::VarLenType tracksDatasetType(&H5::PredType::STD_U64LE);
hsize_t tracksDim[] = { tracks_.size(), 2 };
hsize_t tracksMaxDim[] = { H5S_UNLIMITED, 2 };
H5::DataSpace tracksDataspace(2, tracksDim, tracksMaxDim);
H5::DataSet tracksDataset = bundleGroup.createDataSet("Tracks", tracksDatasetType, tracksDataspace, propList);
for(size_t i = 0; i < tracks_.size(); ++i)
tracks_[i]->save(tracksDataset, i);
tracksDataset.close();
tracksDataspace.close();
tracksDatasetType.close();
propList.close();
bundleGroup.close();
scalar.close();
bundleFile.close();
}
~HDFAtom() {
if (initialized) {
attribute.close();
}
}
