herr_t H5ARRAYget_chunkshape( hid_t dataset_id,
int rank,
hsize_t *dims_chunk)
{
hid_t plist_id;
H5D_layout_t layout;
/* Get creation properties list */
if ( (plist_id = H5Dget_create_plist( dataset_id )) < 0 )
goto out;
/* Get the dataset layout */
layout = H5Pget_layout(plist_id);
if (layout != H5D_CHUNKED) {
H5Pclose( plist_id );
return -1;
}
/* Get the chunkshape for all dimensions */
if (H5Pget_chunk(plist_id, rank, dims_chunk ) < 0 )
goto out;
/* Terminate access to the datatype */
if ( H5Pclose( plist_id ) < 0 )
goto out;
return 0;
out:
if (dims_chunk) free(dims_chunk);
return -1;
}
//--------------------------------------------------------------------------
// Function: DSetCreatPropList::getChunk
///\brief Retrieves the size of the chunks used to store a chunked
/// layout dataset.
///\param max_ndims - IN: Size of \a dim array
///\param dim - OUT: Array to store the chunk dimensions
///\exception H5::PropListIException
// Programmer Binh-Minh Ribler - 2000
//--------------------------------------------------------------------------
int DSetCreatPropList::getChunk( int max_ndims, hsize_t* dim ) const
{
int chunk_size = H5Pget_chunk( id, max_ndims, dim );
if( chunk_size < 0 )
{
throw PropListIException("DSetCreatPropList::getChunk",
"H5Pget_chunk returns negative chunk size");
}
return( chunk_size );
}
void FWSingle::readInFloat(int step, vector<float>& data_out)
{
int RANK=1;
hid_t dataset;
hid_t filespace;
hid_t memspace;
hid_t cparms;
hsize_t dims[2]; /* dataset and chunk dimensions*/
hsize_t chunk_dims[1];
hsize_t col_dims[1];
hsize_t count[2];
hsize_t offset[2];
herr_t status, status_n;
int rank, rank_chunk;
hsize_t hi, hj;
c_file = H5Fopen(fname.str().c_str(),H5F_ACC_RDONLY,H5P_DEFAULT);
stringstream gname("");
gname<<"Block_"<< step;
hid_t d_file = H5Gopen(c_file,gname.str().c_str());
dataset = H5Dopen(d_file, "Positions");
filespace = H5Dget_space(dataset);
rank = H5Sget_simple_extent_ndims(filespace);
status_n = H5Sget_simple_extent_dims(filespace, dims, NULL);
// if (verbose>1) printf("dataset rank %d, dimensions %lu x %lu\n", rank, (unsigned long)(dims[0]), (unsigned long)(dims[1]));
data_out.resize(dims[0]);
cparms = H5Dget_create_plist(dataset);
if (H5D_CHUNKED == H5Pget_layout(cparms)) {
rank_chunk = H5Pget_chunk(cparms, 2, chunk_dims);
// if (verbose>1) printf("chunk rank %d, dimensions %lu \n", rank_chunk, (unsigned long)(chunk_dims[0]) );
}
memspace = H5Screate_simple(RANK,dims,NULL);
status = H5Dread(dataset, H5T_NATIVE_FLOAT, memspace, filespace, H5P_DEFAULT, &(data_out[0]));
if(verbose>2)
{
printf("\n");
printf("Dataset: \n");
for (int j = 0; j < dims[0]; j++) app_log()<<data_out[j]<<" ";
app_log()<<endl;
}
H5Pclose(cparms);
H5Dclose(dataset);
H5Sclose(filespace);
H5Sclose(memspace);
H5Gclose(d_file);
H5Fclose(c_file);
}
HDF5ImageRasterBand::HDF5ImageRasterBand( HDF5ImageDataset *poDS, int nBand,
GDALDataType eType )
{
char **papszMetaGlobal;
this->poDS = poDS;
this->nBand = nBand;
eDataType = eType;
bNoDataSet = FALSE;
dfNoDataValue = -9999;
nBlockXSize = poDS->GetRasterXSize( );
nBlockYSize = 1;
/* -------------------------------------------------------------------- */
/* Take a copy of Global Metadata since I can't pass Raster */
/* variable to Iterate function. */
/* -------------------------------------------------------------------- */
papszMetaGlobal = CSLDuplicate( poDS->papszMetadata );
CSLDestroy( poDS->papszMetadata );
poDS->papszMetadata = NULL;
if( poDS->poH5Objects->nType == H5G_DATASET ) {
poDS->CreateMetadata( poDS->poH5Objects, H5G_DATASET );
}
/* -------------------------------------------------------------------- */
/* Recover Global Metadat and set Band Metadata */
/* -------------------------------------------------------------------- */
SetMetadata( poDS->papszMetadata );
CSLDestroy( poDS->papszMetadata );
poDS->papszMetadata = CSLDuplicate( papszMetaGlobal );
CSLDestroy( papszMetaGlobal );
/* check for chunksize and set it as the blocksize (optimizes read) */
hid_t listid = H5Dget_create_plist(((HDF5ImageDataset * )poDS)->dataset_id);
if (listid>0)
{
if(H5Pget_layout(listid) == H5D_CHUNKED)
{
hsize_t panChunkDims[3];
int nDimSize = H5Pget_chunk(listid, 3, panChunkDims);
nBlockXSize = (int) panChunkDims[nDimSize-1];
nBlockYSize = (int) panChunkDims[nDimSize-2];
}
H5Pclose(listid);
}
}
HDF5ImageRasterBand::HDF5ImageRasterBand( HDF5ImageDataset *poDSIn, int nBandIn,
GDALDataType eType ) :
bNoDataSet(false),
dfNoDataValue(-9999.0)
{
poDS = poDSIn;
nBand = nBandIn;
eDataType = eType;
nBlockXSize = poDS->GetRasterXSize( );
nBlockYSize = 1;
/* -------------------------------------------------------------------- */
/* Take a copy of Global Metadata since I can't pass Raster */
/* variable to Iterate function. */
/* -------------------------------------------------------------------- */
char **papszMetaGlobal = CSLDuplicate( poDSIn->papszMetadata );
CSLDestroy( poDSIn->papszMetadata );
poDSIn->papszMetadata = NULL;
if( poDSIn->poH5Objects->nType == H5G_DATASET ) {
poDSIn->CreateMetadata( poDSIn->poH5Objects, H5G_DATASET );
}
/* -------------------------------------------------------------------- */
/* Recover Global Metadata and set Band Metadata */
/* -------------------------------------------------------------------- */
SetMetadata( poDSIn->papszMetadata );
CSLDestroy( poDSIn->papszMetadata );
poDSIn->papszMetadata = CSLDuplicate( papszMetaGlobal );
CSLDestroy( papszMetaGlobal );
/* check for chunksize and set it as the blocksize (optimizes read) */
const hid_t listid = H5Dget_create_plist(poDSIn->dataset_id);
if (listid>0)
{
if(H5Pget_layout(listid) == H5D_CHUNKED)
{
hsize_t panChunkDims[3] = {0, 0, 0};
const int nDimSize = H5Pget_chunk(listid, 3, panChunkDims);
CPL_IGNORE_RET_VAL(nDimSize);
CPLAssert(nDimSize == poDSIn->ndims);
nBlockXSize = (int) panChunkDims[poDSIn->GetXIndex()];
nBlockYSize = (int) panChunkDims[poDSIn->GetYIndex()];
}
H5Pclose(listid);
}
}
int has_layout(hid_t dcpl_id,
pack_info_t *obj)
{
hsize_t chsize[64]; /* chunk size in elements */
H5D_layout_t layout; /* layout */
int nfilters; /* number of filters */
int rank; /* rank */
int i; /* index */
/* if no information about the input layout is requested return exit */
if (obj==NULL)
return 1;
/* check if we have filters in the input object */
if ((nfilters = H5Pget_nfilters(dcpl_id))<0)
return -1;
/* a non chunked layout was requested on a filtered object; avoid the test */
if (nfilters && obj->layout!=H5D_CHUNKED)
return 1;
/* get layout */
if ((layout = H5Pget_layout(dcpl_id))<0)
return -1;
if (obj->layout != layout)
return 0;
if (layout==H5D_CHUNKED)
{
if ((rank = H5Pget_chunk(dcpl_id,NELMTS(chsize),chsize/*out*/))<0)
return -1;
if (obj->chunk.rank != rank)
return 0;
for ( i=0; i<rank; i++)
if (chsize[i] != obj->chunk.chunk_lengths[i])
return 0;
}
return 1;
}
int H5mdfile::H5_Dopen2(int argc, char **argv, Tcl_Interp *interp)
{
/* Open an existing dataset */
dataset_id = H5Dopen2(file_id, argv[2], H5P_DEFAULT);
// Dataset properties
dataspace_id = H5Dget_space(dataset_id);
dataset_type_id = H5Dget_type(dataset_id);
datatype_size = H5Tget_size(dataset_type_id);
dataset_rank = H5Sget_simple_extent_dims(dataspace_id,dims,maxdims);
dataset_rank = H5Sget_simple_extent_dims(dataspace_id,dimstotal,maxdims);
prop_id = H5Dget_create_plist(dataset_id);
if (H5D_CHUNKED == H5Pget_layout(prop_id))
chunk_rank = H5Pget_chunk(prop_id, dataset_rank, chunk_dims);
// Dataset size
dset_data_size=1;
for(int i=0;i<dataset_rank;i++)
{
dset_data_size*=dims[i];
}
return TCL_OK;
}
static herr_t group_info (hid_t loc_id,
const char *name,
const H5L_info_t *linfo,
void *opdata)
{
hid_t datasetID; /* dataset identifier */
hid_t datatypeID; /* datatype identifier */
hid_t propertyID; /* data_property identifier */
H5T_class_t t_class;
hsize_t chunk_dims_out[2];
int rank_chunk;
/* avoid warnings */
opdata = opdata;
linfo = linfo;
/*
* Open the datasets using their names.
*/
datasetID = H5Dopen (loc_id, name, H5P_DEFAULT);
/*
* Display dataset name.
*/
printf("\nName : %s\n", name);
/*
* Display dataset information.
*/
datatypeID = H5Dget_type(datasetID); /* get datatype*/
propertyID = H5Dget_create_plist(datasetID); /* get creation property list */
/*
* Check if dataset is chunked.
*/
if(H5D_CHUNKED == H5Pget_layout(propertyID)) {
/*
* get chunking information: rank and dimensions.
*/
rank_chunk = H5Pget_chunk(propertyID, 2, chunk_dims_out);
printf("chunk rank %d, dimensions %lu x %lu\n", rank_chunk,
(unsigned long)(chunk_dims_out[0]),
(unsigned long)(chunk_dims_out[1]));
}
else {
t_class = H5Tget_class(datatypeID);
if(t_class < 0) {
puts(" Invalid datatype.\n");
}
else {
if(t_class == H5T_INTEGER)
puts(" Datatype is 'H5T_NATIVE_INTEGER'.\n");
if(t_class == H5T_FLOAT)
puts(" Datatype is 'H5T_NATIVE_FLOAT'.\n");
if(t_class == H5T_STRING)
puts(" Datatype is 'H5T_NATIVE_STRING'.\n");
if(t_class == H5T_BITFIELD)
puts(" Datatype is 'H5T_NATIVE_BITFIELD'.\n");
if(t_class == H5T_OPAQUE)
puts(" Datatype is 'H5T_NATIVE_OPAQUE'.\n");
if(t_class == H5T_COMPOUND)
puts(" Datatype is 'H5T_NATIVE_COMPOUND'.\n");
}
}
H5Dclose(datasetID);
H5Pclose(propertyID);
H5Tclose(datatypeID);
return 0;
}
int apply_filters(const char* name, /* object name from traverse list */
int rank, /* rank of dataset */
hsize_t *dims, /* dimensions of dataset */
size_t msize, /* size of type */
hid_t dcpl_id, /* dataset creation property list */
pack_opt_t *options, /* repack options */
int *has_filter) /* (OUT) object NAME has a filter */
{
int nfilters; /* number of filters in DCPL */
hsize_t chsize[64]; /* chunk size in elements */
H5D_layout_t layout;
int i;
pack_info_t obj;
*has_filter = 0;
if (rank==0) /* scalar dataset, do not apply */
return 0;
/*-------------------------------------------------------------------------
* initialize the assigment object
*-------------------------------------------------------------------------
*/
init_packobject(&obj);
/*-------------------------------------------------------------------------
* find options
*-------------------------------------------------------------------------
*/
if (aux_assign_obj(name,options,&obj)==0)
return 0;
/* get information about input filters */
if ((nfilters = H5Pget_nfilters(dcpl_id))<0)
return -1;
/*-------------------------------------------------------------------------
* check if we have filters in the pipeline
* we want to replace them with the input filters
* only remove if we are inserting new ones
*-------------------------------------------------------------------------
*/
if (nfilters && obj.nfilters )
{
*has_filter = 1;
if (H5Premove_filter(dcpl_id,H5Z_FILTER_ALL)<0)
return -1;
}
/*-------------------------------------------------------------------------
* check if there is an existent chunk
* read it only if there is not a requested layout
*-------------------------------------------------------------------------
*/
if (obj.layout == -1 )
{
if ((layout = H5Pget_layout(dcpl_id))<0)
return -1;
if (layout == H5D_CHUNKED)
{
if ((rank = H5Pget_chunk(dcpl_id,NELMTS(chsize),chsize/*out*/))<0)
return -1;
obj.layout = H5D_CHUNKED;
obj.chunk.rank = rank;
for ( i = 0; i < rank; i++)
obj.chunk.chunk_lengths[i] = chsize[i];
}
}
/*-------------------------------------------------------------------------
* the type of filter and additional parameter
* type can be one of the filters
* H5Z_FILTER_NONE 0 , uncompress if compressed
* H5Z_FILTER_DEFLATE 1 , deflation like gzip
* H5Z_FILTER_SHUFFLE 2 , shuffle the data
* H5Z_FILTER_FLETCHER32 3 , fletcher32 checksum of EDC
* H5Z_FILTER_SZIP 4 , szip compression
* H5Z_FILTER_NBIT 5 , nbit compression
* H5Z_FILTER_SCALEOFFSET 6 , scaleoffset compression
*-------------------------------------------------------------------------
*/
if (obj.nfilters)
{
/*-------------------------------------------------------------------------
* filters require CHUNK layout; if we do not have one define a default
*-------------------------------------------------------------------------
*/
if (obj.layout==-1)
{
/* stripmine info */
hsize_t sm_size[H5S_MAX_RANK]; /*stripmine size */
hsize_t sm_nbytes; /*bytes per stripmine */
obj.chunk.rank = rank;
/*
* determine the strip mine size. The strip mine is
* a hyperslab whose size is manageable.
*/
sm_nbytes = msize;
for ( i = rank; i > 0; --i)
{
hsize_t size = H5TOOLS_BUFSIZE / sm_nbytes;
if ( size == 0) /* datum size > H5TOOLS_BUFSIZE */
size = 1;
sm_size[i - 1] = MIN(dims[i - 1], size);
sm_nbytes *= sm_size[i - 1];
assert(sm_nbytes > 0);
}
for ( i = 0; i < rank; i++)
{
obj.chunk.chunk_lengths[i] = sm_size[i];
}
}
for ( i=0; i<obj.nfilters; i++)
{
switch (obj.filter[i].filtn)
{
default:
break;
/*-------------------------------------------------------------------------
* H5Z_FILTER_DEFLATE 1 , deflation like gzip
*-------------------------------------------------------------------------
*/
case H5Z_FILTER_DEFLATE:
{
unsigned aggression; /* the deflate level */
aggression = obj.filter[i].cd_values[0];
/* set up for deflated data */
if(H5Pset_chunk(dcpl_id, obj.chunk.rank, obj.chunk.chunk_lengths)<0)
return -1;
if(H5Pset_deflate(dcpl_id,aggression)<0)
return -1;
}
break;
/*-------------------------------------------------------------------------
* H5Z_FILTER_SZIP 4 , szip compression
*-------------------------------------------------------------------------
*/
case H5Z_FILTER_SZIP:
{
unsigned options_mask;
unsigned pixels_per_block;
options_mask = obj.filter[i].cd_values[0];
pixels_per_block = obj.filter[i].cd_values[1];
/* set up for szip data */
if(H5Pset_chunk(dcpl_id,obj.chunk.rank,obj.chunk.chunk_lengths)<0)
return -1;
if (H5Pset_szip(dcpl_id,options_mask,pixels_per_block)<0)
return -1;
}
break;
/*-------------------------------------------------------------------------
* H5Z_FILTER_SHUFFLE 2 , shuffle the data
*-------------------------------------------------------------------------
*/
case H5Z_FILTER_SHUFFLE:
if(H5Pset_chunk(dcpl_id, obj.chunk.rank, obj.chunk.chunk_lengths)<0)
return -1;
if (H5Pset_shuffle(dcpl_id)<0)
return -1;
break;
/*-------------------------------------------------------------------------
* H5Z_FILTER_FLETCHER32 3 , fletcher32 checksum of EDC
*-------------------------------------------------------------------------
*/
case H5Z_FILTER_FLETCHER32:
if(H5Pset_chunk(dcpl_id, obj.chunk.rank, obj.chunk.chunk_lengths)<0)
return -1;
if (H5Pset_fletcher32(dcpl_id)<0)
return -1;
break;
/*----------- -------------------------------------------------------------
* H5Z_FILTER_NBIT , NBIT compression
*-------------------------------------------------------------------------
*/
case H5Z_FILTER_NBIT:
if(H5Pset_chunk(dcpl_id, obj.chunk.rank, obj.chunk.chunk_lengths)<0)
return -1;
if (H5Pset_nbit(dcpl_id)<0)
return -1;
break;
/*----------- -------------------------------------------------------------
* H5Z_FILTER_SCALEOFFSET , scale+offset compression
*-------------------------------------------------------------------------
*/
case H5Z_FILTER_SCALEOFFSET:
{
H5Z_SO_scale_type_t scale_type;
int scale_factor;
scale_type = (H5Z_SO_scale_type_t)obj.filter[i].cd_values[0];
scale_factor = obj.filter[i].cd_values[1];
if(H5Pset_chunk(dcpl_id, obj.chunk.rank, obj.chunk.chunk_lengths)<0)
return -1;
if (H5Pset_scaleoffset(dcpl_id,scale_type,scale_factor)<0)
return -1;
}
break;
} /* switch */
}/*i*/
}
/*obj.nfilters*/
/*-------------------------------------------------------------------------
* layout
*-------------------------------------------------------------------------
*/
if (obj.layout>=0)
{
/* a layout was defined */
if (H5Pset_layout(dcpl_id, obj.layout)<0)
return -1;
if (H5D_CHUNKED == obj.layout)
{
if(H5Pset_chunk(dcpl_id, obj.chunk.rank, obj.chunk.chunk_lengths)<0)
return -1;
}
else if (H5D_COMPACT == obj.layout)
{
if (H5Pset_alloc_time(dcpl_id, H5D_ALLOC_TIME_EARLY)<0)
return -1;
}
/* remove filters for the H5D_CONTIGUOUS case */
else if (H5D_CONTIGUOUS == obj.layout)
{
if (H5Premove_filter(dcpl_id,H5Z_FILTER_ALL)<0)
return -1;
}
}
return 0;
}
bool BAGRasterBand::Initialize( hid_t hDatasetID, const char *pszName )
{
SetDescription( pszName );
this->hDatasetID = hDatasetID;
hid_t datatype = H5Dget_type( hDatasetID );
dataspace = H5Dget_space( hDatasetID );
hid_t n_dims = H5Sget_simple_extent_ndims( dataspace );
native = H5Tget_native_type( datatype, H5T_DIR_ASCEND );
hsize_t dims[3], maxdims[3];
eDataType = GH5_GetDataType( native );
if( n_dims == 2 )
{
H5Sget_simple_extent_dims( dataspace, dims, maxdims );
nRasterXSize = dims[1];
nRasterYSize = dims[0];
}
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"Dataset not of rank 2." );
return false;
}
nBlockXSize = nRasterXSize;
nBlockYSize = 1;
/* -------------------------------------------------------------------- */
/* Check for chunksize, and use it as blocksize for optimized */
/* reading. */
/* -------------------------------------------------------------------- */
hid_t listid = H5Dget_create_plist( hDatasetID );
if (listid>0)
{
if(H5Pget_layout(listid) == H5D_CHUNKED)
{
hsize_t panChunkDims[3];
int nDimSize = H5Pget_chunk(listid, 3, panChunkDims);
nBlockXSize = panChunkDims[nDimSize-1];
nBlockYSize = panChunkDims[nDimSize-2];
}
H5Pclose(listid);
}
/* -------------------------------------------------------------------- */
/* Load min/max information. */
/* -------------------------------------------------------------------- */
if( EQUAL(pszName,"elevation")
&& GH5_FetchAttribute( hDatasetID, "Maximum Elevation Value",
dfMaximum )
&& GH5_FetchAttribute( hDatasetID, "Minimum Elevation Value",
dfMinimum ) )
bMinMaxSet = true;
else if( EQUAL(pszName,"uncertainty")
&& GH5_FetchAttribute( hDatasetID, "Maximum Uncertainty Value",
dfMaximum )
&& GH5_FetchAttribute( hDatasetID, "Minimum Uncertainty Value",
dfMinimum ) )
bMinMaxSet = true;
else if( EQUAL(pszName,"nominal_elevation")
&& GH5_FetchAttribute( hDatasetID, "max_value",
dfMaximum )
&& GH5_FetchAttribute( hDatasetID, "min_value",
dfMinimum ) )
bMinMaxSet = true;
return true;
}
/*! Get a copy of the volume property list. When the program is finished
* using the property list it should call mifree_volume_props() to free the
* memory associated with the list.
* \param volume A volume handle
* \param props A pointer to the returned volume properties handle.
* \ingroup mi2VPrp
*/
int miget_volume_props(mihandle_t volume, mivolumeprops_t *props)
{
mivolumeprops_t handle;
hid_t hdf_vol_dataset;
hid_t hdf_plist;
int nfilters;
unsigned int flags;
size_t cd_nelmts;
unsigned int cd_values[MI2_MAX_CD_ELEMENTS];
char fname[MI2_CHAR_LENGTH];
int fcode;
if (volume->hdf_id < 0) {
return (MI_ERROR);
}
hdf_vol_dataset = midescend_path(volume->hdf_id, "/minc-2.0/image/0/image");
if (hdf_vol_dataset < 0) {
return (MI_ERROR);
}
hdf_plist = H5Dget_create_plist(hdf_vol_dataset);
if (hdf_plist < 0) {
return (MI_ERROR);
}
handle = (mivolumeprops_t)malloc(sizeof(struct mivolprops));
if (handle == NULL) {
return (MI_ERROR);
}
/* Get the layout of the raw data for a dataset.
*/
if (H5Pget_layout(hdf_plist) == H5D_CHUNKED) {
hsize_t dims[MI2_MAX_VAR_DIMS];
int i;
/* Returns chunk dimensionality */
handle->edge_count = H5Pget_chunk(hdf_plist, MI2_MAX_VAR_DIMS, dims);
if (handle->edge_count < 0) {
free(handle);
return (MI_ERROR);
}
handle->edge_lengths = (int *)malloc(handle->edge_count*sizeof(int));
if (handle->edge_lengths == NULL) {
free(handle);
return (MI_ERROR);
}
for (i = 0; i < handle->edge_count; i++) {
handle->edge_lengths[i] = dims[i];
}
/* Get the number of filters in the pipeline */
nfilters = H5Pget_nfilters(hdf_plist);
if (nfilters == 0) {
handle->zlib_level = 0;
handle->compression_type = MI_COMPRESS_NONE;
}
else {
for (i = 0; i < nfilters; i++) {
cd_nelmts = MI2_MAX_CD_ELEMENTS;
fcode = H5Pget_filter1(hdf_plist, i, &flags, &cd_nelmts,
cd_values, sizeof(fname), fname);
switch (fcode) {
case H5Z_FILTER_DEFLATE:
handle->compression_type = MI_COMPRESS_ZLIB;
handle->zlib_level = cd_values[0];
break;
case H5Z_FILTER_SHUFFLE:
break;
case H5Z_FILTER_FLETCHER32:
break;
case H5Z_FILTER_SZIP:
break;
default:
break;
}
}
}
}
else {
handle->edge_count = 0;
handle->edge_lengths = NULL;
handle->zlib_level = 0;
handle->compression_type = MI_COMPRESS_NONE;
}
*props = handle;
H5Pclose(hdf_plist);
H5Dclose(hdf_vol_dataset);
return (MI_NOERROR);
}
bool BAGRasterBand::Initialize( hid_t hDatasetID, const char *pszName )
{
SetDescription( pszName );
this->hDatasetID = hDatasetID;
hid_t datatype = H5Dget_type( hDatasetID );
dataspace = H5Dget_space( hDatasetID );
int n_dims = H5Sget_simple_extent_ndims( dataspace );
native = H5Tget_native_type( datatype, H5T_DIR_ASCEND );
hsize_t dims[3], maxdims[3];
eDataType = GH5_GetDataType( native );
if( n_dims == 2 )
{
H5Sget_simple_extent_dims( dataspace, dims, maxdims );
nRasterXSize = (int) dims[1];
nRasterYSize = (int) dims[0];
}
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"Dataset not of rank 2." );
return false;
}
nBlockXSize = nRasterXSize;
nBlockYSize = 1;
/* -------------------------------------------------------------------- */
/* Check for chunksize, and use it as blocksize for optimized */
/* reading. */
/* -------------------------------------------------------------------- */
hid_t listid = H5Dget_create_plist( hDatasetID );
if (listid>0)
{
if(H5Pget_layout(listid) == H5D_CHUNKED)
{
hsize_t panChunkDims[3];
int nDimSize = H5Pget_chunk(listid, 3, panChunkDims);
nBlockXSize = (int) panChunkDims[nDimSize-1];
nBlockYSize = (int) panChunkDims[nDimSize-2];
}
int nfilters = H5Pget_nfilters( listid );
H5Z_filter_t filter;
char name[120];
size_t cd_nelmts = 20;
unsigned int cd_values[20];
unsigned int flags;
for (int i = 0; i < nfilters; i++)
{
filter = H5Pget_filter(listid, i, &flags, (size_t *)&cd_nelmts, cd_values, 120, name);
if (filter == H5Z_FILTER_DEFLATE)
poDS->SetMetadataItem( "COMPRESSION", "DEFLATE", "IMAGE_STRUCTURE" );
else if (filter == H5Z_FILTER_NBIT)
poDS->SetMetadataItem( "COMPRESSION", "NBIT", "IMAGE_STRUCTURE" );
else if (filter == H5Z_FILTER_SCALEOFFSET)
poDS->SetMetadataItem( "COMPRESSION", "SCALEOFFSET", "IMAGE_STRUCTURE" );
else if (filter == H5Z_FILTER_SZIP)
poDS->SetMetadataItem( "COMPRESSION", "SZIP", "IMAGE_STRUCTURE" );
}
H5Pclose(listid);
}
/* -------------------------------------------------------------------- */
/* Load min/max information. */
/* -------------------------------------------------------------------- */
if( EQUAL(pszName,"elevation")
&& GH5_FetchAttribute( hDatasetID, "Maximum Elevation Value",
dfMaximum )
&& GH5_FetchAttribute( hDatasetID, "Minimum Elevation Value",
dfMinimum ) )
bMinMaxSet = true;
else if( EQUAL(pszName,"uncertainty")
&& GH5_FetchAttribute( hDatasetID, "Maximum Uncertainty Value",
dfMaximum )
&& GH5_FetchAttribute( hDatasetID, "Minimum Uncertainty Value",
dfMinimum ) )
{
/* Some products where uncertainty band is completely set to nodata */
/* wrongly declare minimum and maximum to 0.0 */
if( dfMinimum != 0.0 && dfMaximum != 0.0 )
bMinMaxSet = true;
}
else if( EQUAL(pszName,"nominal_elevation")
&& GH5_FetchAttribute( hDatasetID, "max_value",
dfMaximum )
&& GH5_FetchAttribute( hDatasetID, "min_value",
dfMinimum ) )
bMinMaxSet = true;
return true;
}
/*
* Append planes, each of (1,2*chunksize,2*chunksize) to the dataset.
* In other words, 4 chunks are appended to the dataset at a time.
* Fill each plane with the plane number and then write it at the nth plane.
* Increase the plane number and repeat till the end of dataset, when it
* reaches chunksize long. End product is a (2*chunksize)^3 cube.
*
* Return: 0 succeed; -1 fail.
*/
static int
write_file(void)
{
hid_t fid; /* File ID for new HDF5 file */
hid_t dsid; /* dataset ID */
hid_t fapl; /* File access property list */
hid_t dcpl; /* Dataset creation property list */
char *name;
UC_CTYPE *buffer, *bufptr; /* data buffer */
hsize_t cz=chunksize_g; /* Chunk size */
hid_t f_sid; /* dataset file space id */
hid_t m_sid; /* memory space id */
int rank; /* rank */
hsize_t chunk_dims[3]; /* Chunk dimensions */
hsize_t dims[3]; /* Dataspace dimensions */
hsize_t memdims[3]; /* Memory space dimensions */
hsize_t start[3] = {0,0,0}, count[3]; /* Hyperslab selection values */
hbool_t disabled; /* Object's disabled status */
hsize_t i, j, k;
name = filename_g;
/* Open the file */
if((fapl = H5Pcreate(H5P_FILE_ACCESS)) < 0)
return -1;
if(use_swmr_g)
if(H5Pset_libver_bounds(fapl, H5F_LIBVER_LATEST, H5F_LIBVER_LATEST) < 0)
return -1;
if((fid = H5Fopen(name, H5F_ACC_RDWR | (use_swmr_g ? H5F_ACC_SWMR_WRITE : 0), fapl)) < 0){
fprintf(stderr, "H5Fopen failed\n");
return -1;
}
/* Open the dataset of the program name */
if((dsid = H5Dopen2(fid, progname_g, H5P_DEFAULT)) < 0){
fprintf(stderr, "H5Dopen2 failed\n");
return -1;
}
/* Disabled mdc flushed for the dataset */
if(H5Odisable_mdc_flushes(dsid) < 0) {
fprintf(stderr, "H5Odisable_mdc_flushes failed\n");
return -1;
}
/* Get mdc disabled status of the dataset */
if(H5Oare_mdc_flushes_disabled(dsid, &disabled) < 0) {
fprintf(stderr, "H5Oare_mdc_flushes_disabled failed\n");
return -1;
} else if(disabled)
printf("Dataset has disabled mdc flushes.\n");
else
printf("Dataset should have disabled its mdc flushes.\n");
/* Find chunksize used */
if ((dcpl = H5Dget_create_plist(dsid)) < 0){
fprintf(stderr, "H5Dget_create_plist failed\n");
return -1;
}
if (H5D_CHUNKED != H5Pget_layout(dcpl)){
fprintf(stderr, "storage layout is not chunked\n");
return -1;
}
if ((rank = H5Pget_chunk(dcpl, 3, chunk_dims)) != 3){
fprintf(stderr, "storage rank is not 3\n");
return -1;
}
/* verify chunk_dims against set paramenters */
if (chunk_dims[0]!= chunkdims_g[0] || chunk_dims[1] != cz || chunk_dims[2] != cz){
fprintf(stderr, "chunk size is not as expected. Got dims=(%llu,%llu,%llu)\n",
(unsigned long long)chunk_dims[0], (unsigned long long)chunk_dims[1],
(unsigned long long)chunk_dims[2]);
return -1;
}
/* allocate space for data buffer 1 X dims[1] X dims[2] of UC_CTYPE */
memdims[0]=1;
memdims[1] = dims_g[1];
memdims[2] = dims_g[2];
if ((buffer=(UC_CTYPE*)HDmalloc((size_t)memdims[1]*(size_t)memdims[2]*sizeof(UC_CTYPE)))==NULL) {
fprintf(stderr, "malloc: failed\n");
return -1;
};
/*
* Get dataset rank and dimension.
*/
f_sid = H5Dget_space(dsid); /* Get filespace handle first. */
rank = H5Sget_simple_extent_ndims(f_sid);
if (rank != UC_RANK){
fprintf(stderr, "rank(%d) of dataset does not match\n", rank);
return -1;
}
if (H5Sget_simple_extent_dims(f_sid, dims, NULL) < 0){
fprintf(stderr, "H5Sget_simple_extent_dims got error\n");
return -1;
}
printf("dataset rank %d, dimensions %llu x %llu x %llu\n",
rank, (unsigned long long)(dims[0]), (unsigned long long)(dims[1]),
(unsigned long long)(dims[2]));
/* verify that file space dims are as expected and are consistent with memory space dims */
if (dims[0] != 0 || dims[1] != memdims[1] || dims[2] != memdims[2]){
fprintf(stderr, "dataset is not empty. Got dims=(%llu,%llu,%llu)\n",
(unsigned long long)dims[0], (unsigned long long)dims[1],
(unsigned long long)dims[2]);
return -1;
}
/* setup mem-space for buffer */
if ((m_sid=H5Screate_simple(rank, memdims, NULL))<0){
fprintf(stderr, "H5Screate_simple for memory failed\n");
return -1;
};
/* write planes */
count[0]=1;
count[1]=dims[1];
count[2]=dims[2];
for (i=0; i<nplanes_g; i++){
/* fill buffer with value i+1 */
bufptr = buffer;
for (j=0; j<dims[1]; j++)
for (k=0; k<dims[2]; k++)
*bufptr++ = i;
/* extend the dataset by one for new plane */
dims[0]=i+1;
if(H5Dset_extent(dsid, dims) < 0){
fprintf(stderr, "H5Dset_extent failed\n");
return -1;
}
/* Get the dataset's dataspace */
if((f_sid = H5Dget_space(dsid)) < 0){
fprintf(stderr, "H5Dset_extent failed\n");
return -1;
}
start[0]=i;
/* Choose the next plane to write */
if(H5Sselect_hyperslab(f_sid, H5S_SELECT_SET, start, NULL, count, NULL) < 0){
fprintf(stderr, "Failed H5Sselect_hyperslab\n");
return -1;
}
/* Write plane to the dataset */
if(H5Dwrite(dsid, UC_DATATYPE, m_sid, f_sid, H5P_DEFAULT, buffer) < 0){
fprintf(stderr, "Failed H5Dwrite\n");
return -1;
}
/* Flush the dataset for every "chunkplanes_g" planes */
if(!((i + 1) % (hsize_t)chunkplanes_g)) {
if(H5Dflush(dsid) < 0) {
fprintf(stderr, "Failed to H5Dflush dataset\n");
return -1;
}
}
}
if(H5Dflush(dsid) < 0) {
fprintf(stderr, "Failed to H5Dflush dataset\n");
return -1;
}
/* Enable mdc flushes for the dataset */
/* Closing the dataset later will enable mdc flushes automatically if this is not done */
if(disabled)
if(H5Oenable_mdc_flushes(dsid) < 0) {
fprintf(stderr, "Failed to H5Oenable_mdc_flushes\n");
return -1;
}
/* Done writing. Free/Close all resources including data file */
HDfree(buffer);
if(H5Dclose(dsid) < 0){
fprintf(stderr, "Failed to close datasete\n");
return -1;
}
if(H5Sclose(m_sid) < 0){
fprintf(stderr, "Failed to close memory space\n");
return -1;
}
if(H5Sclose(f_sid) < 0){
fprintf(stderr, "Failed to close file space\n");
return -1;
}
if(H5Pclose(fapl) < 0){
fprintf(stderr, "Failed to property list\n");
return -1;
}
if(H5Fclose(fid) < 0){
fprintf(stderr, "Failed to close file id\n");
return -1;
}
return 0;
} /* write_file() */