![]() |
HDF User’s GuideVersion 4.2r4 |
[Top] [Prev][Next] |
create_sds.c#include "mfhdf.h" #define FILE_NAME "SDS.hdf" #define SDS_NAME "SDStemplate" #define X_LENGTH 5 #define Y_LENGTH 16 #define RANK 2 /* Number of dimensions of the SDS */ main( ) { /************************* Variable declaration **************************/ int32 sd_id, sds_id; /* SD interface and data set identifiers */ int32 dim_sizes[2]; /* sizes of the SDS dimensions */ intn status; /* status returned by some routines; has value SUCCEED or FAIL */ /********************* End of variable declaration ***********************/ /* * Create the file and initialize the SD interface. */ sd_id = SDstart (FILE_NAME, DFACC_CREATE); /* * Define the dimensions of the array to be created. */ dim_sizes[0] = Y_LENGTH; dim_sizes[1] = X_LENGTH; /* * Create the data set with the name defined in SDS_NAME. Note that * DFNT_INT32 indicates that the SDS data is of type int32. Refer to * Table 2E for definitions of other types. */ sds_id = SDcreate (sd_id, SDS_NAME, DFNT_INT32, RANK, dim_sizes); /* * Terminate access to the data set. */ status = SDendaccess (sds_id); /* * Terminate access to the SD interface and close the file. */ status = SDend (sd_id); }create_sds.fprogram create_SDS implicit none C C Parameter declaration. C character*7 FILE_NAME character*11 SDS_NAME integer X_LENGTH, Y_LENGTH, RANK parameter (FILE_NAME = 'SDS.hdf', + SDS_NAME = 'SDStemplate', + X_LENGTH = 5, + Y_LENGTH = 16, + RANK = 2) integer DFACC_CREATE, DFNT_INT32 parameter (DFACC_CREATE = 4, + DFNT_INT32 = 24) C C Function declaration. C integer sfstart, sfcreate, sfendacc, sfend C C**** Variable declaration ******************************************* C integer sd_id, sds_id, dim_sizes(2) integer status C C**** End of variable declaration ************************************ C C C Create the file and initialize the SD interface. C sd_id = sfstart(FILE_NAME, DFACC_CREATE) C C Define dimensions of the array to be created. C dim_sizes(1) = X_LENGTH dim_sizes(2) = Y_LENGTH C C Create the array with the name defined in SDS_NAME. C Note that DFNT_INT32 indicates that the SDS data is of type C integer. Refer to Tables 2E and 2I for the definition of other types. C sds_id = sfcreate(sd_id, SDS_NAME, DFNT_INT32, RANK, . dim_sizes) C C Terminate access to the data set. C status = sfendacc(sds_id) C C Terminate access to the SD interface and close the file. C status = sfend(sd_id) endwrite_to_sds.c#include "mfhdf.h" #define FILE_NAME "SDS.hdf" #define X_LENGTH 5 #define Y_LENGTH 16 main( ) { /************************* Variable declaration **************************/ int32 sd_id, sds_id, sds_index; intn status; int32 start[2], edges[2]; int32 data[Y_LENGTH][X_LENGTH]; int i, j; /********************* End of variable declaration ***********************/ /* * Data set data initialization. */ for (j = 0; j < Y_LENGTH; j++) { for (i = 0; i < X_LENGTH; i++) data[j][i] = (i + j) + 1; } /* * Open the file and initialize the SD interface. */ sd_id = SDstart (FILE_NAME, DFACC_WRITE); /* * Attach to the first data set. */ sds_index = 0; sds_id = SDselect (sd_id, sds_index); /* * Define the location and size of the data to be written to the data set. */ start[0] = 0; start[1] = 0; edges[0] = Y_LENGTH; edges[1] = X_LENGTH; /* * Write the stored data to the data set. The third argument is set to NULL * to specify contiguous data elements. The last argument must * be explicitly cast to a generic pointer since SDwritedata is designed * to write generic data. */ status = SDwritedata (sds_id, start, NULL, edges, (VOIDP)data); /* * Terminate access to the data set. */ status = SDendaccess (sds_id); /* * Terminate access to the SD interface and close the file. */ status = SDend (sd_id); }write_to_sds.fprogram write_data implicit none C C Parameter declaration. C character*7 FILE_NAME character*11 SDS_NAME integer X_LENGTH, Y_LENGTH, RANK parameter (FILE_NAME = 'SDS.hdf', + SDS_NAME = 'SDStemplate', + X_LENGTH = 5, + Y_LENGTH = 16, + RANK = 2) integer DFACC_WRITE, DFNT_INT32 parameter (DFACC_WRITE = 2, + DFNT_INT32 = 24) C C Function declaration. C integer sfstart, sfselect, sfwdata, sfendacc, sfend C C**** Variable declaration ******************************************* C integer sd_id, sds_id, sds_index, status integer start(2), edges(2), stride(2) integer i, j integer data(X_LENGTH, Y_LENGTH) C C**** End of variable declaration ************************************ C C C Data set data initialization. C do 20 j = 1, Y_LENGTH do 10 i = 1, X_LENGTH data(i, j) = i + j - 1 10 continue 20 continue C C Open the file and initialize the SD interface. C sd_id = sfstart(FILE_NAME, DFACC_WRITE) C C Attach to the first data set. C sds_index = 0 sds_id = sfselect(sd_id, sds_index) C C Define the location and size of the data to be written C to the data set. Note that setting values of the array stride to 1 C specifies the contiguous writing of data. C start(1) = 0 start(2) = 0 edges(1) = X_LENGTH edges(2) = Y_LENGTH stride(1) = 1 stride(2) = 1 C C Write the stored data to the data set named in SDS_NAME. C Note that the routine sfwdata is used instead of sfwcdata C to write the numeric data. C status = sfwdata(sds_id, start, stride, edges, data) C C Terminate access to the data set. C status = sfendacc(sds_id) C C Terminate access to the SD interface and close the file. C status = sfend(sd_id) endwrite_slab.c#include "mfhdf.h" #define FILE_NAME "SLABS.hdf" #define SDS_NAME "FilledBySlabs" #define X_LENGTH 4 #define Y_LENGTH 5 #define Z_LENGTH 6 #define RANK 3 main( ) { /************************* Variable declaration **************************/ int32 sd_id, sds_id; intn status; int32 dim_sizes[3], start[3], edges[3]; int32 data[Z_LENGTH][Y_LENGTH][X_LENGTH]; int32 zx_data[Z_LENGTH][X_LENGTH]; int i, j, k; /********************* End of variable declaration ***********************/ /* * Data initialization. */ for (k = 0; k < Z_LENGTH; k++) for (j = 0; j < Y_LENGTH; j++) for (i = 0; i < X_LENGTH; i++) data[k][j][i] = (i + 1) + (j + 1) + (k + 1); /* * Create the file and initialize the SD interface. */ sd_id = SDstart (FILE_NAME, DFACC_CREATE); /* * Define dimensions of the array to be created. */ dim_sizes[0] = Z_LENGTH; dim_sizes[1] = Y_LENGTH; dim_sizes[2] = X_LENGTH; /* * Create the array with the name defined in SDS_NAME. */ sds_id = SDcreate (sd_id, SDS_NAME, DFNT_INT32, RANK, dim_sizes); /* * Set the parameters start and edges to write * a 6x4 element slab of data to the data set; note * that edges[1] is set to 1 to define a 2-dimensional slab * parallel to the ZX plane. * start[1] (slab position in the array) is initialized inside * the for loop. */ edges[0] = Z_LENGTH; edges[1] = 1; edges[2] = X_LENGTH; start[0] = start[2] = 0; for (j = 0; j < Y_LENGTH; j++) { start[1] = j; /* * Initialize zx_data buffer (data slab). */ for ( k = 0; k < Z_LENGTH; k++) { for ( i = 0; i < X_LENGTH; i++) { zx_data[k][i] = data[k][j][i]; } } /* * Write the data slab into the SDS array defined in SDS_NAME. * Note that the 3rd parameter is NULL which indicates that consecutive * slabs in the Y direction are written. */ status = SDwritedata (sds_id, start, NULL, edges, (VOIDP)zx_data); } /* * Terminate access to the data set. */ status = SDendaccess (sds_id); /* * Terminate access to the SD interface and close the file. */ status = SDend (sd_id); }write_slab.fprogram write_slab implicit none C C Parameter declaration. C character*9 FILE_NAME character*13 SDS_NAME integer X_LENGTH, Y_LENGTH, Z_LENGTH, RANK parameter (FILE_NAME = 'SLABS.hdf', + SDS_NAME = 'FilledBySlabs', + X_LENGTH = 4, + Y_LENGTH = 5, + Z_LENGTH = 6, + RANK = 3) integer DFACC_CREATE, DFNT_INT32 parameter (DFACC_CREATE = 4, + DFNT_INT32 = 24) C C Function declaration. C integer sfstart, sfcreate, sfwdata, sfendacc, sfend C C**** Variable declaration ******************************************* C integer sd_id, sds_id integer dim_sizes(3), start(3), edges(3), stride(3) integer i, j, k, status integer data(X_LENGTH, Y_LENGTH, Z_LENGTH) integer xz_data(X_LENGTH, Z_LENGTH) C C**** End of variable declaration ************************************ C C C Data initialization. C do 30 k = 1, Z_LENGTH do 20 j = 1, Y_LENGTH do 10 i = 1, X_LENGTH data(i, j, k) = i + j + k 10 continue 20 continue 30 continue C C Create the file and initialize the SD interface. C sd_id = sfstart(FILE_NAME, DFACC_CREATE) C C Define dimensions of the array to be created. C dim_sizes(1) = X_LENGTH dim_sizes(2) = Y_LENGTH dim_sizes(3) = Z_LENGTH C C Create the data set with the name defined in SDS_NAME. C sds_id = sfcreate(sd_id, SDS_NAME, DFNT_INT32, RANK, . dim_sizes) C C Set the parameters start and edges to write C a 4x6 element slab of data to the data set; C note that edges(2) is set to 1 to define a 2 dimensional slab C parallel to the XZ plane; C start(2) (slab position in the array) is initialized inside the C for loop. C edges(1) = X_LENGTH edges(2) = 1 edges(3) = Z_LENGTH start(1) = 0 start(3) = 0 stride(1) = 1 stride(2) = 1 stride(3) = 1 do 60 j = 1, Y_LENGTH start(2) = j - 1 C C Initialize the buffer xz_data (data slab). C do 50 k = 1, Z_LENGTH do 40 i = 1, X_LENGTH xz_data(i, k) = data(i, j, k) 40 continue 50 continue C C Write the data slab into SDS array defined in SDS_NAME. C Note that the elements of array stride are set to 1 to C specify that the consecutive slabs in the Y direction are written. C status = sfwdata(sds_id, start, stride, edges, xz_data) 60 continue C C Terminate access to the data set. C status = sfendacc(sds_id) C C Terminate access to the SD interface and close the file. C status = sfend(sd_id) endalter_sds_values.c#include "mfhdf.h" #define FILE_NAME "SDS.hdf" main( ) { /************************* Variable declaration **************************/ int32 sd_id, sds_id, sds_index; intn status; int32 start[2], edges[2]; int32 new_data[2]; int i, j; /********************* End of variable declaration ***********************/ /* * Open the file and initialize the SD interface with write access. */ sd_id = SDstart (FILE_NAME, DFACC_WRITE); /* * Select the first data set. */ sds_index = 0; sds_id = SDselect (sd_id, sds_index); /* * Set up the start and edge parameters to write new element values * into 10th row, 2nd column place, and 11th row, 2nd column place. */ start[0] = 9; /* starting at 10th row */ start[1] = 1; /* starting at 2nd column */ edges[0] = 2; /* rows 10th and 11th */ edges[1] = 1; /* column 2nd only */ /* * Initialize buffer with the new values to be written. */ new_data[0] = new_data[1] = 1000; /* * Write the new values. */ status = SDwritedata (sds_id, start, NULL, edges, (VOIDP)new_data); /* * Terminate access to the data set. */ status = SDendaccess (sds_id); /* * Terminate access to the SD interface and close the file. */ status = SDend (sd_id); }alter_sds_values.fprogram alter_data implicit none C C Parameter declaration. C character*7 FILE_NAME integer DFACC_WRITE parameter (FILE_NAME = 'SDS.hdf', + DFACC_WRITE = 2) C C Function declaration. C integer sfstart, sfselect, sfwdata, sfendacc, sfend C C**** Variable declaration ******************************************* C integer sd_id, sds_id, sds_index integer start(2), edges(2), stride(2) integer status integer new_data(2) C C**** End of variable declaration ************************************ C C C Open the file and initialize the SD interface. C sd_id = sfstart(FILE_NAME, DFACC_WRITE) C C Select the first data set. C sds_index = 0 sds_id = sfselect(sd_id, sds_index) C C Initialize the start, edge, and stride parameters to write C two elements into 2nd row, 10th column and 11th column places. C C Specify 2nd row. C start(1) = 1 C C Specify 10th column. C start(2) = 9 edges(1) = 1 C C Two elements are written along 2nd row. C edges(2) = 2 stride(1) = 1 stride(2) = 1 C C Initialize the new values to be written. C new_data(1) = 1000 new_data(2) = 1000 C C Write the new values. C status = sfwdata(sds_id, start, stride, edges, new_data) C C Terminate access to the data set. C status = sfendacc(sds_id) C C Terminate access to the SD interface and close the file. C status = sfend(sd_id) endunlimited_sds.c#include "mfhdf.h" #define FILE_NAME "SDSUNLIMITED.hdf" #define SDS_NAME "AppendableData" #define X_LENGTH 10 #define Y_LENGTH 10 #define RANK 2 main( ) { /************************* Variable declaration **************************/ int32 sd_id, sds_id, sds_index; intn status; int32 dim_sizes[2]; int32 data[Y_LENGTH][X_LENGTH], append_data[X_LENGTH]; int32 start[2], edges[2]; int i, j; /********************* End of variable declaration ***********************/ /* * Data initialization. */ for (j = 0; j < Y_LENGTH; j++) { for (i = 0; i < X_LENGTH; i++) data[j][i] = (i + 1) + (j + 1); } /* * Create the file and initialize the SD interface. */ sd_id = SDstart (FILE_NAME, DFACC_CREATE); /* * Define dimensions of the array. Make the first dimension * appendable by defining its length to be unlimited. */ dim_sizes[0] = SD_UNLIMITED; dim_sizes[1] = X_LENGTH; /* * Create the array data set. */ sds_id = SDcreate (sd_id, SDS_NAME, DFNT_INT32, RANK, dim_sizes); /* * Define the location and the size of the data to be written * to the data set. */ start[0] = start[1] = 0; edges[0] = Y_LENGTH; edges[1] = X_LENGTH; /* * Write the data. */ status = SDwritedata (sds_id, start, NULL, edges, (VOIDP)data); /* * Terminate access to the array data set, terminate access * to the SD interface, and close the file. */ status = SDendaccess (sds_id); status = SDend (sd_id); /* * Store the array values to be appended to the data set. */ for (i = 0; i < X_LENGTH; i++) append_data[i] = 1000 + i; /* * Reopen the file and initialize the SD interface. */ sd_id = SDstart (FILE_NAME, DFACC_WRITE); /* * Select the first data set. */ sds_index = 0; sds_id = SDselect (sd_id, sds_index); /* * Check if selected SDS is unlimited. If it is not, then terminate access * to the SD interface and close the file. */ if ( SDisrecord (sds_id) ) { /* * Define the location of the append to start at the first column * of the 11th row of the data set and to stop at the end of the * eleventh row. */ start[0] = Y_LENGTH; start[1] = 0; edges[0] = 1; edges[1] = X_LENGTH; /* * Append data to the data set. */ status = SDwritedata (sds_id, start, NULL, edges, (VOIDP)append_data); } /* * Terminate access to the data set. */ status = SDendaccess (sds_id); /* * Terminate access to the SD interface and close the file. */ status = SDend (sd_id); }unlimited_sds.fprogram append_sds implicit none C C Parameter declaration. C character*16 FILE_NAME character*14 SDS_NAME integer X_LENGTH, Y_LENGTH, RANK parameter (FILE_NAME = 'SDSUNLIMITED.hdf', + SDS_NAME = 'AppendableData', + X_LENGTH = 10, + Y_LENGTH = 10, + RANK = 2) integer DFACC_CREATE, DFACC_WRITE, SD_UNLIMITED, + DFNT_INT32 parameter (DFACC_CREATE = 4, + DFACC_WRITE = 2, + SD_UNLIMITED = 0, + DFNT_INT32 = 24) C C Function declaration. C integer sfstart, sfcreate, sfwdata, sfselect integer sfendacc, sfend C C**** Variable declaration ******************************************* C integer sd_id, sds_id, sds_index, status integer dim_sizes(2) integer start(2), edges(2), stride(2) integer i, j integer data (X_LENGTH, Y_LENGTH), append_data(X_LENGTH) C C**** End of variable declaration ************************************ C C C Data initialization. C do 20 j = 1, Y_LENGTH do 10 i = 1, X_LENGTH data(i, j) = i + j 10 continue 20 continue C C Create the file and initialize the SD interface. C sd_id = sfstart(FILE_NAME, DFACC_CREATE) C C Define dimensions of the array. Make the C last dimension appendable by defining its length as unlimited. C dim_sizes(1) = X_LENGTH dim_sizes(2) = SD_UNLIMITED C Create the array data set. sds_id = sfcreate(sd_id, SDS_NAME, DFNT_INT32, RANK, . dim_sizes) C C Define the location and the size of the data to be written C to the data set. Note that the elements of array stride are C set to 1 for contiguous writing. C start(1) = 0 start(2) = 0 edges(1) = X_LENGTH edges(2) = Y_LENGTH stride(1) = 1 stride(2) = 1 C C Write the data. C status = sfwdata(sds_id, start, stride, edges, data) C C Terminate access to the data set, terminate access C to the SD interface, and close the file. C status = sfendacc(sds_id) status = sfend(sd_id) C C Store the array values to be appended to the data set. C do 30 i = 1, X_LENGTH append_data(i) = 1000 + i - 1 30 continue C C Reopen the file and initialize the SD. C sd_id = sfstart(FILE_NAME, DFACC_WRITE) C C Select the first data set. C sds_index = 0 sds_id = sfselect(sd_id, sds_index) C C Define the location of the append to start at the 11th C column of the 1st row and to stop at the end of the 10th row. C start(1) = 0 start(2) = Y_LENGTH edges(1) = X_LENGTH edges(2) = 1 C C Append the data to the data set. C status = sfwdata(sds_id, start, stride, edges, append_data) C C Terminate access to the data set. C status = sfendacc(sds_id) C C Terminate access to the SD interface and close the file. C status = sfend(sd_id) endcompress_sds.c#include "mfhdf.h" #define FILE_NAME "SDScompressed.hdf" #define SDS_NAME "SDSgzip" #define X_LENGTH 5 #define Y_LENGTH 16 #define RANK 2 main( ) { /************************* Variable declaration **************************/ int32 sd_id, sds_id, sds_index; intn status; int32 comp_type; /* Compression flag */ comp_info c_info; /* Compression structure */ int32 start[2], edges[2], dim_sizes[2]; int32 data[Y_LENGTH][X_LENGTH]; int i, j; /********************* End of variable declaration ***********************/ /* * Buffer array data and define array dimensions. */ for (j = 0; j < Y_LENGTH; j++) { for (i = 0; i < X_LENGTH; i++) data[j][i] = (i + j) + 1; } dim_sizes[0] = Y_LENGTH; dim_sizes[1] = X_LENGTH; /* * Create the file and initialize the SD interface. */ sd_id = SDstart (FILE_NAME, DFACC_CREATE); /* * Create the data set with the name defined in SDS_NAME. */ sds_id = SDcreate (sd_id, SDS_NAME, DFNT_INT32, RANK, dim_sizes); /* * Ininitialize compression structure element and compression * flag for GZIP compression and call SDsetcompress. * * To use the Skipping Huffman compression method, initialize * comp_type = COMP_CODE_SKPHUFF * c_info.skphuff.skp_size = value * * To use the RLE compression method, initialize * comp_type = COMP_CODE_RLE * No structure element needs to be initialized. */ comp_type = COMP_CODE_DEFLATE; c_info.deflate.level = 6; status = SDsetcompress (sds_id, comp_type, &c_info); /* * Define the location and size of the data set * to be written to the file. */ start[0] = 0; start[1] = 0; edges[0] = Y_LENGTH; edges[1] = X_LENGTH; /* * Write the stored data to the data set. The last argument * must be explicitly cast to a generic pointer since SDwritedata * is designed to write generic data. */ status = SDwritedata (sds_id, start, NULL, edges, (VOIDP)data); /* * Terminate access to the data set. */ status = SDendaccess (sds_id); /* * Terminate access to the SD interface and close the file. */ status = SDend (sd_id); }compress_sds.fprogram write_compressed_data implicit none C C Parameter declaration. C character*17 FILE_NAME character*7 SDS_NAME integer X_LENGTH, Y_LENGTH, RANK parameter (FILE_NAME = 'SDScompressed.hdf', + SDS_NAME = 'SDSgzip', + X_LENGTH = 5, + Y_LENGTH = 16, + RANK = 2) integer DFACC_CREATE, DFNT_INT32 parameter (DFACC_CREATE = 4, + DFNT_INT32 = 24) integer COMP_CODE_DEFLATE parameter (COMP_CODE_DEFLATE = 4) integer DEFLATE_LEVEL parameter (DEFLATE_LEVEL = 6) C To use Skipping Huffman compression method, declare C integer COMP_CODE_SKPHUFF C parameter(COMP_CODE_SKPHUFF = 3) C To use RLE compression method, declare C integer COMP_CODE_RLE C parameter(COMP_CODE_RLE = 1) C C C Function declaration. C integer sfstart, sfcreate, sfwdata, sfendacc, sfend, + sfscompress C C**** Variable declaration ******************************************* C integer sd_id, sds_id, status integer start(2), edges(2), stride(2), dim_sizes(2) integer comp_type integer comp_prm(1) integer data(X_LENGTH, Y_LENGTH) integer i, j C C**** End of variable declaration ************************************ C C C Buffer array data and define array dimensions. C do 20 j = 1, Y_LENGTH do 10 i = 1, X_LENGTH data(i, j) = i + j - 1 10 continue 20 continue dim_sizes(1) = X_LENGTH dim_sizes(2) = Y_LENGTH C C Open the file and initialize the SD interface. C sd_id = sfstart(FILE_NAME, DFACC_CREATE) C C Create the data set with the name SDS_NAME. C sds_id = sfcreate(sd_id, SDS_NAME, DFNT_INT32, RANK, dim_sizes) C C Initialize compression parameter (deflate level) C and call sfscompress function C For Skipping Huffman compression, comp_prm(1) should be set C to skipping sizes value (skp_size). C comp_type = COMP_CODE_DEFLATE comp_prm(1) = deflate_level status = sfscompress(sds_id, comp_type, comp_prm(1)) C C Define the location and size of the data that will be written to C the data set. C start(1) = 0 start(2) = 0 edges(1) = X_LENGTH edges(2) = Y_LENGTH stride(1) = 1 stride(2) = 1 C C Write the stored data to the data set. C status = sfwdata(sds_id, start, stride, edges, data) C C Terminate access to the data set. C status = sfendacc(sds_id) C C Terminate access to the SD interface and close the file. C status = sfend(sd_id) endmv_sds_to_external.c#include "mfhdf.h" #define FILE_NAME "SDS.hdf" #define EXT_FILE_NAME "ExternalSDS" #define OFFSET 24 main( ) { /************************* Variable declaration **************************/ int32 sd_id, sds_id, sds_index, offset; intn status; /********************* End of variable declaration ***********************/ /* * Open the file and initialize the SD interface. */ sd_id = SDstart (FILE_NAME, DFACC_WRITE); /* * Select the first data set. */ sds_index = 0; sds_id = SDselect (sd_id, sds_index); /* * Create a file with the name EXT_FILE_NAME and move the data set * values into it, starting at byte location OFFSET. */ status = SDsetexternalfile (sds_id, EXT_FILE_NAME, OFFSET); /* * Terminate access to the data set, SD interface, and file. */ status = SDendaccess (sds_id); status = SDend (sd_id); }mv_sds_to_external.fprogram write_extfile implicit none C C Parameter declaration. C character*7 FILE_NAME character*11 EXT_FILE_NAME integer OFFSET integer DFACC_WRITE parameter (FILE_NAME = 'SDS.hdf', + EXT_FILE_NAME = 'ExternalSDS', + OFFSET = 24, + DFACC_WRITE = 2) C C Function declaration. C integer sfstart, sfselect, sfsextf, sfendacc, sfend C C**** Variable declaration ******************************************* C integer sd_id, sds_id, sds_index, offset integer status C C**** End of variable declaration ************************************ C C C Open the HDF file and initialize the SD interface. C sd_id = sfstart(FILE_NAME, DFACC_WRITE) C C Select the first data set. C sds_index = 0 sds_id = sfselect(sd_id, sds_index) C C Create a file with the name EXT_FILE_NAME and move the data set C into it, starting at byte location OFFSET. C status = sfsextf(sds_id, EXT_FILE_NAME, OFFSET) C C Terminate access to the data set. C status = sfendacc(sds_id) C C Terminate access to the SD interface and close the file. C status = sfend(sd_id) endread_from_sds.c#include "mfhdf.h" #define FILE_NAME "SDS.hdf" #define X_LENGTH 5 #define Y_LENGTH 16 main( ) { /************************* Variable declaration **************************/ int32 sd_id, sds_id, sds_index; intn status; int32 start[2], edges[2]; int32 data[Y_LENGTH][X_LENGTH]; int i, j; /********************* End of variable declaration ***********************/ /* * Open the file for reading and initialize the SD interface. */ sd_id = SDstart (FILE_NAME, DFACC_READ); /* * Select the first data set. */ sds_index = 0; sds_id = SDselect (sd_id, sds_index); /* * Set elements of array start to 0, elements of array edges * to SDS dimensions,and use NULL for the argument stride in SDreaddata * to read the entire data. */ start[0] = 0; start[1] = 0; edges[0] = Y_LENGTH; edges[1] = X_LENGTH; /* * Read entire data into data array. */ status = SDreaddata (sds_id, start, NULL, edges, (VOIDP)data); /* * Print 10th row; the following numbers should be displayed. * * 10 1000 12 13 14 */ for (j = 0; j < X_LENGTH; j++) printf ("%d ", data[9][j]); printf ("\n"); /* * Terminate access to the data set. */ status = SDendaccess (sds_id); /* * Terminate access to the SD interface and close the file. */ status = SDend (sd_id); }read_from_sds.fprogram read_data implicit none C C Parameter declaration. C character*7 FILE_NAME integer X_LENGTH, Y_LENGTH parameter (FILE_NAME = 'SDS.hdf', + X_LENGTH = 5, + Y_LENGTH = 16) integer DFACC_READ, DFNT_INT32 parameter (DFACC_READ = 1, + DFNT_INT32 = 24) C C Function declaration. C integer sfstart, sfselect, sfrdata, sfendacc, sfend C C**** Variable declaration ******************************************* C integer sd_id, sds_id, sds_index, status integer start(2), edges(2), stride(2) integer data(X_LENGTH, Y_LENGTH) integer j C C**** End of variable declaration ************************************ C C C Open the file and initialize the SD interface. C sd_id = sfstart(FILE_NAME, DFACC_READ) C C Select the first data set. C sds_index = 0 sds_id = sfselect(sd_id, sds_index) C C Set elements of the array start to 0, elements of the array edges to C SDS dimensions, and elements of the array stride to 1 to read the C entire data. C start(1) = 0 start(2) = 0 edges(1) = X_LENGTH edges(2) = Y_LENGTH stride(1) = 1 stride(2) = 1 C C Read entire data into data array. Note that sfrdata is used C to read the numeric data. C status = sfrdata(sds_id, start, stride, edges, data) C C Print 10th column; the following numbers are displayed: C C 10 1000 12 13 14 C write(*,*) (data(j,10), j = 1, X_LENGTH) C C Terminate access to the data set. C status = sfendacc(sds_id) C C Terminate access to the SD interface and close the file. C status = sfend(sd_id) endread_subsets.c#include "mfhdf.h" #define FILE_NAME "SDS.hdf" #define SUB1_LENGTH 5 #define SUB2_LENGTH 4 #define SUB3_LENGTH1 2 #define SUB3_LENGTH2 3 main( ) { /************************* Variable declaration **************************/ int32 sd_id, sds_id, sds_index; intn status; int32 start[2], edges[2], stride[2]; int32 sub1_data[SUB1_LENGTH]; int32 sub2_data[SUB2_LENGTH]; int32 sub3_data[SUB3_LENGTH2][SUB3_LENGTH1]; int i, j; /********************* End of variable declaration ***********************/ /* * Open the file for reading and initialize the SD interface. */ sd_id = SDstart (FILE_NAME, DFACC_READ); /* * Select the first data set. */ sds_index = 0; sds_id = SDselect (sd_id, sds_index); /* * Reading the first subset. * * Set elements of start, edges, and stride arrays to read * every 3rd element in the 2nd column starting at 4th row. */ start[0] = 3; /* 4th row */ start[1] = 1; /* 2nd column */ edges[0] = SUB1_LENGTH; /* SUB1_LENGTH elements are read along 2nd column*/ edges[1] = 1; stride[0] = 3; /* every 3rd element is read along 2nd column */ stride[1] = 1; /* * Read the data from the file into sub1_data array. */ status = SDreaddata (sds_id, start, stride, edges, (VOIDP)sub1_data); /* * Print what we have just read; the following numbers should be displayed: * * 5 8 1000 14 17 */ for (j = 0; j < SUB1_LENGTH; j++) printf ("%d ", sub1_data[j]); printf ("\n"); /* * Reading the second subset. * * Set elements of start and edges arrays to read * first 4 elements of the 10th row. */ start[0] = 9; /* 10th row */ start[1] = 0; /* 1st column */ edges[0] = 1; edges[1] = SUB2_LENGTH; /* SUB2_LENGTH elements are read along 10th row */ /* * Read data from the file into sub2_data array. Note that the third * parameter is set to NULL for contiguous reading. */ status = SDreaddata (sds_id, start, NULL, edges, (VOIDP)sub2_data); /* * Print what we have just read; the following numbers should be displayed: * * 10 1000 12 13 */ for (j = 0; j < SUB2_LENGTH; j++) printf ("%d ", sub2_data[j]); printf ("\n"); /* * Reading the third subset. * * Set elements of the arrays start, edges, and stride to read * every 6th element in the column and 4th element in the row * starting at 1st column, 3d row. */ start[0] = 2; /* 3d row */ start[1] = 0; /* 1st column */ edges[0] = SUB3_LENGTH2; /* SUB3_LENGTH2 elements are read along each column */ edges[1] = SUB3_LENGTH1; /* SUB3_LENGTH1 elements are read along each row */ stride[0] = 6; /* read every 6th element along each column */ stride[1] = 4; /* read every 4th element along each row */ /* * Read the data from the file into sub3_data array. */ status = SDreaddata (sds_id, start, stride, edges, (VOIDP)sub3_data); /* * Print what we have just read; the following numbers should be displayed: * * 3 7 * 9 13 * 15 19 */ for ( j = 0; j < SUB3_LENGTH2; j++ ) { for (i = 0; i < SUB3_LENGTH1; i++) printf ("%d ", sub3_data[j][i]); printf ("\n"); } /* * Terminate access to the data set. */ status = SDendaccess (sds_id); /* * Terminate access to the SD interface and close the file. */ status = SDend (sd_id); }read_subsets.fprogram read_subsets implicit none C C Parameter declaration. C character*7 FILE_NAME parameter (FILE_NAME = 'SDS.hdf') integer DFACC_READ, DFNT_INT32 parameter (DFACC_READ = 1, + DFNT_INT32 = 24) integer SUB1_LENGTH, SUB2_LENGTH, SUB3_LENGTH1, + SUB3_LENGTH2 parameter (SUB1_LENGTH = 5, + SUB2_LENGTH = 4, + SUB3_LENGTH1 = 2, + SUB3_LENGTH2 = 3) C C Function declaration. C integer sfstart, sfselect, sfrdata, sfendacc, sfend C C**** Variable declaration ******************************************* C integer sd_id, sds_id, sds_index, status integer start(2), edges(2), stride(2) integer sub1_data(SUB1_LENGTH) integer sub2_data(SUB2_LENGTH) integer sub3_data(SUB3_LENGTH1,SUB3_LENGTH2) integer i, j C C**** End of variable declaration ************************************ C C C Open the file and initialize the SD interface. C sd_id = sfstart(FILE_NAME, DFACC_READ) C C Select the first data set. C sds_index = 0 sds_id =sfselect(sd_id, sds_index) C C Reading the first subset. C C Set elements of start, stride, and edges arrays to read C every 3d element in in the 2nd row starting in the 4th column. C start(1) = 1 start(2) = 3 edges(1) = 1 edges(2) = SUB1_LENGTH stride(1) = 1 stride(2) = 3 C C Read the data from sub1_data array. C status = sfrdata(sds_id, start, stride, edges, sub1_data) C C Print what we have just read, the following numbers should be displayed: C C 5 8 1000 14 17 C write(*,*) (sub1_data(j), j = 1, SUB1_LENGTH) C C Reading the second subset. C C Set elements of start, stride, and edges arrays to read C first 4 elements of 10th column. C start(1) = 0 start(2) = 9 edges(1) = SUB2_LENGTH edges(2) = 1 stride(1) = 1 stride(2) = 1 C C Read the data into sub2_data array. C status = sfrdata(sds_id, start, stride, edges, sub2_data) C C Print what we have just read; the following numbers should be displayed: C C 10 1000 12 13 C write(*,*) (sub2_data(j), j = 1, SUB2_LENGTH) C C Reading the third subset. C C Set elements of start, stride and edges arrays to read C every 6th element in the row and every 4th element in the column C starting at 1st row, 3rd column. C start(1) = 0 start(2) = 2 edges(1) = SUB3_LENGTH1 edges(2) = SUB3_LENGTH2 stride(1) = 4 stride(2) = 6 C C Read the data from the file into sub3_data array. C status = sfrdata(sds_id, start, stride, edges, sub3_data) C C Print what we have just read; the following numbers should be displayed: C C 3 9 15 C 7 13 19 C do 50 i = 1, SUB3_LENGTH1 write(*,*) (sub3_data(i,j), j = 1, SUB3_LENGTH2) 50 continue C C Terminate access to the data set. C status = sfendacc(sds_id) C C Terminate access to the SD interface and close the file. C status = sfend(sd_id) endget_info.c#include "mfhdf.h" #define FILE_NAME "SDS.hdf" main( ) { /************************* Variable declaration **************************/ int32 sd_id, sds_id; intn status; int32 n_datasets, n_file_attrs, index; int32 dim_sizes[MAX_VAR_DIMS]; int32 rank, data_type, n_attrs; char name[MAX_NC_NAME]; int i; /********************* End of variable declaration ***********************/ /* * Open the file and initialize the SD interface. */ sd_id = SDstart (FILE_NAME, DFACC_READ); /* * Determine the number of data sets in the file and the number * of file attributes. */ status = SDfileinfo (sd_id, &n_datasets, &n_file_attrs); /* * Access every data set and print its name, rank, dimension sizes, * data type, and number of attributes. * The following information should be displayed: * * name = SDStemplate * rank = 2 * dimension sizes are : 16 5 * data type is 24 * number of attributes is 0 */ for (index = 0; index < n_datasets; index++) { sds_id = SDselect (sd_id, index); status = SDgetinfo (sds_id, name, &rank, dim_sizes, &data_type, &n_attrs); printf ("name = %s\n", name); printf ("rank = %d\n", rank); printf ("dimension sizes are : "); for (i=0; i< rank; i++) printf ("%d ", dim_sizes[i]); printf ("\n"); printf ("data type is %d\n", data_type); printf ("number of attributes is %d\n", n_attrs); /* * Terminate access to the data set. */ status = SDendaccess (sds_id); } /* * Terminate access to the SD interface and close the file. */ status = SDend (sd_id); }get_info.fprogram get_data_set_info implicit none C C Parameter declaration. C character*7 FILE_NAME parameter (FILE_NAME = 'SDS.hdf') integer DFACC_READ, DFNT_INT32 parameter (DFACC_READ = 1, + DFNT_INT32 = 24) integer MAX_NC_NAME, MAX_VAR_DIMS parameter (MAX_NC_NAME = 256, + MAX_VAR_DIMS = 32) C C Function declaration. C integer sfstart, sffinfo, sfselect, sfginfo integer sfendacc, sfend C C**** Variable declaration ******************************************* C integer sd_id, sds_id integer n_datasets, n_file_attrs, index integer status, n_attrs integer rank, data_type integer dim_sizes(MAX_VAR_DIMS) character name *(MAX_NC_NAME) integer i C C**** End of variable declaration ************************************ C C C Open the file and initialize the SD interface. C sd_id = sfstart(FILE_NAME, DFACC_READ) C C Determine the number of data sets in the file and the number of C file attributes. C status = sffinfo(sd_id, n_datasets, n_file_attrs) C C Access every data set in the file and print its name, rank, C dimension sizes, data type, and number of attributes. C The following information should be displayed: C C name = SDStemplate C rank = 2 C dimension sizes are : 5 16 C data type is 24 C number of attributes is 0 C do 10 index = 0, n_datasets - 1 sds_id = sfselect(sd_id, index) status = sfginfo(sds_id, name, rank, dim_sizes, data_type, . n_attrs) write(*,*) "name = ", name(1:15) write(*,*) "rank = ", rank write(*,*) "dimension sizes are : ", (dim_sizes(i), i=1, rank) write(*,*) "data type is ", data_type write(*,*) "number of attributes is ", n_attrs C C Terminate access to the current data set. C status = sfendacc(sds_id) 10 continue C C Terminate access to the SD interface and close the file. C status = sfend(sd_id) endfind_sds_by_name.c#include "mfhdf.h" #define FILE_NAME "SDS.hdf" #define SDS_NAME "SDStemplate" #define WRONG_NAME "WrongName" #define X_LENGTH 5 #define Y_LENGTH 16 main( ) { /************************* Variable declaration **************************/ int32 sd_id, sds_id, sds_index; intn status; int32 start[2], edges[2]; int32 data[Y_LENGTH][X_LENGTH]; int i, j; /********************* End of variable declaration ***********************/ /* * Open the file for reading and initialize the SD interface. */ sd_id = SDstart (FILE_NAME, DFACC_READ); /* * Find index of the data set with the name specified in WRONG_NAME. * Error condition occurs, since the data set with that name does not exist * in the file. */ sds_index = SDnametoindex (sd_id, WRONG_NAME); if (sds_index == FAIL) printf ("Data set with the name \"WrongName\" does not exist\n"); /* * Find index of the data set with the name specified in SDS_NAME and use * the index to select the data set. */ sds_index = SDnametoindex (sd_id, SDS_NAME); sds_id = SDselect (sd_id, sds_index); /* * Set elements of the array start to 0, elements of the array edges to * SDS dimensions, and use NULL for stride argument in SDreaddata to read * the entire data. */ start[0] = 0; start[1] = 0; edges[0] = Y_LENGTH; edges[1] = X_LENGTH; /* * Read the entire data into the buffer named data. */ status = SDreaddata (sds_id, start, NULL, edges, (VOIDP)data); /* * Print 10th row; the following numbers should be displayed: * * 10 1000 12 13 14 */ for (j = 0; j < X_LENGTH; j++) printf ("%d ", data[9][j]); printf ("\n"); /* * Terminate access to the data set. */ status = SDendaccess (sds_id); /* * Terminate access to the SD interface and close the file. */ status = SDend (sd_id); }find_sds_by_name.fprogram locate_by_name implicit none C C Parameter declaration. C character*7 FILE_NAME character*11 SDS_NAME character*9 WRONG_NAME integer X_LENGTH, Y_LENGTH parameter (FILE_NAME = 'SDS.hdf', + SDS_NAME = 'SDStemplate', + WRONG_NAME = 'WrongName', + X_LENGTH = 5, + Y_LENGTH = 16) integer DFACC_READ, DFNT_INT32 parameter (DFACC_READ = 1, + DFNT_INT32 = 24) C C Function declaration. C integer sfstart, sfn2index, sfselect, sfrdata, sfendacc, sfend C C**** Variable declaration ******************************************* C integer sd_id, sds_id, sds_index, status integer start(2), edges(2), stride(2) integer data(X_LENGTH, Y_LENGTH) integer j C C**** End of variable declaration ************************************ C C C Open the file and initialize the SD interface. C sd_id = sfstart(FILE_NAME, DFACC_READ) C C Find index of the data set with the name specified in WRONG_NAME. C Error condition occurs, since a data set with this name C does not exist in the file. C sds_index = sfn2index(sd_id, WRONG_NAME) if (sds_index .eq. -1) then write(*,*) "Data set with the name ", WRONG_NAME, + " does not exist" endif C C Find index of the data set with the name specified in SDS_NAME C and use the index to attach to the data set. C sds_index = sfn2index(sd_id, SDS_NAME) sds_id = sfselect(sd_id, sds_index) C C Set elements of start array to 0, elements of edges array C to SDS dimensions, and elements of stride array to 1 to read entire data. C start(1) = 0 start(2) = 0 edges(1) = X_LENGTH edges(2) = Y_LENGTH stride(1) = 1 stride(2) = 1 C C Read entire data into array named data. C status = sfrdata(sds_id, start, stride, edges, data) C C Print 10th column; the following numbers should be displayed: C C 10 1000 12 13 14 C write(*,*) (data(j,10), j = 1, X_LENGTH) C C Terminate access to the data set. C status = sfendacc(sds_id) C C Terminate access to the SD interface and close the file. C status = sfend(sd_id) endset_get_dim_info.c#include "mfhdf.h" #define FILE_NAME "SDS.hdf" #define SDS_NAME "SDStemplate" #define DIM_NAME_X "X_Axis" #define DIM_NAME_Y "Y_Axis" #define NAME_LENGTH 6 #define X_LENGTH 5 #define Y_LENGTH 16 #define RANK 2 main( ) { /************************* Variable declaration **************************/ int32 sd_id, sds_id, sds_index; intn status; int32 dim_index, dim_id; int32 n_values, data_type, n_attrs; int16 data_X[X_LENGTH]; /* X dimension dimension scale */ int16 data_X_out[X_LENGTH]; float64 data_Y[Y_LENGTH]; /* Y dimension dimension scale */ float64 data_Y_out[Y_LENGTH]; char dim_name[NAME_LENGTH]; int i, j, nrow; /********************* End of variable declaration ***********************/ /* * Initialize dimension scales. */ for (i=0; i < X_LENGTH; i++) data_X[i] = i; for (i=0; i < Y_LENGTH; i++) data_Y[i] = 0.1 * i; /* * Open the file and initialize SD interface. */ sd_id = SDstart (FILE_NAME, DFACC_WRITE); /* * Get the index of the data set specified in SDS_NAME. */ sds_index = SDnametoindex (sd_id, SDS_NAME); /* * Select the data set corresponding to the returned index. */ sds_id = SDselect (sd_id, sds_index); /* For each dimension of the data set specified in SDS_NAME, * get its dimension identifier and set dimension name * and dimension scale. Note that data type of dimension scale * can be different between dimensions and can be different from * SDS data type. */ for (dim_index = 0; dim_index < RANK; dim_index++) { /* * Select the dimension at position dim_index. */ dim_id = SDgetdimid (sds_id, dim_index); /* * Assign name and dimension scale to selected dimension. */ switch (dim_index) { case 0: status = SDsetdimname (dim_id, DIM_NAME_Y); n_values = Y_LENGTH; status = SDsetdimscale (dim_id,n_values,DFNT_FLOAT64, \ (VOIDP)data_Y); break; case 1: status = SDsetdimname (dim_id, DIM_NAME_X); n_values = X_LENGTH; status = SDsetdimscale (dim_id,n_values,DFNT_INT16, \ (VOIDP)data_X); break; default: break; } /* * Get and display info about the dimension and its scale values. * The following information is displayed: * * Information about 1 dimension: * dimension name is Y_Axis * number of scale values is 16 * dimension scale data type is float64 * number of dimension attributes is 0 * * Scale values are : * 0.000 0.100 0.200 0.300 * 0.400 0.500 0.600 0.700 * 0.800 0.900 1.000 1.100 * 1.200 1.300 1.400 1.500 * * Information about 2 dimension: * dimension name is X_Axis * number of scale values is 5 * dimension scale data type is int16 * number of dimension attributes is 0 * * Scale values are : * 0 1 2 3 4 */ status = SDdiminfo (dim_id, dim_name, &n_values, &data_type, &n_attrs); printf ("Information about %d dimension:\n", dim_index+1); printf ("dimension name is %s\n", dim_name); printf ("number of scale values is %d\n", n_values); if( data_type == DFNT_FLOAT64) printf ("dimension scale data type is float64\n"); if( data_type == DFNT_INT16) printf ("dimension scale data type is int16\n"); printf ("number of dimension attributes is %d\n", n_attrs); printf ("\n"); printf ("Scale values are :\n"); switch (dim_index) { case 0: status = SDgetdimscale (dim_id, (VOIDP)data_Y_out); nrow = 4; for (i=0; i<n_values/nrow; i++ ) { for (j=0; j<nrow; j++) printf (" %-6.3f", data_Y_out[i*nrow + j]); printf ("\n"); } break; case 1: status = SDgetdimscale (dim_id, (VOIDP)data_X_out); for (i=0; i<n_values; i++) printf (" %d", data_X_out[i]); break; default: break; } printf ("\n"); } /*for dim_index */ /* * Terminate access to the data set. */ status = SDendaccess (sds_id); /* * Terminate access to the SD interface and close the file. */ status = SDend (sd_id); }set_get_dim_info.fprogram dimension_info implicit none C C Parameter declaration. C character*7 FILE_NAME character*11 SDS_NAME character*6 DIM_NAME_X character*6 DIM_NAME_Y integer X_LENGTH, Y_LENGTH, RANK parameter (FILE_NAME = 'SDS.hdf', + SDS_NAME = 'SDStemplate', + DIM_NAME_X = 'X_Axis', + DIM_NAME_Y = 'Y_Axis', + X_LENGTH = 5, + Y_LENGTH = 16, + RANK = 2) integer DFACC_WRITE, DFNT_INT16, DFNT_FLOAT64 parameter (DFACC_WRITE = 2, + DFNT_INT16 = 22, + DFNT_FLOAT64 = 6) C C Function declaration. C integer sfstart, sfn2index, sfdimid, sfgdinfo integer sfsdscale, sfgdscale, sfsdmname, sfendacc integer sfend, sfselect C C**** Variable declaration ******************************************* C integer sd_id, sds_id, sds_index, status integer dim_index, dim_id integer n_values, n_attrs, data_type integer*2 data_X(X_LENGTH) integer*2 data_X_out(X_LENGTH) real*8 data_Y(Y_LENGTH) real*8 data_Y_out(Y_LENGTH) character*6 dim_name integer i C C**** End of variable declaration ************************************ C C C Initialize dimension scales. C do 10 i = 1, X_LENGTH data_X(i) = i - 1 10 continue do 20 i = 1, Y_LENGTH data_Y(i) = 0.1 * (i - 1) 20 continue C C Open the file and initialize SD interface. C sd_id = sfstart(FILE_NAME, DFACC_WRITE) C C Get the index of the data set with the name specified in SDS_NAME. C sds_index = sfn2index(sd_id, SDS_NAME) C C Select the data set corresponding to the returned index. C sds_id = sfselect(sd_id, sds_index) C C For each dimension of the data set, C get its dimension identifier and set dimension name C and dimension scales. Note that data type of dimension scale can C be different between dimensions and can be different from SDS data type. C do 30 dim_index = 0, RANK - 1 C C Select the dimension at position dim_index. C dim_id = sfdimid(sds_id, dim_index) C C Assign name and dimension scale to the dimension. C if (dim_index .eq. 0) then status = sfsdmname(dim_id, DIM_NAME_X) n_values = X_LENGTH status = sfsdscale(dim_id, n_values, DFNT_INT16, data_X) end if if (dim_index .eq. 1) then status = sfsdmname(dim_id, DIM_NAME_Y) n_values = Y_LENGTH status = sfsdscale(dim_id, n_values, DFNT_FLOAT64, data_Y) end if C C Get and display information about dimension and its scale values. C The following information is displayed: C C Information about 1 dimension : C dimension name is X_Axis C number of scale values is 5 C dimension scale data type is int16 C C number of dimension attributes is 0 C Scale values are: C 0 1 2 3 4 C C Information about 2 dimension : C dimension name is Y_Axis C number of scale values is 16 C dimension scale data type is float64 C number of dimension attributes is 0 C C Scale values are: C 0.000 0.100 0.200 0.300 C 0.400 0.500 0.600 0.700 C 0.800 0.900 1.000 1.100 C 1.200 1.300 1.400 1.500 C status = sfgdinfo(dim_id, dim_name, n_values, data_type, n_attrs) C write(*,*) "Information about ", dim_index+1," dimension :" write(*,*) "dimension name is ", dim_name write(*,*) "number of scale values is", n_values if (data_type. eq. 22) then write(*,*) "dimension scale data type is int16" endif if (data_type. eq. 6) then write(*,*) "dimension scale data type is float64" endif write(*,*) "number of dimension attributes is ", n_attrs C write(*,*) "Scale values are:" if (dim_index .eq. 0) then status = sfgdscale(dim_id, data_X_out) write(*,*) (data_X_out(i), i= 1, X_LENGTH) endif if (dim_index .eq. 1) then status = sfgdscale(dim_id, data_Y_out) write(*,100) (data_Y_out(i), i= 1, Y_LENGTH) 100 format(4(1x,f10.3)/) endif 30 continue C C Terminate access to the data set. C status = sfendacc(sds_id) C C Terminate access to the SD interface and close the file. C status = sfend(sd_id) enddimscale_vs_sds.c#include "mfhdf.h" #define FILE_NAME "SDS.hdf" main( ) { /************************* Variable declaration **************************/ int32 sd_id, sds_id, sds_index; intn status; int32 rank, data_type, dim_sizes[MAX_VAR_DIMS]; int32 n_datasets, n_file_attr, n_attrs; char sds_name[MAX_NC_NAME]; /********************* End of variable declaration ***********************/ /* * Open the file and initialize the SD interface. */ sd_id = SDstart(FILE_NAME, DFACC_READ); /* * Obtain information about the file. */ status = SDfileinfo(sd_id, &n_datasets, &n_file_attr); /* Get information about each SDS in the file. * Check whether it is a coordinate variable, then display retrieved * information. * Output displayed: * * SDS array with the name SDStemplate * Coordinate variable with the name Y_Axis * Coordinate variable with the name X_Axis * */ for (sds_index=0; sds_index< n_datasets; sds_index++) { sds_id = SDselect (sd_id, sds_index); status = SDgetinfo(sds_id, sds_name, &rank, dim_sizes, &data_type, &n_attrs); if (SDiscoordvar(sds_id)) printf(" Coordinate variable with the name %s\n", sds_name); else printf(" SDS array with the name %s\n", sds_name); /* * Terminate access to the selected data set. */ status = SDendaccess(sds_id); } /* * Terminate access to the SD interface and close the file. */ status = SDend(sd_id); }dimscale_vs_sds.fprogram sds_vrs_coordvar implicit none C C Parameter declaration. C character*7 FILE_NAME parameter (FILE_NAME = 'SDS.hdf') integer DFACC_READ, DFNT_INT32 parameter (DFACC_READ = 1, + DFNT_INT32 = 24) integer MAX_VAR_DIMS parameter (MAX_VAR_DIMS = 32) C C Function declaration. C integer sfstart, sfselect, sfiscvar, sffinfo, sfginfo integer sfendacc, sfend C C**** Variable declaration ******************************************* C integer sd_id, sds_id, sds_index, status integer rank, data_type integer n_datasets, n_file_attrs, n_attrs integer dim_sizes(MAX_VAR_DIMS) character*256 sds_name C C**** End of variable declaration ************************************ C C C Open the file and initialize the SD interface. C sd_id = sfstart(FILE_NAME, DFACC_READ) C C Obtain information about the file. C status = sffinfo(sd_id, n_datasets, n_file_attrs) C C Get information about each SDS in the file. C Check whether it is a coordinate variable, then display retrieved C information. C Output displayed: C C SDS array with the name SDStemplate C Coordinate variable with the name X_Axis C Coordinate variable with the name Y_Axis C do 10 sds_index = 0, n_datasets-1 sds_id = sfselect(sd_id, sds_index) status = sfginfo(sds_id, sds_name, rank, dim_sizes, + data_type, n_attrs) status = sfiscvar(sds_id) if (status .eq. 1) then write(*,*) "Coordinate variable with the name ", + sds_name(1:6) else write(*,*) "SDS array with the name ", + sds_name(1:11) endif C C Terminate access to the data set. C status = sfendacc(sds_id) 10 continue C C Terminate access to the SD interface and close the file. C status = sfend(sd_id) endset_attr.c#include "mfhdf.h" #define FILE_NAME "SDS.hdf" #define FILE_ATTR_NAME "File_contents" #define SDS_ATTR_NAME "Valid_range" #define DIM_ATTR_NAME "Dim_metric" main( ) { /************************* Variable declaration **************************/ int32 sd_id, sds_id, sds_index; intn status; int32 dim_id, dim_index; int32 n_values; /* number of values of the file, SDS or dimension attribute */ char8 file_values[] = "Storm_track_data"; /* values of the file attribute */ float32 sds_values[2] = {2., 10.}; /* values of the SDS attribute */ char8 dim_values[] = "Seconds"; /* values of the dimension attribute */ /********************* End of variable declaration ***********************/ /* * Open the file and initialize the SD interface. */ sd_id = SDstart (FILE_NAME, DFACC_WRITE); /* * Set an attribute that describes the file contents. */ n_values = 16; status = SDsetattr (sd_id, FILE_ATTR_NAME, DFNT_CHAR8, n_values, (VOIDP)file_values); /* * Select the first data set. */ sds_index = 0; sds_id = SDselect (sd_id, sds_index); /* * Assign attribute to the first SDS. Note that attribute values * may have different data type than SDS data. */ n_values = 2; status = SDsetattr (sds_id, SDS_ATTR_NAME, DFNT_FLOAT32, n_values, (VOIDP)sds_values); /* * Get the the second dimension identifier of the SDS. */ dim_index = 1; dim_id = SDgetdimid (sds_id, dim_index); /* * Set an attribute of the dimension that specifies the dimension metric. */ n_values = 7; status = SDsetattr (dim_id, DIM_ATTR_NAME, DFNT_CHAR8, n_values, (VOIDP)dim_values); /* * Terminate access to the data set. */ status = SDendaccess (sds_id); /* * Terminate access to the SD interface and close the file. */ status = SDend (sd_id); }set_attr.fprogram set_attribs implicit none C C Parameter declaration. C character*7 FILE_NAME character*13 FILE_ATTR_NAME character*11 SDS_ATTR_NAME character*10 DIM_ATTR_NAME parameter (FILE_NAME = 'SDS.hdf', + FILE_ATTR_NAME = 'File_contents', + SDS_ATTR_NAME = 'Valid_range', + DIM_ATTR_NAME = 'Dim_metric') integer DFACC_WRITE, DFNT_CHAR8, DFNT_FLOAT32 parameter (DFACC_WRITE = 2, + DFNT_CHAR8 = 4, + DFNT_FLOAT32 = 5) C C Function declaration. C integer sfstart, sfscatt, sfsnatt, sfselect, sfdimid integer sfendacc, sfend C C**** Variable declaration ******************************************* C integer sd_id, sds_id, sds_index, status integer dim_id, dim_index integer n_values character*16 file_values real sds_values(2) character*7 dim_values file_values = 'Storm_track_data' sds_values(1) = 2. sds_values(2) = 10. dim_values = 'Seconds' C C**** End of variable declaration ************************************ C C C Open the file and initialize the SD interface. C sd_id = sfstart(FILE_NAME, DFACC_WRITE) C C Set an attribute that describes the file contents. C n_values = 16 status = sfscatt(sd_id, FILE_ATTR_NAME, DFNT_CHAR8, n_values, + file_values) C C Select the first data set. C sds_index = 0 sds_id = sfselect(sd_id, sds_index) C C Assign attribute to the first SDS. Note that attribute values C may have different data type than SDS data. C n_values = 2 status = sfsnatt(sds_id, SDS_ATTR_NAME, DFNT_FLOAT32, n_values, + sds_values) C C Get the identifier for the first dimension. C dim_index = 0 dim_id = sfdimid(sds_id, dim_index) C C Set an attribute to the dimension that specifies the C dimension metric. C n_values = 7 status = sfscatt(dim_id, DIM_ATTR_NAME, DFNT_CHAR8, n_values, + dim_values) C C Terminate access to the data set. C status = sfendacc(sds_id) C C Terminate access to the SD interface and close the file. C status = sfend(sd_id) endget_attr.c#include "mfhdf.h" #define FILE_NAME "SDS.hdf" #define FILE_ATTR_NAME "File_contents" #define SDS_ATTR_NAME "Valid_range" #define DIM_ATTR_NAME "Dim_metric" main( ) { /************************* Variable declaration **************************/ int32 sd_id, sds_id, dim_id; intn status; int32 attr_index, data_type, n_values; char attr_name[MAX_NC_NAME]; int8 *file_data; int8 *dim_data; float32 *sds_data; int i; /********************* End of variable declaration ***********************/ /* * Open the file and initialize SD interface. */ sd_id = SDstart (FILE_NAME, DFACC_READ); /* * Find the file attribute defined by FILE_ATTR_NAME. */ attr_index = SDfindattr (sd_id, FILE_ATTR_NAME); /* * Get information about the file attribute. Note that the first * parameter is an SD interface identifier. */ status = SDattrinfo (sd_id, attr_index, attr_name, &data_type, &n_values); /* * Allocate a buffer to hold the attribute data. */ file_data = (int8 *)malloc (n_values * sizeof (data_type)); /* * Read the file attribute data. */ status = SDreadattr (sd_id, attr_index, file_data); /* * Print out file attribute value. */ printf ("File attribute value is : %s\n", file_data); /* * Select the first data set. */ sds_id = SDselect (sd_id, 0); /* * Find the data set attribute defined by SDS_ATTR_NAME. Note that the * first parameter is a data set identifier. */ attr_index = SDfindattr (sds_id, SDS_ATTR_NAME); /* * Get information about the data set attribute. */ status = SDattrinfo (sds_id, attr_index, attr_name, &data_type, &n_values); /* * Allocate a buffer to hold the data set attribute data. */ sds_data = (float32 *)malloc (n_values * sizeof (data_type)); /* * Read the SDS attribute data. */ status = SDreadattr (sds_id, attr_index, sds_data); /* * Print out SDS attribute data type and values. */ if (data_type == DFNT_FLOAT32) printf ("SDS attribute data type is : float32\n"); printf ("SDS attribute values are : "); for (i=0; i<n_values; i++) printf (" %f", sds_data[i]); printf ("\n"); /* * Get the identifier for the second dimension of the SDS. */ dim_id = SDgetdimid (sds_id, 1); /* * Find dimension attribute defined by DIM_ATTR_NAME. */ attr_index = SDfindattr (dim_id, DIM_ATTR_NAME); /* * Get information about the dimension attribute. */ status = SDattrinfo (dim_id, attr_index, attr_name, &data_type, &n_values); /* * Allocate a buffer to hold the dimension attribute data. */ dim_data = (int8 *)malloc (n_values * sizeof (data_type)); /* * Read the dimension attribute data. */ status = SDreadattr (dim_id, attr_index, dim_data); /* * Print out dimension attribute value. */ printf ("Dimensional attribute values is : %s\n", dim_data); /* * Terminate access to the data set and to the SD interface and * close the file. */ status = SDendaccess (sds_id); status = SDend (sd_id); /* * Free all buffers. */ free (dim_data); free (sds_data); free (file_data); /* Output of this program is : * * File attribute value is : Storm_track_data * SDS attribute data type is : float32 * SDS attribute values are : 2.000000 10.000000 * Dimensional attribute values is : Seconds */ }get_attr.fprogram attr_info implicit none C C Parameter declaration. C character*7 FILE_NAME character*13 FILE_ATTR_NAME character*11 SDS_ATTR_NAME character*10 DIM_ATTR_NAME parameter (FILE_NAME = 'SDS.hdf', + FILE_ATTR_NAME = 'File_contents', + SDS_ATTR_NAME = 'Valid_range', + DIM_ATTR_NAME = 'Dim_metric') integer DFACC_READ, DFNT_FLOAT32 parameter (DFACC_READ = 1, + DFNT_FLOAT32 = 5) C C Function declaration. C integer sfstart, sffattr, sfgainfo, sfrattr, sfselect integer sfdimid, sfendacc, sfend C C**** Variable declaration ******************************************* C integer sd_id, sds_id, dim_id integer attr_index, data_type, n_values, status real sds_data(2) character*20 attr_name character*16 file_data character*7 dim_data integer i C C**** End of variable declaration ************************************ C C C Open the file and initialize SD interface. C sd_id = sfstart(FILE_NAME, DFACC_READ) C C Find the file attribute defined by FILE_ATTR_NAME. C Note that the first parameter is an SD interface identifier. C attr_index = sffattr(sd_id, FILE_ATTR_NAME) C C Get information about the file attribute. C status = sfgainfo(sd_id, attr_index, attr_name, data_type, + n_values) C C Read the file attribute data. C status = sfrattr(sd_id, attr_index, file_data) C C Print file attribute value. C write(*,*) "File attribute value is : ", file_data C C Select the first data set. C sds_id = sfselect(sd_id, 0) C C Find the data set attribute defined by SDS_ATTR_NAME. C Note that the first parameter is a data set identifier. C attr_index = sffattr(sds_id, SDS_ATTR_NAME) C C Get information about the data set attribute. C status = sfgainfo(sds_id, attr_index, attr_name, data_type, + n_values) C C Read the SDS attribute data. C status = sfrattr(sds_id, attr_index, sds_data) C C Print SDS attribute data type and values. C if (data_type .eq. DFNT_FLOAT32) then write(*,*) "SDS attribute data type is : float32 " endif write(*,*) "SDS attribute values are : " write(*,*) (sds_data(i), i=1, n_values) C C Get the identifier for the first dimension of the SDS. C dim_id = sfdimid(sds_id, 0) C C Find the dimensional attribute defined by DIM_ATTR_NAME. C Note that the first parameter is a dimension identifier. C attr_index = sffattr(dim_id, DIM_ATTR_NAME) C C Get information about dimension attribute. C status = sfgainfo(dim_id, attr_index, attr_name, data_type, + n_values) C C Read the dimension attribute data. C status = sfrattr(dim_id, attr_index, dim_data) C C Print dimension attribute value. C write(*,*) "Dimensional attribute value is : ", dim_data C C Terminate access to the data set. C status = sfendacc(sds_id) C C Terminate access to the SD interface and close the file. C status = sfend(sd_id) C C Output of this program is : C C C File attribute value is : Storm_track_data C SDS attribute data type is : float32 C SDS attribute values are : C 2.00000 10.00000 C Dimensional attribute value is : Seconds C endchunking_example.c#include "mfhdf.h" #define FILE_NAME "SDSchunked.hdf" #define SDS_NAME "ChunkedData" #define RANK 2 main() { /************************* Variable declaration **************************/ int32 sd_id, sds_id, sds_index; intn status; int32 flag, maxcache, new_maxcache; int32 dim_sizes[2], origin[2]; HDF_CHUNK_DEF c_def, c_def_out; /* Chunking definitions */ int32 comp_flag, c_flags; int16 all_data[9][4]; int32 start[2], edges[2]; int16 chunk_out[3][2]; int16 row[2] = { 5, 5 }; int16 column[3] = { 4, 4, 4 }; int16 fill_value = 0; /* Fill value */ int i,j; /* * Declare chunks data type and initialize some of them. */ int16 chunk1[3][2] = { 1, 1, 1, 1, 1, 1 }; int16 chunk2[3][2] = { 2, 2, 2, 2, 2, 2 }; int16 chunk3[3][2] = { 3, 3, 3, 3, 3, 3 }; int16 chunk6[3][2] = { 6, 6, 6, 6, 6, 6 }; /********************* End of variable declaration ***********************/ /* * Define chunk's dimensions. * * In this example we do not use compression. * To use chunking with RLE, Skipping Huffman, and GZIP * compression, initialize * * c_def.comp.chunk_lengths[0] = 3; * c_def.comp.chunk_lengths[1] = 2; * * To use chunking with NBIT, initialize * * c_def.nbit.chunk_lengths[0] = 3; * c_def.nbit.chunk_lengths[1] = 2; * */ c_def.chunk_lengths[0] = 3; c_def.chunk_lengths[1] = 2; /* * Create the file and initialize SD interface. */ sd_id = SDstart (FILE_NAME, DFACC_CREATE); /* * Create 9x4 SDS. */ dim_sizes[0] = 9; dim_sizes[1] = 4; sds_id = SDcreate (sd_id, SDS_NAME,DFNT_INT16, RANK, dim_sizes); /* * Fill the SDS array with the fill value. */ status = SDsetfillvalue (sds_id, (VOIDP)&fill_value); /* * Create chunked SDS. * In this example we do not use compression ( third * parameter of SDsetchunk is set to HDF_CHUNK). * * To use RLE compresssion, set compression type and flag * * c_def.comp.comp_type = COMP_CODE_RLE; * comp_flag = HDF_CHUNK | HDF_COMP; * * To use Skipping Huffman compression, set compression type, flag * and skipping size skp_size * * c_def.comp.comp_type = COMP_CODE_SKPHUFF; * c_def.comp.cinfo.skphuff.skp_size = value; * comp_flag = HDF_CHUNK | HDF_COMP; * * To use GZIP compression, set compression type, flag and * deflate level * * c_def.comp.comp_type = COMP_CODE_DEFLATE; * c_def.comp.cinfo.deflate.level = value; * comp_flag = HDF_CHUNK | HDF_COMP; * * To use NBIT compression, set compression flag and * compression parameters * * comp_flag = HDF_CHUNK | HDF_NBIT; * c_def.nbit.start_bit = value1; * c_def.nbit.bit_len = value2; * c_def.nbit.sign_ext = value3; * c_def.nbit.fill_one = value4; */ comp_flag = HDF_CHUNK; status = SDsetchunk (sds_id, c_def, comp_flag); /* * Set chunk cache to hold maximum of 3 chunks. */ maxcache = 3; flag = 0; new_maxcache = SDsetchunkcache (sds_id, maxcache, flag); /* * Write chunks using SDwritechunk function. * Chunks can be written in any order. */ /* * Write the chunk with the coordinates (0,0). */ origin[0] = 0; origin[1] = 0; status = SDwritechunk (sds_id, origin, (VOIDP) chunk1); /* * Write the chunk with the coordinates (1,0). */ origin[0] = 1; origin[1] = 0; status = SDwritechunk (sds_id, origin, (VOIDP) chunk3); /* * Write the chunk with the coordinates (0,1). */ origin[0] = 0; origin[1] = 1; status = SDwritechunk (sds_id, origin, (VOIDP) chunk2); /* * Write chunk with the coordinates (1,2) using * SDwritedata function. */ start[0] = 6; start[1] = 2; edges[0] = 3; edges[1] = 2; status = SDwritedata (sds_id, start, NULL, edges, (VOIDP) chunk6); /* * Fill second column in the chunk with the coordinates (1,1) * using SDwritedata function. */ start[0] = 3; start[1] = 3; edges[0] = 3; edges[1] = 1; status = SDwritedata (sds_id, start, NULL, edges, (VOIDP) column); /* * Fill second row in the chunk with the coordinates (0,2) * using SDwritedata function. */ start[0] = 7; start[1] = 0; edges[0] = 1; edges[1] = 2; status = SDwritedata (sds_id, start, NULL, edges, (VOIDP) row); /* * Terminate access to the data set. */ status = SDendaccess (sds_id); /* * Terminate access to the SD interface and close the file. */ status = SDend (sd_id); /* * Reopen the file and access the first data set. */ sd_id = SDstart (FILE_NAME, DFACC_READ); sds_index = 0; sds_id = SDselect (sd_id, sds_index); /* * Get information about the SDS. Only chunk lengths and compression * flag can be returned. Compression information is not available if * NBIT, Skipping Huffman, or GZIP compression is used. */ status = SDgetchunkinfo (sds_id, &c_def_out, &c_flags); if (c_flags == HDF_CHUNK ) printf(" SDS is chunked\nChunk's dimensions %dx%d\n", c_def_out.chunk_lengths[0], c_def_out.chunk_lengths[1]); else if (c_flags == (HDF_CHUNK | HDF_COMP)) printf("SDS is chunked and compressed\nChunk's dimensions %dx%d\n", c_def_out.comp.chunk_lengths[0], c_def_out.comp.chunk_lengths[1]); else if (c_flags == (HDF_CHUNK | HDF_NBIT)) printf ("SDS is chunked (NBIT)\nChunk's dimensions %dx%d\n", c_def_out.nbit.chunk_lengths[0], c_def_out.nbit.chunk_lengths[1]); /* * Read the entire data set using SDreaddata function. */ start[0] = 0; start[1] = 0; edges[0] = 9; edges[1] = 4; status = SDreaddata (sds_id, start, NULL, edges, (VOIDP)all_data); /* * Print out what we have read. * The following information should be displayed: * * SDS is chunked * Chunk's dimensions 3x2 * 1 1 2 * 1 1 2 2 * 1 1 2 2 * 3 3 0 4 * 3 3 0 4 * 3 3 0 4 * 0 0 6 6 * 5 5 6 6 * 0 0 6 6 */ for (j=0; j<9; j++) { for (i=0; i<4; i++) printf (" %d", all_data[j][i]); printf ("\n"); } /* * Read chunk with the coordinates (2,0) and display it. */ origin[0] = 2; origin[1] = 0; status = SDreadchunk (sds_id, origin, chunk_out); printf (" Chunk (2,0) \n"); for (j=0; j<3; j++) { for (i=0; i<2; i++) printf (" %d", chunk_out[j][i]); printf ("\n"); } /* * Read chunk with the coordinates (1,1) and display it. */ origin[0] = 1; origin[1] = 1; status = SDreadchunk (sds_id, origin, chunk_out); printf (" Chunk (1,1) \n"); for (j=0; j<3; j++) { for (i=0; i<2; i++) printf (" %d", chunk_out[j][i]); printf ("\n"); } /* The following information is displayed: * * Chunk (2,0) * 0 0 * 5 5 * 0 0 * Chunk (1,1) * 0 4 * 0 4 * 0 4 */ /* * Terminate access to the data set. */ status = SDendaccess (sds_id); /* * Terminate access to the SD interface and close the file. */ status = SDend (sd_id); }chunking_example.fprogram chunk_examples implicit none C C Parameter declaration. C character*14 FILE_NAME character*11 SDS_NAME integer RANK parameter (FILE_NAME = 'SDSchunked.hdf', + SDS_NAME = 'ChunkedData', + RANK = 2) integer DFACC_CREATE, DFACC_READ, DFNT_INT16 parameter (DFACC_CREATE = 4, + DFACC_READ = 1, + DFNT_INT16 = 22) integer COMP_CODE_NONE parameter (COMP_CODE_NONE = 0) C C This example does not use compression. C C To use RLE compression, declare: C C integer COMP_CODE_RLE C parameter (COMP_CODE_RLE = 1) C C To use NBIT compression, declare: C C integer COMP_CODE_NBIT C parameter (COMP_CODE_NBIT = 2) C C To use Skipping Huffman compression, declare: C C integer COMP_CODE_SKPHUFF C parameter (COMP_CODE_SKPHUFF = 3) C C To use GZIP compression, declare: C C integer COMP_CODE_DEFLATE C parameter (COMP_CODE_DEFLATE = 4) C C C Function declaration. C integer sfstart, sfcreate, sfendacc, sfend, + sfselect, sfsfill, sfschnk, sfwchnk, + sfrchnk, sfgichnk, sfwdata, sfrdata, + sfscchnk C C**** Variable declaration ******************************************* C integer sd_id, sds_id, sds_index, status integer dim_sizes(2), origin(2) integer fill_value, maxcache, new_maxcache, flag integer start(2), edges(2), stride(2) integer*2 all_data(4,9) integer*2 row(3), column(2) integer*2 chunk_out(2,3) integer*2 chunk1(2,3), + chunk2(2,3), + chunk3(2,3), + chunk6(2,3) integer i, j C C Compression flag and parameters. C integer comp_type, comp_flag, comp_prm(4) C C Chunk's dimensions. C integer dim_length(2), dim_length_out(2) C C Initialize four chunks C data chunk1 /6*1/ data chunk2 /6*2/ data chunk3 /6*3/ data chunk6 /6*6/ C C Initialize row and column arrays. C data row /3*4/ data column /2*5/ C C**** End of variable declaration ************************************ C C C Define chunk's dimensions. C dim_length(1) = 2 dim_length(2) = 3 C C Create the file and initialize SD interface. C sd_id = sfstart(FILE_NAME, DFACC_CREATE) C C Create 4x9 SDS C dim_sizes(1) = 4 dim_sizes(2) = 9 sds_id = sfcreate(sd_id, SDS_NAME, DFNT_INT16, + RANK, dim_sizes) C C Fill SDS array with the fill value. C fill_value = 0 status = sfsfill( sds_id, fill_value) C C Create chunked SDS. C C In this example we do not use compression. C C To use RLE compression, initialize comp_type parameter C before the call to sfschnk function. C comp_type = COMP_CODE_RLE C C To use NBIT, Skipping Huffman, or GZIP compression, C initialize comp_prm array and comp type parameter C before call to sfschnk function C C NBIT: C comp_prm(1) = value_of(sign_ext) C comp_prm(2) = value_of(fill_one) C comp_prm(3) = value_of(start_bit) C comp_prm(4) = value_of(bit_len) C comp_type = COMP_CODE_NBIT C C Skipping Huffman: C comp_prm(1) = value_of(skp_size) C comp_type = COMP_CODE_SKPHUFF C C GZIP: C comp_prm(1) = value_of(deflate_level) C comp_type = COMP_CODE_DEFLATE C C comp_type = COMP_CODE_NONE status = sfschnk(sds_id, dim_length, comp_type, comp_prm) C C Set chunk cache to hold maximum 2 chunks. C flag = 0 maxcache = 2 new_maxcache = sfscchnk(sds_id, maxcache, flag) C C Write chunks using SDwritechunk function. C Chunks can be written in any order. C C Write chunk with the coordinates (1,1). C origin(1) = 1 origin(2) = 1 status = sfwchnk(sds_id, origin, chunk1) C C Write chunk with the coordinates (1,2). C origin(1) = 1 origin(2) = 2 status = sfwchnk(sds_id, origin, chunk3) C C Write chunk with the coordinates (2,1). C origin(1) = 2 origin(2) = 1 status = sfwchnk(sds_id, origin, chunk2) C C Write chunk with the coordinates (2,3). C origin(1) = 2 origin(2) = 3 status = sfwchnk(sds_id, origin, chunk6) C C Fill second row in the chunk with the coordinates (2,2). C start(1) = 3 start(2) = 3 edges(1) = 1 edges(2) = 3 stride(1) = 1 stride(2) = 1 status = sfwdata(sds_id, start, stride, edges, row) C C Fill second column in the chunk with the coordinates (1,3). C start(1) = 0 start(2) = 7 edges(1) = 2 edges(2) = 1 stride(1) = 1 stride(2) = 1 status = sfwdata(sds_id, start, stride, edges, column) C C Terminate access to the data set. C status = sfendacc(sds_id) C C Terminate access to the SD interface and close the file. C status = sfend(sd_id) C C Reopen the file and access the first data set. C sd_id = sfstart(FILE_NAME, DFACC_READ) sds_index = 0 sds_id = sfselect(sd_id, sds_index) C C Get information about the SDS. C status = sfgichnk(sds_id, dim_length_out, comp_flag) if (comp_flag .eq. 0) then write(*,*) 'SDS is chunked' endif if (comp_flag .eq. 1) then write(*,*) 'SDS is chunked and compressed' endif if (comp_flag .eq. 2) then write(*,*) 'SDS is chunked and NBIT compressed' endif write(*,*) 'Chunks dimensions are ', dim_length_out(1), + ' x' ,dim_length_out(2) C C Read the whole SDS using sfrdata function and display C what we have read. The following information will be displayed: C C C SDS is chunked C Chunks dimensions are 2 x 3 C C 1 1 1 3 3 3 0 5 0 C 1 1 1 3 3 3 0 5 0 C 2 2 2 0 0 0 6 6 6 C 2 2 2 4 4 4 6 6 6 C start(1) = 0 start(2) = 0 edges(1) = 4 edges(2) = 9 stride(1) = 1 stride(2) = 1 status = sfrdata(sds_id, start, stride, edges, all_data) C C Display the SDS. C write(*,*) do 10 i = 1,4 write(*,*) (all_data(i,j), j=1,9) 10 continue C C Read chunks with the coordinates (2,2) and (1,3) and display. C The following information will be shown: C C Chunk (2,2) C C 0 0 0 C 4 4 4 C C Chunk (1,3) C C 0 5 0 C 0 5 0 C origin(1) = 2 origin(2) = 2 status = sfrchnk(sds_id, origin, chunk_out) write(*,*) write(*,*) 'Chunk (2,2)' write(*,*) do 20 i = 1,2 write(*,*) (chunk_out(i,j), j=1,3) 20 continue C origin(1) = 1 origin(2) = 3 status = sfrchnk(sds_id, origin, chunk_out) write(*,*) write(*,*) 'Chunk (1,3)' write(*,*) do 30 i = 1,2 write(*,*) (chunk_out(i,j), j=1,3) 30 continue C C Terminate access to the data set. C status = sfendacc(sds_id) C C Terminate access to the SD interface and close the file. C status = sfend(sd_id) end
HDF4.2r4 - February 2009 Copyright |
The HDF Group www.hdfgroup.org ![]() |