[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 - 05/19/99, NCSA HDF Development Group.