[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.f
program 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)
end
write_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.f
program 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)
end
write_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.f
program 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)
end
alter_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.f
program 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)
end
unlimited_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.f
program 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)
end
compress_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.f
program 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)
end
mv_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.f
program 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)
end
read_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.f
program 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)
end
read_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.f
program 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)
end
get_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.f
program 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)
end
find_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.f
program 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)
end
set_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.f
program 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)
end
dimscale_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.f
program 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)
end
set_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.f
program 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)
end
get_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.f
program 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
end
chunking_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.f
program 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
[Top] [Prev] [Next]
hdfhelp@ncsa.uiuc.edu
HDF User's Guide - 05/19/99, NCSA HDF
Development Group.