[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.f
program 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)
end
modify_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.f
program 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)
end
read_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.f
program 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))
end
image_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.f
program 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)
end
set_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.f
program 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)
end
get_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.f
program 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)
end
write_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.f
program 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)
end
read_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.f
program 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
[Top] [Prev] [Next]
hdfhelp@ncsa.uiuc.edu
HDF User's Guide - 07/21/98, NCSA HDF
Development Group.