HDF5 크기 다시 조정 데이터 세트의 최대 치수

Question

내가 레이아웃을 청크와 데이터 세트를 만들었습니다, 나는

DataSpace *dataspace = new DataSpace (2, dims, maxdims)//maxdims equal to dims 
// Modify dataset creation property to enable chunking 
DSetCreatPropList prop; 
prop.setChunk(2, chunk_dims); 

가 그럼 난 거기에 일부 데이터가 기록 된 데이터 세트의 최대 크기를 결정했다. 최근에 나는 예외를 내가 데이터 세트를

dataset->extend(new_size); //New size 

의 크기를 조정하려고 할 때마다 원인이 내가 시작 부분에서 결정된 최대 크기를 초과이 데이터 집합하지만 새 크기를 크기를 조정하기 위해 필요로했다 내가의 최대 크기를 확장 할 수있는 방법이 있나요 내 기록 된 데이터를 잃지 않고 데이터 세트. 다른 데이터 세트를 덮어 쓰는 방법이 없다면 데이터와 새로운 최대 크기가 포함되어 있습니까?

Answer 1

옵션 :: extend()는 확장 가능 데이터 세트 (link)에서만 사용할 수 있습니다.

데이터 세트가 최대 크기로 작성된 경우 데이터 세트를 확장 가능으로 변경할 수 없습니다. 무제한으로 만든 새 데이터 세트로 내용을 복사해야합니다.

여기 hdf 웹 사이트 (link)에서 가져온 예제가 있습니다. 답변에 대한

/* 
* This example shows how to work with extendible dataset. 
* In the current version of the library dataset MUST be 
* chunked. 
*/ 
#ifdef OLD_HEADER_FILENAME 
#include <iostream.h> 
#else 
#include <iostream> 
#endif 
#include <string> 
#ifndef H5_NO_NAMESPACE 
#ifndef H5_NO_STD 
    using std::cout; 
    using std::endl; 
#endif // H5_NO_STD 
#endif 
#include "H5Cpp.h" 
#ifndef H5_NO_NAMESPACE 
    using namespace H5; 
#endif 
const H5std_string FILE_NAME("SDSextendible.h5"); 
const H5std_string DATASET_NAME("ExtendibleArray"); 
const int  NX = 10; 
const int  NY = 5; 
const int  RANK = 2; 
int main (void) 
{ 
    //Try block to detect exceptions raised by any of the calls inside it 
    try 
    { 
     /* 
     * Turn off the auto-printing when failure occurs so that we can 
     * handle the errors appropriately 
     */ 
     Exception::dontPrint(); 

     //Create the data space with unlimited dimensions. 
     hsize_t  dims[2] = { 3, 3}; // dataset dimensions at creation 
     hsize_t  maxdims[2] = {H5S_UNLIMITED, H5S_UNLIMITED}; 
     DataSpace mspace1(RANK, dims, maxdims); 

     //Create a new file. If file exists its contents will be overwritten. 
     H5File file(FILE_NAME, H5F_ACC_TRUNC); 

     //Modify dataset creation properties, i.e. enable chunking.   
     DSetCreatPropList cparms; 
     hsize_t  chunk_dims[2] ={2, 5}; 
     cparms.setChunk(RANK, chunk_dims); 

     //Set fill value for the dataset   
     int fill_val = 0; 
     cparms.setFillValue(PredType::NATIVE_INT, &fill_val); 

     //Create a new dataset within the file using cparms creation properties. 
     DataSet dataset = file.createDataSet(DATASET_NAME, PredType::NATIVE_INT, mspace1, cparms); 

     //Extend the dataset. This call assures that dataset is at least 3 x 3. 
     hsize_t  size[2]; 
     size[0] = 3; 
     size[1] = 3; 
     dataset.extend(size); 

     //Select a hyperslab. 
     DataSpace fspace1 = dataset.getSpace(); 
     hsize_t  offset[2]; 
     offset[0] = 0; 
     offset[1] = 0; 
     hsize_t  dims1[2] = { 3, 3};   /* data1 dimensions */ 
     fspace1.selectHyperslab(H5S_SELECT_SET, dims1, offset); 

     //Write the data to the hyperslab.   
     int  data1[3][3] = { {1, 1, 1},  /* data to write */ 
       {1, 1, 1}, 
       {1, 1, 1} }; 
     dataset.write(data1, PredType::NATIVE_INT, mspace1, fspace1); 

     //Extend the dataset. Dataset becomes 10 x 3.   
     hsize_t dims2[2] = { 7, 1};   /* data2 dimensions */ 
     dims[0] = dims1[0] + dims2[0]; 
     size[0] = dims[0]; 
     size[1] = dims[1]; 
     dataset.extend(size); 

     //Select a hyperslab.   
     DataSpace fspace2 = dataset.getSpace(); 
     offset[0] = 3; 
     offset[1] = 0; 
     fspace2.selectHyperslab(H5S_SELECT_SET, dims2, offset); 

     //Define memory space 
     DataSpace mspace2(RANK, dims2); 

     //Write the data to the hyperslab. 
     int data2[7] = { 2, 2, 2, 2, 2, 2, 2}; 
     dataset.write(data2, PredType::NATIVE_INT, mspace2, fspace2); 

     //Extend the dataset. Dataset becomes 10 x 5. 
     hsize_t dims3[2] = { 2, 2};   /* data3 dimensions */ 
     dims[1] = dims1[1] + dims3[1]; 
     size[0] = dims[0]; 
     size[1] = dims[1]; 
     dataset.extend(size); 

     //Select a hyperslab   
     DataSpace fspace3 = dataset.getSpace(); 
     offset[0] = 0; 
     offset[1] = 3; 
     fspace3.selectHyperslab(H5S_SELECT_SET, dims3, offset); 

     //Define memory space. 
     DataSpace mspace3(RANK, dims3); 

     //Write the data to the hyperslab.   
     int   data3[2][2] = { {3, 3}, {3, 3} }; 
     dataset.write(data3, PredType::NATIVE_INT, mspace3, fspace3); 

     //Read the data from this dataset and display it.   
     int i, j; 
     int data_out[NX][NY]; 
     for (i = 0; i < NX; i++) 
     { 
     for (j = 0; j < NY; j++) 
      data_out[i][j] = 0; 
     } 
     dataset.read(data_out, PredType::NATIVE_INT); 
     /* 
     * Resulting dataset 
     * 
     *  1 1 1 3 3 
     *  1 1 1 3 3 
     *  1 1 1 0 0 
     *  2 0 0 0 0 
     *  2 0 0 0 0 
     *  2 0 0 0 0 
     *  2 0 0 0 0 
     *  2 0 0 0 0 
     *  2 0 0 0 0 
     *  2 0 0 0 0 
     */ 

     //Display the result.   
     for (i=0; i < NX; i++) 
     { 
      for(j=0; j < NY; j++) 
      cout << data_out[i][j] << " "; 
      cout << endl; 
     } 
    } // end of try block 
    // catch failure caused by the H5File operations 
    catch(FileIException error) 
    { 
     error.printError(); 
     return -1; 
    } 
    // catch failure caused by the DataSet operations 
    catch(DataSetIException error) 
    { 
     error.printError(); 
     return -1; 
    } 
    // catch failure caused by the DataSpace operations 
    catch(DataSpaceIException error) 
    { 
     error.printError(); 
     return -1; 
    } 
    // catch failure caused by the DataSpace operations 
    catch(DataTypeIException error) 
    { 
     error.printError(); 
     return -1; 
    } 
    return 0; 
}