![]() |
HDF User’s GuideVersion 4.2r4 |
[Top] [Prev][Next] |
create_and_write_image.c#include "hdf.h" #define FILE_NAME "General_RImages.hdf" #define IMAGE_NAME "Image Array 1" #define X_LENGTH 10 /* number of columns in the image */ #define Y_LENGTH 5 /* number of rows in the image */ #define N_COMPS 2 /* number of components in the image */ main( ) { /************************* Variable declaration **************************/ intn status; /* status for functions returning an intn */ int32 file_id, /* HDF file identifier */ gr_id, /* GR interface identifier */ ri_id, /* raster image identifier */ start[2], /* start position to write for each dimension */ edges[2], /* number of elements to be written along each dimension */ dim_sizes[2], /* dimension sizes of the image array */ interlace_mode, /* interlace mode of the image */ data_type, /* data type of the image data */ i, j; int16 image_buf[Y_LENGTH][X_LENGTH][N_COMPS]; /********************** End of variable declaration **********************/ /* * Create and open the file. */ file_id = Hopen (FILE_NAME, DFACC_CREATE, 0); /* * Initialize the GR interface. */ gr_id = GRstart (file_id); /* * Set the data type, interlace mode, and dimensions of the image. */ data_type = DFNT_INT16; interlace_mode = MFGR_INTERLACE_PIXEL; dim_sizes[0] = X_LENGTH; dim_sizes[1] = Y_LENGTH; /* * Create the raster image array. */ ri_id = GRcreate (gr_id, IMAGE_NAME, N_COMPS, data_type, interlace_mode, dim_sizes); /* * Fill the image data buffer with values. */ for (i = 0; i < Y_LENGTH; i++) { for (j = 0; j < X_LENGTH; j++) { image_buf[i][j][0] = (i + j) + 1; /* first component */ image_buf[i][j][1] = (i + j) + 1; /* second component */ } } /* * Define the size of the data to be written, i.e., start from the origin * and go as long as the length of each dimension. */ start[0] = start[1] = 0; edges[0] = X_LENGTH; edges[1] = Y_LENGTH; /* * Write the data in the buffer into the image array. */ status = GRwriteimage(ri_id, start, NULL, edges, (VOIDP)image_buf); /* * Terminate access to the raster image and to the GR interface and, * close the HDF file. */ status = GRendaccess (ri_id); status = GRend (gr_id); status = Hclose (file_id); }create_and_write_image.fprogram create_raster_image implicit none C C Parameter declaration C character*19 FILE_NAME character*13 IMAGE_NAME integer X_LENGTH integer Y_LENGTH integer N_COMPS C parameter (FILE_NAME = `General_RImages.hdf', + IMAGE_NAME = `Image Array 1', + X_LENGTH = 10, + Y_LENGTH = 5, + N_COMPS = 2) integer DFACC_CREATE, DFNT_INT16, MFGR_INTERLACE_PIXEL parameter (DFACC_CREATE = 4, + DFNT_INT16 = 22, + MFGR_INTERLACE_PIXEL = 0) C C Function declaration C integer hopen, hclose integer mgstart, mgcreat, mgwrimg, mgendac, mgend C C**** Variable declaration ******************************************* C integer status integer file_id integer gr_id, ri_id, num_type, interlace_mode integer start(2), stride(2), edges(2), dimsizes(2) integer i, j, k integer*2 image_buf(N_COMPS, X_LENGTH, Y_LENGTH) C C**** End of variable declaration ************************************ C C C Create and open the file. C file_id = hopen(FILE_NAME, DFACC_CREATE, 0) C C Initialize the GR interface. C gr_id = mgstart(file_id) C C Set the number type, interlace mode, and dimensions of the image. C num_type = DFNT_INT16 interlace_mode = MFGR_INTERLACE_PIXEL dimsizes(1) = X_LENGTH dimsizes(2) = Y_lENGTH C C Create the raster image array. C ri_id = mgcreat(gr_id, IMAGE_NAME, N_COMPS, num_type, + interlace_mode, dimsizes) C C Fill the image data buffer with values. C do 30 i = 1, Y_LENGTH do 20 j = 1, X_LENGTH do 10 k = 1, N_COMPS image_buf(k,j,i) = (i+j) - 1 10 continue 20 continue 30 continue C C Define the size of the data to be written, i.e., start from the origin C and go as long as the length of each dimension. 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 in the buffer into the image array. C status = mgwrimg(ri_id, start, stride, edges, image_buf) C C Terminate access to the raster image and to the GR interface, C and close the HDF file. C status = mgendac(ri_id) status = mgend(gr_id) status = hclose(file_id) endmodify_image.c#include "hdf.h" #define FILE_NAME "General_RImages.hdf" #define X1_LENGTH 5 /* number of columns in the first image being modified */ #define Y1_LENGTH 2 /* number of rows in the first image being modified */ #define N1_COMPS 2 /* number of components in the first image */ #define IMAGE1_NAME "Image Array 1" #define IMAGE2_NAME "Image Array 2" #define X2_LENGTH 6 /* number of columns in the second image */ #define Y2_LENGTH 4 /* number of rows in the second image */ #define N2_COMPS 3 /* number of components in the second image */ main( ) { /************************* Variable declaration **************************/ intn status; /* status for functions returning an intn */ int32 file_id, /* HDF file identifier */ gr_id, /* GR interface identifier */ ri1_id, /* raster image identifier */ start1[2], /* start position to write for each dimension */ edges1[2], /* number of elements to be written along each dimension */ ri2_id, /* raster image identifier */ start2[2], /* start position to write for each dimension */ edges2[2], /* number of elements to be written along each dimension */ dims_sizes[2], /* sizes of the two dimensions of the image array */ data_type, /* data type of the image data */ interlace_mode; /* interlace mode of the image */ int16 i, j; /* indices for the dimensions */ int16 image1_buf[Y1_LENGTH][X1_LENGTH][N1_COMPS]; /* data of first image */ char image2_buf[Y2_LENGTH][X2_LENGTH][N2_COMPS]; /* data of second image*/ /********************** End of variable declaration **********************/ /* * Open the HDF file for writing. */ file_id = Hopen (FILE_NAME, DFACC_WRITE, 0); /* * Initialize the GR interface. */ gr_id = GRstart (file_id); /* * Select the first raster image in the file. */ ri1_id = GRselect (gr_id, 0); /* * Fill the first image data buffer with values. */ for (i = 0; i < Y1_LENGTH; i++) { for (j = 0; j < X1_LENGTH; j++) { image1_buf[i][j][0] = 0; /* first component */ image1_buf[i][j][1] = 0; /* second component */ } } /* * Define the size of the data to be written, i.e., start from the origin * and go as long as the length of each dimension. */ start1[0] = start1[1] = 0; edges1[0] = X1_LENGTH; edges1[1] = Y1_LENGTH; /* * Write the data in the buffer into the image array. */ status = GRwriteimage (ri1_id, start1, NULL, edges1, (VOIDP)image1_buf); /* * Set the interlace mode and dimensions of the second image. */ data_type = DFNT_CHAR8; interlace_mode = MFGR_INTERLACE_PIXEL; dims_sizes[0] = X2_LENGTH; dims_sizes[1] = Y2_LENGTH; /* * Create the second image in the file. */ ri2_id = GRcreate (gr_id, IMAGE2_NAME, N2_COMPS, data_type, interlace_mode, dims_sizes); /* * Fill the second image data buffer with values. */ for (i = 0; i < Y2_LENGTH; i++) { for (j = 0; j < X2_LENGTH; j++) { image2_buf[i][j][0] = `A'; /* first component */ image2_buf[i][j][1] = `B'; /* second component */ image2_buf[i][j][2] = `C'; /* third component */ } } /* * Define the size of the data to be written, i.e., start from the origin * and go as long as the length of each dimension. */ for (i = 0; i < 2; i++) { start2[i] = 0; edges2[i] = dims_sizes[i]; } /* * Write the data in the buffer into the second image array. */ status = GRwriteimage (ri2_id, start2, NULL, edges2, (VOIDP)image2_buf); /* * Terminate access to the raster images and to the GR interface, and * close the HDF file. */ status = GRendaccess (ri1_id); status = GRendaccess (ri2_id); status = GRend (gr_id); status = Hclose (file_id); }modify_image.fprogram modify_image implicit none C C Parameter declaration C character*19 FILE_NAME character*13 IMAGE1_NAME integer X1_LENGTH integer Y1_LENGTH integer N1_COMPS character*13 IMAGE2_NAME integer X2_LENGTH integer Y2_LENGTH integer N2_COMPS C parameter (FILE_NAME = `General_RImages.hdf', + IMAGE1_NAME = `Image Array 1', + IMAGE2_NAME = `Image Array 2', + X1_LENGTH = 5, + Y1_LENGTH = 2, + N1_COMPS = 2, + X2_LENGTH = 6, + Y2_LENGTH = 4, + N2_COMPS = 3) integer DFACC_WRITE, DFNT_INT16, DFNT_CHAR8, + MFGR_INTERLACE_PIXEL parameter (DFACC_WRITE = 2, + DFNT_CHAR8 = 4, + DFNT_INT16 = 22, + MFGR_INTERLACE_PIXEL = 0) C C Function declaration C integer hopen, hclose integer mgstart, mgselct, mgcreat, mgwrimg, mgendac, mgend C C**** Variable declaration ******************************************* C integer status integer file_id integer gr_id, ri1_id, ri2_id, data_type, interlace_mode integer start1(2), stride1(2), edges1(2) integer start2(2), stride2(2), edges2(2), dim_sizes(2) integer i, j, k integer*2 image1_buf(N1_COMPS, X1_LENGTH, Y1_LENGTH) character image2_buf(N2_COMPS, X2_LENGTH, Y2_LENGTH) C C**** End of variable declaration ************************************ C C C Open the HDF file for writing. C file_id = hopen(FILE_NAME, DFACC_WRITE, 0) C C Initialize the GR interface. C gr_id = mgstart(file_id) C C Select the first raster image in the file. C ri1_id = mgselct(gr_id, 0) C C Fill the buffer with values. C do 20 i = 1, Y1_LENGTH do 10 j = 1, X1_LENGTH image1_buf(1,j,i) = 0 image1_buf(2,j,i) = 0 10 continue 20 continue C C Define the part of the data in the first image that will be overwritten C with the new values from image1_buf. C start1(1) = 0 start1(2) = 0 edges1(1) = X1_LENGTH edges1(2) = Y1_LENGTH stride1(1) = 1 stride1(2) = 1 C C Write the data in the buffer into the image array. C status = mgwrimg(ri1_id, start1, stride1, edges1, image1_buf) C C Set the number type, interlace mode, and dimensions of the second image. C data_type = DFNT_CHAR8 interlace_mode = MFGR_INTERLACE_PIXEL dim_sizes(1) = X2_LENGTH dim_sizes(2) = Y2_LENGTH C C Create the second image in the file. C ri2_id = mgcreat(gr_id, IMAGE2_NAME, N2_COMPS, data_type, + interlace_mode, dim_sizes) C C Fill the image data buffer with values. C do 60 i = 1, Y2_LENGTH do 50 j = 1, X2_LENGTH do 40 k = 1, N2_COMPS image2_buf(k,j,i) = char(65 + k - 1) 40 continue 50 continue 60 continue C C Define the size of the data to be written, i.e., start from the origin C and go as long as the length of each dimension. C start2(1) = 0 start2(2) = 0 edges2(1) = dim_sizes(1) edges2(2) = dim_sizes(2) stride2(1) = 1 stride2(2) = 1 C C Write the data in the buffer into the image array. C status = mgwrimg(ri2_id, start2, stride2, edges2, image2_buf) C C Terminate access to the raster images and to the GR interface, C and close the HDF file. C status = mgendac(ri1_id) status = mgendac(ri2_id) status = mgend(gr_id) status = hclose(file_id) endread_image.c#include "hdf.h" #define FILE_NAME "General_RImages.hdf" #define N_COMPS 2 #define X_LENGTH 10 /* number of columns of the entire image */ #define Y_LENGTH 5 /* number of rows of the entire image */ #define PART_COLS 2 /* number of columns read for partial image */ #define PART_ROWS 3 /* number of rows read for partial image */ #define SKIP_COLS 5 /* number of columns read for skipped image */ #define SKIP_ROWS 3 /* number of rows read for skipped image */ #define COLS_PART_START 3 /* starting column to read partial image */ #define ROWS_PART_START 1 /* starting row to read partial image */ #define COLS_SKIP_START 1 /* starting column to read skipped image */ #define ROWS_SKIP_START 0 /* starting row to read skipped image */ #define N_STRIDES 2 /* number of elements to skip on each dim. */ main( ) { /************************* Variable declaration **************************/ intn status; /* status for functions returning an intn */ int32 index; int32 file_id, gr_id, ri_id, start[2], /* start position to write for each dimension */ edges[2], /* number of elements to bewritten along each dimension */ stride[2], /* number of elements to skip on each dimension */ dim_sizes[2]; /* dimension sizes of the image array */ int16 entire_image[Y_LENGTH][X_LENGTH][N_COMPS], partial_image[PART_ROWS][PART_COLS][N_COMPS], skipped_image[SKIP_ROWS][SKIP_COLS][N_COMPS]; int32 i, j; /********************** End of variable declaration **********************/ /* * Open the HDF file for reading. */ file_id = Hopen (FILE_NAME, DFACC_READ, 0); /* * Initialize the GR interface. */ gr_id = GRstart (file_id); /* * Select the first raster image in the file. */ ri_id = GRselect (gr_id, 0); /* * Define the size of the data to be read, i.e., start from the origin * and go as long as the length of each dimension. */ start[0] = start[1] = 0; edges[0] = X_LENGTH; edges[1] = Y_LENGTH; /* * Read the data from the raster image array. */ status = GRreadimage (ri_id, start, NULL, edges, (VOIDP)entire_image); /* * Display only the first component of the image since the two components * have the same data in this example. */ printf ("First component of the entire image:\n"); for (i = 0; i < Y_LENGTH; i++) { for (j = 0; j < X_LENGTH; j++) printf ("%d ", entire_image[i][j][0]); printf ("\n"); } /* * Define the size of the data to be read. */ start[0] = COLS_PART_START; start[1] = ROWS_PART_START; edges[0] = PART_COLS; edges[1] = PART_ROWS; /* * Read a subset of the raster image array. */ status = GRreadimage (ri_id, start, NULL, edges, (VOIDP)partial_image); /* * Display the first component of the read sample. */ printf ("\nThree rows & two cols at 2nd row and 4th column"); printf (" of the first component:\n"); for (i = 0; i < PART_ROWS; i++) { for (j = 0; j < PART_COLS; j++) printf ("%d ", partial_image[i][j][0]); printf ("\n"); } /* * Define the size and the pattern to read the data. */ start[0] = COLS_SKIP_START; start[1] = ROWS_SKIP_START; edges[0] = SKIP_COLS; edges[1] = SKIP_ROWS; stride[0] = stride[1] = N_STRIDES; /* * Read all the odd rows and even columns of the image. */ status = GRreadimage (ri_id, start, stride, edges, (VOIDP)skipped_image); /* * Display the first component of the read sample. */ printf ("\nAll odd rows and even columns of the first component:\n"); for (i = 0; i < SKIP_ROWS; i++) { for (j = 0; j < SKIP_COLS; j++) printf ("%d ", skipped_image[i][j][0]); printf ("\n"); } /* * Terminate access to the raster image and to the GR interface, and * close the HDF file. */ status = GRendaccess (ri_id); status = GRend (gr_id); status = Hclose (file_id); }read_image.fprogram read_raster_image implicit none C C Parameter declaration C character*19 FILE_NAME integer X_LENGTH integer Y_LENGTH integer N_COMPS C parameter (FILE_NAME = `General_RImages.hdf', + X_LENGTH = 10, + Y_LENGTH = 5, + N_COMPS = 2) integer PART_COLS, PART_ROWS, SKIP_COLS, SKIP_ROWS integer COLS_PART_START, ROWS_PART_START integer COLS_SKIP_START, ROWS_SKIP_START integer N_STRIDES parameter (PART_COLS = 3, PART_ROWS = 2, + SKIP_COLS = 3, SKIP_ROWS = 5, + COLS_PART_START = 1, ROWS_PART_START = 3, + COLS_SKIP_START = 0, ROWS_SKIP_START = 1, + N_STRIDES = 2) integer DFACC_READ parameter (DFACC_READ = 1) C C Function declaration C integer hopen, hclose integer mgstart, mgselct, mgrdimg, mgendac, mgend C C**** Variable declaration ******************************************* C integer status integer file_id integer gr_id, ri_id integer start(2), stride(2), edges(2) integer i, j integer*2 entire_image(N_COMPS, X_LENGTH, Y_LENGTH) integer*2 partial_image(N_COMPS, PART_ROWS, PART_COLS) integer*2 skipped_image(N_COMPS, SKIP_ROWS, SKIP_COLS) C C**** End of variable declaration ************************************ C C C Open the HDF file for reading. C file_id = hopen(FILE_NAME, DFACC_READ, 0) C C Initialize the GR interface. C gr_id = mgstart(file_id) C C Select the first raster image in the file. C ri_id = mgselct(gr_id, 0) C C Define the size of the data to be read, i.e., start from the origin C and go as long as the length of each dimension. C start(1) = 0 start(2) = 0 edges(1) = X_LENGTH edges(2) = Y_LENGTH stride(1) = 1 stride(2) = 1 C C Read the data from the raster image array. C status = mgrdimg(ri_id, start, stride, edges, entire_image) C C Display only the first component of the image since the two components C have the same data in this example. C write(*,*) `First component of the entire image' write(*,*) do 10 i = 1, X_LENGTH write(*,1000) (entire_image(1,i,j), j = 1, Y_LENGTH) 10 continue write(*,*) C C Define the size of the data to be read. C start(1) = ROWS_PART_START start(2) = COLS_PART_START edges(1) = PART_ROWS edges(2) = PART_COLS stride(1) = 1 stride(2) = 1 C C Read a subset of the raster image array. C status = mgrdimg(ri_id, start, stride, edges, partial_image) C C Display only the first component of the read sample. C write(*,*) + `Two rows and three columns at 4th row and 2nd column', + ` of the first component' write(*,*) do 20 i = 1, PART_ROWS write(*,1000) (partial_image(1,i,j), j = 1, PART_COLS) 20 continue write(*,*) C C Define the size and the pattern to read the data. C start(1) = ROWS_SKIP_START start(2) = COLS_SKIP_START edges(1) = SKIP_ROWS edges(2) = SKIP_COLS stride(1) = N_STRIDES stride(2) = N_STRIDES C C Read all the odd rows and even columns of the image. C status = mgrdimg(ri_id, start, stride, edges, skipped_image) C C Display only the first component of the read sample. C write(*,*) `All even rows and odd columns of the first component' write(*,*) do 30 i = 1, SKIP_ROWS write(*,1000) (skipped_image(1,i,j), j = 1, SKIP_COLS) 30 continue write(*,*) C C Terminate access to the raster image and to the GR interface, C and close the HDF file. C status = mgendac(ri_id) status = mgend(gr_id) status = hclose(file_id) 1000 format(1x, 5(I4)) endimage_info.c#include "hdf.h" #define FILE_NAME "General_RImages.hdf" main( ) { /************************* Variable declaration **************************/ intn status; /* status for functions returning an intn */ int32 file_id, gr_id, ri_id, n_rimages, /* number of raster images in the file */ n_file_attrs, /* number of file attributes */ ri_index, /* index of a image */ dim_sizes[2], /* dimensions of an image */ n_comps, /* number of components an image contains */ interlace_mode, /* interlace mode of an image */ data_type, /* number type of an image */ n_attrs; /* number of attributes belong to an image */ char name[MAX_GR_NAME], /* name of an image */ *type_string, /* mapped text of a number type */ *interlace_string; /* mapped text of an interlace mode */ /********************** End of variable declaration **********************/ /* * Open the file for reading. */ file_id = Hopen (FILE_NAME, DFACC_READ, 0); /* * Initialize the GR interface. */ gr_id = GRstart (file_id); /* * Determine the contents of the file. */ status = GRfileinfo (gr_id, &n_rimages, &n_file_attrs); /* * For each image in the file, get and display the image information. */ printf ("RI# Name Components Type Interlace \ Dimensions Attributes\n\n"); for (ri_index = 0; ri_index < n_rimages; ri_index++) { ri_id = GRselect (gr_id, ri_index); status = GRgetiminfo (ri_id, name, &n_comps, &data_type, &interlace_mode, dim_sizes, &n_attrs); /* * Map the number type and interlace mode into text strings for output * readability. Note that, in this example, only two possible types * are considered because of the simplicity of the example. For real * problems, all possible types should be checked and, if reading the * data is desired, the size of the type must be determined based on the * machine where the program resides. */ if (data_type == DFNT_CHAR8) type_string = "Char8"; else if (data_type == DFNT_INT16) type_string = "Int16"; else type_string = "Unknown"; switch (interlace_mode) { case MFGR_INTERLACE_PIXEL: interlace_string = "MFGR_INTERLACE_PIXEL"; break; case MFGR_INTERLACE_LINE: interlace_string = "MFGR_INTERLACE_LINE"; break; case MFGR_INTERLACE_COMPONENT: interlace_string = "MFGR_INTERLACE_COMPONENT"; break; default: interlace_string = "Unknown"; break; } /* switch */ /* * Display the image information for the current raster image. */ printf ("%d %s %d %s %s %2d,%2d %d\n", ri_index, name, n_comps, type_string, interlace_string, dim_sizes[0], dim_sizes[1], n_attrs); /* * Terminate access to the current raster image. */ status = GRendaccess (ri_id); } /* * Terminate access to the GR interface and close the HDF file. */ status = GRend (gr_id); status = Hclose (file_id); }image_info.fprogram image_info implicit none C C Parameter declaration C character*19 FILE_NAME C parameter (FILE_NAME = `General_RImages.hdf') integer DFACC_READ parameter (DFACC_READ = 1) C C Function declaration C integer hopen, hclose integer mgstart, mgselct, mgfinfo, mggiinf, mgendac, mgend C C**** Variable declaration ******************************************* C integer status integer file_id, gr_id, ri_id integer n_rimages, n_file_attrs, ri_index integer n_comps, interlace_mode, n_attrs, data_type integer dim_sizes(2) character*10 type_string character*24 interlace_string character*64 name C C**** End of variable declaration ************************************ C C C Open the HDF file for reading. C file_id = hopen(FILE_NAME, DFACC_READ, 0) C C Initialize the GR interface. C gr_id = mgstart(file_id) C C Determine the contents of the file. C status = mgfinfo(gr_id, n_rimages, n_file_attrs) C C For each image in the file, get and display image information. C do 100 ri_index = 0, n_rimages-1 ri_id = mgselct(gr_id, ri_index) status = mggiinf(ri_id, name, n_comps, data_type, + interlace_mode, dim_sizes, n_attrs) C C Map the number type and interlace mode into text strings for C output readability. C if(data_type .eq. 4) then type_string = `DFNT_CHAR8' else if(data_type .eq. 22) then type_string = `DFNT_INT16' else type_string = `Unknown' endif if (interlace_mode .eq. 0) then interlace_string = `MFGR_INTERLACE_PIXEL' else if(interlace_mode .eq. 1) then interlace_string = `MFGR_INTERLACE_LINE' else if(interlace_mode .eq. 2) then interlace_string = `MFGR_INTERLACE_COMPONENT' else interlace_string = `Unknown' endif C C Display the image information for the current image. C write(*,*) `Image index: `, ri_index write(*,*) `Image name: `, name write(*,*) `Number of components: `, n_comps write(*,*) `Number type: `, type_string write(*,*) `Interlace mode: `, interlace_string write(*,*) `Dimnesions: `, dim_sizes(1), dim_sizes(2) write(*,*) `Number of image attributes: `, n_attrs write(*,*) C C Terminate access to the current raster image. C status = mgendac(ri_id) 100 continue C C Terminate access to the GR interface and close the HDF file. status = mgend(gr_id) status = hclose(file_id) endset_attribute.c#include "hdf.h" #define FILE_NAME "General_RImages.hdf" #define IMAGE_NAME "Image Array 2" #define F_ATT1_NAME "File Attribute 1" #define F_ATT2_NAME "File Attribute 2" #define RI_ATT1_NAME "Image Attribute 1" #define RI_ATT2_NAME "Image Attribute 2" #define F_ATT1_VAL "Contents of First FILE Attribute" #define F_ATT2_VAL "Contents of Second FILE Attribute" #define F_ATT1_N_VALUES 32 #define F_ATT2_N_VALUES 33 #define RI_ATT1_VAL "Contents of IMAGE's First Attribute" #define RI_ATT1_N_VALUES 35 #define RI_ATT2_N_VALUES 6 main( ) { /************************* Variable declaration **************************/ intn status; /* status for functions returning an intn */ int32 gr_id, ri_id, file_id, ri_index; int16 ri_attr_2[RI_ATT2_N_VALUES] = {1, 2, 3, 4, 5, 6}; /********************** End of variable declaration **********************/ /* * Open the HDF file. */ file_id = Hopen (FILE_NAME, DFACC_WRITE, 0); /* * Initialize the GR interface. */ gr_id = GRstart (file_id); /* * Set two file attributes to the file with names, data types, numbers of * values, and values of the attributes specified. */ status = GRsetattr (gr_id, F_ATT1_NAME, DFNT_CHAR8, F_ATT1_N_VALUES, (VOIDP)F_ATT1_VAL); status = GRsetattr (gr_id, F_ATT2_NAME, DFNT_CHAR8, F_ATT2_N_VALUES, (VOIDP)F_ATT2_VAL); /* * Obtain the index of the image named IMAGE_NAME. */ ri_index = GRnametoindex (gr_id, IMAGE_NAME); /* * Obtain the identifier of this image. */ ri_id = GRselect (gr_id, ri_index); /* * Set two attributes to the image with names, data types, numbers of * values, and values of the attributes specified. */ status = GRsetattr (ri_id, RI_ATT1_NAME, DFNT_CHAR8, RI_ATT1_N_VALUES, (VOIDP)RI_ATT1_VAL); status = GRsetattr (ri_id, RI_ATT2_NAME, DFNT_INT16, RI_ATT2_N_VALUES, (VOIDP)ri_attr_2); /* * Terminate access to the image and to the GR interface, and close the * HDF file. */ status = GRendaccess (ri_id); status = GRend (gr_id); status = Hclose (file_id); }set_attribute.fprogram set_attribute implicit none C C Parameter declaration C character*19 FILE_NAME character*13 IMAGE_NAME character*16 F_ATT1_NAME character*16 F_ATT2_NAME character*17 RI_ATT1_NAME character*17 RI_ATT2_NAME character*32 F_ATT1_VAL character*33 F_ATT2_VAL integer F_ATT1_N_VALUES integer F_ATT2_N_VALUES character*35 RI_ATT1_VAL integer RI_ATT1_N_VALUES integer RI_ATT2_N_VALUES C parameter (FILE_NAME = `General_RImages.hdf', + IMAGE_NAME = `Image Array 2', + F_ATT1_NAME = `File Attribute 1', + F_ATT2_NAME = `File Attribute 2', + RI_ATT1_NAME = `Image Attribute 1', + RI_ATT2_NAME = `Image Attribute 2', + F_ATT1_VAL = `Contents of First FILE Attribute', + F_ATT2_VAL = `Contents of Second FILE Attribute', + F_ATT1_N_VALUES = 32, + F_ATT2_N_VALUES = 33, + RI_ATT1_VAL = `Contents of IMAGE''s First Attribute', + RI_ATT1_N_VALUES = 35, + RI_ATT2_N_VALUES = 6) integer DFACC_WRITE, DFNT_INT16, DFNT_CHAR8 parameter (DFACC_WRITE = 2, + DFNT_CHAR8 = 4, + DFNT_INT16 = 22) C C Function declaration C integer hopen, hclose integer mgstart, mgscatt, mgsnatt , mgn2ndx, + mgselct, mgendac, mgend C C**** Variable declaration ******************************************* C integer status integer file_id, gr_id, ri_id, ri_index integer*2 ri_attr_2(RI_ATT2_N_VALUES) integer i do 10 i = 1, RI_ATT2_N_VALUES ri_attr_2(i) = i 10 continue C C**** End of variable declaration ************************************ C C C Open the HDF file. C file_id = hopen(FILE_NAME, DFACC_WRITE, 0) C C Initialize the GR interface. C gr_id = mgstart(file_id) C C Set two file attributes to the file with names, data type, numbers of C values, and values of attributes specified. C status = mgscatt(gr_id, F_ATT1_NAME, DFNT_CHAR8, + F_ATT1_N_VALUES, F_ATT1_VAL) status = mgscatt(gr_id, F_ATT2_NAME, DFNT_CHAR8, + F_ATT2_N_VALUES, F_ATT2_VAL) C C Obtain the index of the image named IMAGE_NAMR. C ri_index = mgn2ndx(gr_id, IMAGE_NAME) C C Obtain the identifier of this image. C ri_id = mgselct(gr_id, ri_index) C C Set two attributes of the image with names, data types, number of C values, and values of the attributes specified. C status = mgscatt(ri_id, RI_ATT1_NAME, DFNT_CHAR8, + RI_ATT1_N_VALUES, RI_ATT1_VAL) status = mgsnatt(ri_id, RI_ATT2_NAME, DFNT_INT16, + RI_ATT2_N_VALUES, ri_attr_2) C C Terminate access to the image and to the GR interface, C and close the HDF file. C status = mgendac(ri_id) status = mgend(gr_id) status = hclose(file_id) endget_attribute.c#include "hdf.h" #define FILE_NAME "General_RImages.hdf" #define RI_ATTR_NAME "Image Attribute 2" main( ) { /************************* Variable declaration **************************/ intn status; /* status for functions returning an intn */ int32 gr_id, ri_id, file_id, f_att_index, /* index of file attributes */ ri_att_index, /* index of raster image attributes */ data_type, /* image data type */ n_values, /* number of values in an attribute */ value_index, /* index of values in an attribute */ n_rimages, /* number of raster images in the file */ n_file_attrs; /* number of file attributes */ char attr_name[MAX_GR_NAME]; /* buffer to hold the attribute name */ VOIDP data_buf; /* buffer to hold the attribute values */ int16 *int_ptr; /* int16 pointer to point to a void data buffer */ char8 *char_ptr; /* char8 pointer to point to a void data buffer */ /********************** End of variable declaration **********************/ /* * Open the HDF file. */ file_id = Hopen (FILE_NAME, DFACC_READ, 0); /* * Initialize the GR interface. */ gr_id = GRstart (file_id); /* * Determine the number of attributes in the file. */ status = GRfileinfo (gr_id, &n_rimages, &n_file_attrs); if (status != FAIL && n_file_attrs > 0) { for (f_att_index = 0; f_att_index < n_file_attrs; f_att_index++) { /* * Get information about the current file attribute. */ status = GRattrinfo (gr_id, f_att_index, attr_name, &data_type, &n_values); /* * Allocate a buffer to hold the file attribute data. In this example, * knowledge about the data type is assumed to be available from * the previous example for simplicity. In reality, the size * of the type must be determined based on the machine where the * program resides. */ if (data_type == DFNT_CHAR8) { data_buf = malloc (n_values * sizeof (char8)); if (data_buf == NULL) { printf ("Unable to allocate space for attribute data.\n"); exit (1); } } else { printf ("Unable to determine data type to allocate data buffer.\n"); exit (1); } /* * Read and display the attribute values. */ status = GRgetattr (gr_id, f_att_index, (VOIDP)data_buf); char_ptr = (char8 *) data_buf; printf ("Attribute %s: ", attr_name); for (value_index = 0; value_index < n_values; value_index++) printf ("%c", char_ptr[value_index]); printf ("\n"); /* * Free the space allocated for the data buffer. */ free (data_buf); } /* for */ } /* if */ /* * Select the second image in the file. */ ri_id = GRselect (gr_id, 1); /* * Find the image attribute named RI_ATTR_NAME. */ ri_att_index = GRfindattr (ri_id, RI_ATTR_NAME); /* * Get information about the attribute. */ status = GRattrinfo (ri_id, ri_att_index, attr_name, &data_type, &n_values); /* * Allocate a buffer to hold the file attribute data. As mentioned above, * knowledge about the data type is assumed to be available from * the previous example for simplicity. In reality, the size of the * type must be determined based on the machine where the program resides. */ if (data_type == DFNT_INT16) data_buf = malloc (n_values * sizeof (int16)); /* * Read and display the attribute values. */ status = GRgetattr (ri_id, ri_att_index, (VOIDP)data_buf); printf ("\nAttribute %s: ", RI_ATTR_NAME); int_ptr = (int16 *)data_buf; for (value_index = 0; value_index < n_values; value_index++) printf ("%d ", int_ptr[value_index]); printf ("\n"); /* * Free the space allocated for the data buffer. */ free (data_buf); /* * Terminate access to the raster image and to the GR interface, and * close the file. */ status = GRendaccess (ri_id); status = GRend (gr_id); status = Hclose (file_id); }get_attribute.fprogram get_attribute implicit none C C Parameter declaration C character*19 FILE_NAME character*17 RI_ATTR_NAME C parameter (FILE_NAME = `General_RImages.hdf', + RI_ATTR_NAME = `Image Attribute 2') integer DFACC_READ, DFNT_INT16, DFNT_CHAR8 parameter (DFACC_READ = 1, + DFNT_CHAR8 = 4, + DFNT_INT16 = 22) C C Function declaration C integer hopen, hclose integer mgstart, mgfinfo, mgatinf, mggcatt, mggnatt , mgfndat, + mgselct, mgendac, mgend C C**** Variable declaration ******************************************* C integer status integer file_id, gr_id, ri_id integer f_att_index, ri_att_index, data_type, n_values integer n_rimages, n_file_attrs integer*2 int_buf(10) character*17 attr_name character*80 char_buf integer i C C**** End of variable declaration ************************************ C C C Open the HDF file. C file_id = hopen(FILE_NAME, DFACC_READ, 0) C C Initialize the GR interface. C gr_id = mgstart(file_id) C C Determine the number of attributes in the file. C status = mgfinfo(gr_id, n_rimages, n_file_attrs) if ((status .NE. -1) .AND. (n_file_attrs .GT. 0)) then do 10 f_att_index = 0, n_file_attrs-1 C C Get information about the current file attribute. C status = mgatinf(gr_id, f_att_index, attr_name, data_type, + n_values) C C Check whether data type is DFNT_CHAR8 in order to use allocated buffer. C if(data_type .NE. DFNT_CHAR8) then write(*,*) + `Unable to determine data type to use allocated buffer' else C C Read and display the attribute values. C status = mggcatt(gr_id, f_att_index, char_buf) write(*,*) `Attribute `, attr_name, ` : `, + char_buf(1:n_values) endif 10 continue endif C C Select the second image in the file. C ri_id = mgselct(gr_id, 1) C C Find the image attribute named RI_ATTR_NAME. C ri_att_index = mgfndat(ri_id, RI_ATTR_NAME) C C Get information about the attribute. C status = mgatinf(ri_id, ri_att_index, attr_name, data_type, + n_values) C C Read and display attribute values. C status = mggnatt(ri_id, ri_att_index, int_buf) write(*,*) `Attributes :', (int_buf(i), i = 1, n_values) C C Terminate access to the image and to the GR interface, C and close the HDF file. C status = mgendac(ri_id) status = mgend(gr_id) status = hclose(file_id) endwrite_palette.c#include "hdf.h" #define FILE_NAME "Image_with_Palette.hdf" #define NEW_IMAGE_NAME "Image with Palette" #define N_COMPS_IMG 2 /* number of image components */ #define X_LENGTH 5 #define Y_LENGTH 5 #define N_ENTRIES 256 /* number of entries in the palette */ #define N_COMPS_PAL 3 /* number of palette's components */ main( ) { /************************* Variable declaration **************************/ intn status, /* status for functions returning an intn */ i, j; int32 file_id, gr_id, ri_id, pal_id, interlace_mode, start[2], /* holds where to start to write for each dimension */ edges[2], /* holds how long to write for each dimension */ dim_sizes[2]; /* sizes of the two dimensions of the image array */ uint8 image_buf[Y_LENGTH][X_LENGTH][N_COMPS_IMG]; /* data of first image */ uint8 palette_buf[N_ENTRIES][N_COMPS_PAL]; /********************** End of variable declaration **********************/ /* * Open the HDF file. */ file_id = Hopen (FILE_NAME, DFACC_CREATE, 0); /* * Initialize the GR interface. */ gr_id = GRstart (file_id); /* * Define the dimensions and interlace mode of the image. */ dim_sizes[0] = X_LENGTH; dim_sizes[1] = Y_LENGTH; interlace_mode = MFGR_INTERLACE_PIXEL; /* * Create the image named NEW_IMAGE_NAME. */ ri_id = GRcreate (gr_id, NEW_IMAGE_NAME, N_COMPS_IMG, DFNT_UINT8, interlace_mode, dim_sizes); /* * Fill the image data buffer with values. */ for (i = 0; i < Y_LENGTH; i++) { for (j = 0; j < X_LENGTH; j++) { image_buf[i][j][0] = (i + j) + 1; image_buf[i][j][1] = (i + j) + 2; } } /* * Define the size of the data to be written, i.e., start from the origin * and go as long as the length of each dimension. */ start[0] = start[1] = 0; edges[0] = X_LENGTH; edges[1] = Y_LENGTH; /* * Write the data in the buffer into the image array. */ status = GRwriteimage (ri_id, start, NULL, edges, (VOIDP)image_buf); /* * Initialize the palette to grayscale. */ for (i = 0; i < N_ENTRIES; i++) { palette_buf[i][0] = i; palette_buf[i][1] = i; palette_buf[i][2] = i; } /* * Define palette interlace mode. */ interlace_mode = MFGR_INTERLACE_PIXEL; /* * Get the identifier of the palette attached to the image NEW_IMAGE_NAME. */ pal_id = GRgetlutid (ri_id, 0); /* * Write data to the palette. */ status = GRwritelut (pal_id, N_COMPS_PAL, DFNT_UINT8, interlace_mode, N_ENTRIES, (VOIDP)palette_buf); /* * Terminate access to the image and to the GR interface, and * close the HDF file. */ status = GRendaccess (ri_id); status = GRend (gr_id); status = Hclose (file_id); }write_palette.fprogram write_palette implicit none C C Parameter declaration C character*22 FILE_NAME character*18 NEW_IMAGE_NAME integer X_LENGTH integer Y_LENGTH integer N_ENTRIES integer N_COMPS_IMG integer N_COMPS_PAL C parameter (FILE_NAME = `Image_with_Palette.hdf', + NEW_IMAGE_NAME = `Image with Palette', + X_LENGTH = 5, + Y_LENGTH = 5, + N_ENTRIES = 256, + N_COMPS_IMG = 2, + N_COMPS_PAL = 3) integer DFACC_CREATE, DFNT_CHAR8, DFNT_UINT8, MFGR_INTERLACE_PIXEL parameter (DFACC_CREATE = 4, + DFNT_CHAR8 = 4, + DFNT_UINT8 = 21, + MFGR_INTERLACE_PIXEL = 0) C C Function declaration C integer hopen, hclose integer mgstart, mgcreat, mgwcimg, mggltid, mgwclut, + mgendac, mgend C C**** Variable declaration ******************************************* C integer file_id, gr_id, ri_id, pal_id integer interlace_mode integer start(2), stride(2), edges(2), dim_sizes(2) integer status integer i, j character image_buf(N_COMPS_IMG, X_LENGTH, Y_LENGTH) character palette_buf(N_COMPS_PAL, N_ENTRIES) C C**** End of variable declaration ************************************ C C C Create and open the file. C file_id = hopen(FILE_NAME, DFACC_CREATE, 0) C C Initialize the GR interface. C gr_id = mgstart(file_id) C C Define interlace mode and dimensions of the image. C interlace_mode = MFGR_INTERLACE_PIXEL dim_sizes(1) = X_LENGTH dim_sizes(2) = Y_lENGTH C C Create the raster image array. C ri_id = mgcreat(gr_id, NEW_IMAGE_NAME, N_COMPS_IMG, DFNT_CHAR8, + interlace_mode, dim_sizes) C C Fill the image data buffer with values. C do 20 i = 1, Y_LENGTH do 10 j = 1, X_LENGTH image_buf(1,j,i) = char(i + j - 1 ) image_buf(2,j,i) = char(i + j) 10 continue 20 continue C C Define the size of the data to be written, i.e., start from the origin C and go as long as the length of each dimension. 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 in the buffer into the image array. C status = mgwcimg(ri_id, start, stride, edges, image_buf) C C Initilaize the palette buffer to grayscale. C do 40 i = 1, N_ENTRIES do 30 j = 1, N_COMPS_PAL palette_buf(j,i) = char(i) 30 continue 40 continue C C Get the identifier of the palette attached to the image NEW_IMAGE_NAME. C pal_id = mggltid(ri_id, 0) C C Set palette interlace mode. C interlace_mode = MFGR_INTERLACE_PIXEL C C Write data to the palette. C status = mgwclut(pal_id, N_COMPS_PAL, DFNT_UINT8, interlace_mode, + N_ENTRIES, palette_buf) C C Terminate access to the raster image and to the GR interface, C and close the HDF file. C status = mgendac(ri_id) status = mgend(gr_id) status = hclose(file_id) endread_palette.c#include "hdf.h" #define FILE_NAME "Image_with_Palette.hdf" #define IMAGE_NAME "Image with Palette" #define N_ENTRIES 256 /* number of elements of each color */ main( ) { /************************* Variable declaration **************************/ intn status, /* status for functions returning an intn */ i, j; int32 file_id, gr_id, ri_id, pal_id, ri_index; int32 data_type, n_comps, n_entries, interlace_mode; uint8 palette_data[N_ENTRIES][3]; /* static because of fixed size */ /************************* Variable declaration **************************/ /* * Open the file. */ file_id = Hopen (FILE_NAME, DFACC_READ, 0); /* * Initiate the GR interface. */ gr_id = GRstart (file_id); /* * Get the index of the image IMAGR_NAME. */ ri_index = GRnametoindex (gr_id, IMAGE_NAME); /* * Get image identifier. */ ri_id = GRselect (gr_id, ri_index); /* * Get the identifier of the palette attached to the image. */ pal_id = GRgetlutid (ri_id, ri_index); /* * Obtain and display information about the palette. */ status = GRgetlutinfo (pal_id, &n_comps, &data_type, &interlace_mode, &n_entries); printf ("Palette: %d components; %d entries\n", n_comps, n_entries); /* * Read the palette data. */ status = GRreadlut (pal_id, (VOIDP)palette_data); /* * Display the palette data. Recall that HDF supports only 256 colors. * Each color is defined by its 3 components. Therefore, * verifying the value of n_entries and n_comps is not necessary and * the buffer to hold the palette data can be static. However, * if more values or colors are added to the model, these parameters * must be checked to allocate sufficient space when reading a palette. */ printf (" Palette Data: \n"); for (i=0; i< n_entries; i++) { for (j = 0; j < n_comps; j++) printf ("%i ", palette_data[i][j]); printf ("\n"); } printf ("\n"); /* * Terminate access to the image and to the GR interface, and * close the HDF file. */ status = GRendaccess (ri_id); status = GRend (gr_id); status = Hclose (file_id); }read_palette.fprogram read_palette implicit none C C Parameter declaration C character*22 FILE_NAME character*18 IMAGE_NAME integer N_ENTRIES integer N_COMPS_PAL C parameter (FILE_NAME = `Image_with_Palette.hdf', + IMAGE_NAME = `Image with Palette', + N_COMPS_PAL = 3, + N_ENTRIES = 256) integer DFACC_READ, DFNT_CHAR8, DFNT_UINT8, MFGR_INTERLACE_PIXEL parameter (DFACC_READ = 1, + DFNT_CHAR8 = 4, + DFNT_UINT8 = 21, + MFGR_INTERLACE_PIXEL = 0) C C Function declaration C integer hopen, hclose integer mgstart, mgn2ndx, mgselct, mggltid, mgglinf, + mgrclut, mgendac, mgend C C**** Variable declaration ******************************************* C integer file_id, gr_id, ri_id, ri_index, pal_id, pal_index integer interlace_mode integer data_type, n_comps, n_entries_out integer status integer i, j character palette_data(N_COMPS_PAL, N_ENTRIES) C C**** End of variable declaration ************************************ C C C Open the file. C file_id = hopen(FILE_NAME, DFACC_READ, 0) C C Initialize the GR interface. C gr_id = mgstart(file_id) C C Get the index of the image IMAGE_NAME. C ri_index = mgn2ndx(gr_id, IMAGE_NAME) C C Get the image identifier. C ri_id = mgselct(gr_id, 0) C C Get the identifier of the palette attached to the image. C pal_index = 0 pal_id = mggltid(ri_id, pal_index) C C Obtain information about the palette. C status = mgglinf(pal_id, n_comps, data_type, interlace_mode, + n_entries_out) write(*,*) ` Palette: `, n_comps, ` components; `, + n_entries_out, ` entries' C C Read the palette. C status = mgrclut(pal_id, palette_data) C C Display the palette data. C write(*,*) "Palette data" do 10 i = 1, n_entries_out write(*,*) (ichar(palette_data(j,i)), j = 1, n_comps) 10 continue C C Terminate access to the raster image and to the GR interface, C and close the HDF file. C status = mgendac(ri_id) status = mgend(gr_id) status = hclose(file_id) end
HDF4.2r4 - February 2009 Copyright |
The HDF Group www.hdfgroup.org ![]() |