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() */