int main(void)
{
hid_t fid;
int i, j, n, space;
unsigned char buf [ WIDTH*HEIGHT ];
unsigned char pal[ PAL_ENTRIES * 3 ]; /* palette array */
hsize_t pal_dims[2] = {PAL_ENTRIES,3}; /* palette dimensions */
hsize_t width = WIDTH;
hsize_t height = HEIGHT;
/* create a file */
if ((fid = H5Fcreate(FILENAME, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT))<0)
return 1;
/* create an image */
space = WIDTH*HEIGHT / PAL_ENTRIES;
for (i=0, j=0, n=0; i < WIDTH*HEIGHT; i++, j++ )
{
buf[i] = n;
if ( j > space )
{
n++;
j=0;
}
}
/* make the image */
if (H5IMmake_image_8bit( fid, IMAGE1_NAME, width, height, buf )<0)
return 1;
/*-------------------------------------------------------------------------
* define a palette, blue to red tones
*-------------------------------------------------------------------------
*/
for ( i=0, n=0; i<PAL_ENTRIES*3; i+=3, n++)
{
pal[i] =n; /* red */
pal[i+1]=0; /* green */
pal[i+2]=255-n; /* blue */
}
/* make a palette */
if (H5IMmake_palette( fid, PAL_NAME, pal_dims, pal )<0)
return 1;
/* attach the palette to the image */
if (H5IMlink_palette( fid, IMAGE1_NAME, PAL_NAME )<0)
return 1;
if(H5Fclose(fid)<0)
return 1;
return 0;
}
int main( void )
{
hid_t file_id;
herr_t status;
hsize_t pal_dims[] = {PAL_ENTRIES,3};
size_t i, j;
int n, space;
unsigned char pal[PAL_ENTRIES*3] = { /* create a palette with 9 colors */
0,0,168, /* dark blue */
0,0,252, /* blue */
0,168,252, /* ocean blue */
84,252,252, /* light blue */
168,252,168, /* light green */
0,252,168, /* green */
252,252,84, /* yellow */
252,168,0, /* orange */
252,0,0}; /* red */
/* create an image of 9 values divided evenly by the array */
space = WIDTH*HEIGHT / PAL_ENTRIES;
for (i=0, j=0, n=0; i < WIDTH*HEIGHT; i++, j++ )
{
buf[i] = n;
if ( j > space )
{
n++;
j=0;
}
if (n>PAL_ENTRIES-1) n=0;
}
/* create a new HDF5 file using default properties. */
file_id = H5Fcreate( "ex_image1.h5", H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT );
/* make the image */
status = H5IMmake_image_8bit( file_id, "image1", WIDTH, HEIGHT, buf );
/* make a palette */
status = H5IMmake_palette( file_id, "pallete", pal_dims, pal );
/* attach the palette to the image */
status = H5IMlink_palette( file_id, "image1", "pallete" );
/* close the file. */
status = H5Fclose( file_id );
return 0;
}
static int test_simple(void)
{
hsize_t width = WIDTH;
hsize_t height = HEIGHT;
hsize_t planes;
hid_t fid;
int i, j, n, space;
hsize_t u;
char interlace[20];
hssize_t npals;
/* 8-bit image */
unsigned char *buf1 = NULL;
unsigned char pal[ PAL_ENTRIES * 3 ]; /* palette array */
hsize_t pal_dims[2] = {PAL_ENTRIES,3}; /* palette dimensions */
/* 24-bit image */
unsigned char *buf2 = NULL;
/* read data */
unsigned char *buf1_out = NULL;
unsigned char *buf2_out = NULL;
unsigned char pal_out[ PAL_ENTRIES * 3 ]; /* palette array */
hsize_t pal_dims_out[2]; /* palette dimensions */
/* Allocate image buffers */
buf1 = (unsigned char *)HDmalloc(WIDTH * HEIGHT);
HDassert(buf1);
buf2 = (unsigned char *)HDmalloc(WIDTH * HEIGHT * 3);
HDassert(buf2);
buf1_out = (unsigned char *)HDmalloc(WIDTH * HEIGHT);
HDassert(buf1_out);
buf2_out = (unsigned char *)HDmalloc(WIDTH * HEIGHT * 3);
HDassert(buf2_out);
/* create an image */
space = WIDTH*HEIGHT / PAL_ENTRIES;
for (i=0, j=0, n=0; i < WIDTH*HEIGHT; i++, j++ )
{
buf1[i] = (unsigned char)n;
if ( j > space )
{
n++;
j=0;
}
}
/* create an image */
space = WIDTH*HEIGHT / 256;
for (i=0, j=0, n=0; i < WIDTH*HEIGHT*3; i+=3, j++ )
{
buf2[i] = (unsigned char)n;
buf2[i+1] = 0;
buf2[i+2] = (unsigned char)(255 - n);
if ( j > space )
{
n++;
j=0;
}
}
/*-------------------------------------------------------------------------
* define a palette, blue to red tones
*-------------------------------------------------------------------------
*/
for ( i=0, n=0; i<PAL_ENTRIES*3; i+=3, n++)
{
pal[i] =(unsigned char)n; /* red */
pal[i+1]=0; /* green */
pal[i+2]=(unsigned char)(255 - n); /* blue */
}
/* Create a new HDF5 file using default properties. */
fid = H5Fcreate(FILE_NAME, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT );
/*-------------------------------------------------------------------------
* Indexed image test
*-------------------------------------------------------------------------
*/
TESTING("indexed image");
/* Write image */
if ( H5IMmake_image_8bit( fid, IMAGE1_NAME, width, height, buf1 ) < 0 )
goto out;
/* Make a palette */
if ( H5IMmake_palette( fid, PAL_NAME, pal_dims, pal ) < 0 )
goto out;
/* Attach a palette to the image dataset */
if ( H5IMlink_palette( fid, IMAGE1_NAME, PAL_NAME ) < 0 )
goto out;
/* Read image */
if ( H5IMget_image_info( fid, IMAGE1_NAME, &width, &height, &planes, interlace, &npals ) < 0 )
goto out;
if ( H5IMread_image( fid, IMAGE1_NAME, buf1_out ) < 0 )
goto out;
for (u = 0; u < height*width*planes; u++)
{
if ( buf1[u] != buf1_out[u] )
goto out;
}
PASSED();
/*-------------------------------------------------------------------------
* True color image test
*-------------------------------------------------------------------------
*/
TESTING("true color image");
/* Write image */
if ( H5IMmake_image_24bit( fid, IMAGE2_NAME, width, height, "INTERLACE_PIXEL", buf2 ) )
goto out;
/* Read image */
if ( H5IMget_image_info( fid, IMAGE2_NAME, &width, &height, &planes, interlace, &npals ) < 0 )
goto out;
if ( H5IMread_image( fid, IMAGE2_NAME, buf2_out ) < 0 )
goto out;
for (u = 0; u < height*width*planes; u++)
{
if ( buf2[u] != buf2_out[u] )
goto out;
}
PASSED();
/*-------------------------------------------------------------------------
* H5IMget_npalettes test
*-------------------------------------------------------------------------
*/
TESTING("pallete functions");
if ( H5IMget_npalettes( fid, IMAGE1_NAME, &npals ) < 0 )
goto out;
/*-------------------------------------------------------------------------
* H5IMget_palette_info test
*-------------------------------------------------------------------------
*/
if ( H5IMget_palette_info( fid, IMAGE1_NAME, 0, pal_dims_out ) < 0 )
goto out;
for (i = 0; i < 2; i++)
{
if ( pal_dims[i] != pal_dims_out[i] )
goto out;
}
/*-------------------------------------------------------------------------
* H5IMget_palette test
*-------------------------------------------------------------------------
*/
if ( H5IMget_palette( fid, IMAGE1_NAME, 0, pal_out ) < 0 )
goto out;
for (i = 0; i < PAL_ENTRIES * 3; i++)
{
if ( pal[i] != pal_out[i] )
goto out;
}
/*-------------------------------------------------------------------------
* H5IMis_image test
*-------------------------------------------------------------------------
*/
if ( H5IMis_image( fid, IMAGE1_NAME ) < 0 )
goto out;
if ( H5IMis_image( fid, IMAGE2_NAME ) < 0 )
goto out;
/*-------------------------------------------------------------------------
* H5IMis_palette test
*-------------------------------------------------------------------------
*/
if ( H5IMis_palette( fid, PAL_NAME ) < 0 )
goto out;
/*-------------------------------------------------------------------------
* end tests
*-------------------------------------------------------------------------
*/
if(buf1)
HDfree(buf1);
if(buf2)
HDfree(buf2);
if(buf1_out)
HDfree(buf1_out);
if(buf2_out)
HDfree(buf2_out);
/* Close the file. */
if(H5Fclose( fid ) < 0)
goto out;
PASSED();
return 0;
/* error zone, gracefully close */
out:
if(buf1)
HDfree(buf1);
if(buf2)
HDfree(buf2);
if(buf1_out)
HDfree(buf1_out);
if(buf2_out)
HDfree(buf2_out);
H5E_BEGIN_TRY {
H5Fclose(fid);
} H5E_END_TRY;
H5_FAILED();
return FAIL;
}
static int test_generate(void)
{
hid_t fid;
hsize_t pal_dims[2] = { 256, 3 };
float *data;
int imax, jmax, kmax;
int n_elements;
float valex, xmin, xmax, value;
FILE *f = NULL;
char *srcdir = getenv("srcdir"); /* the source directory */
char data_file[512]=""; /* buffer to hold name of existing data file */
int i;
int retval = FAIL;
/* create a file using default properties */
if ((fid=H5Fcreate(FILE3,H5F_ACC_TRUNC,H5P_DEFAULT,H5P_DEFAULT))<0)
goto out;
printf("Testing read and process data and make indexed images\n");
/*-------------------------------------------------------------------------
* compose the name of the file to open, using the srcdir, if appropriate
*-------------------------------------------------------------------------
*/
if ( srcdir )
{
HDstrcpy(data_file, srcdir);
HDstrcat(data_file, "/");
}
HDstrcat(data_file,DATA_FILE4);
/*-------------------------------------------------------------------------
* read data; the file data format is described below
*-------------------------------------------------------------------------
*/
f = HDfopen( data_file, "r" ) ;
if ( f == NULL )
{
printf( "Could not find file %s. Try set $srcdir \n", data_file );
goto out;
}
/*
!The first line of the ASCII file contains the dimension of the array :
! IMAX, JMAX, KMAX. The integers are stored with the FORTRAN format I5.
!The second line contains the exclusion value, the minimum and the maximum value of this
! file. These numbers are stored with the FORTRAN format E12.5.
! The remaining lines contains the data of the array, with 5 numbers per line
! (except the last line for each I-line).
! The array is stored in horizontal slices from sea surface to sea bottom and from
! north to south. So the indexes go from :
!
! DO K = KMAX to 1
! DO J = JMAX to 1
! DO I = 1 to IMAX
! read
! OD
! OD
! OD
!
! ____________________________
! / /| (imax,jmax,kmax)
! / sea surface / |
! / / |
! /__________________________ / |
! | | |
! | | | (imax,jmax,1) n
! | | / /
! | | / /
! ^ j | | / w <-----o-----> e
! k | / |__________________________|/ /
! | / (imax,1,1) /
! |----------> s
! i
!
*/
fscanf( f, "%d %d %d", &imax, &jmax, &kmax );
fscanf( f, "%f %f %f", &valex, &xmin, &xmax );
/* Sanity check on scanned-in values */
if(imax < 1 || jmax < 1 || kmax < 1)
goto out;
/* Test product for integer overflow */
if(imax > INT_MAX / jmax)
goto out;
if(imax * jmax > INT_MAX / kmax)
goto out;
n_elements = imax * jmax * kmax;
/* Test buffer sizes for overflow */
if(n_elements > INT_MAX / (int)sizeof(unsigned char))
goto out;
if(n_elements > INT_MAX / (int)sizeof(float))
goto out;
data = (float *)HDmalloc((size_t)n_elements * sizeof(float));
if(NULL == data)
goto out;
image_data = (unsigned char *)HDmalloc((size_t)n_elements * sizeof(unsigned char));
if(NULL == image_data)
goto out;
for ( i = 0; i < n_elements; i++ )
{
fscanf( f, "%f ", &value );
data[i] = value;
}
HDfclose(f);
f = NULL;
/*-------------------------------------------------------------------------
* transform the data from floating point to unsigned char
* we are processing all the data here
*-------------------------------------------------------------------------
*/
TESTING2("make indexed image from all the data");
for ( i = 0; i < n_elements; i++ )
image_data[i] = (unsigned char)(( 255 * (data[i] - xmin ) ) / (xmax - xmin ));
/* Make the image */
if ((H5IMmake_image_8bit(fid,"All data",(hsize_t)imax,(hsize_t)jmax,image_data))<0)
goto out;
PASSED();
/*-------------------------------------------------------------------------
* transform the data from floating point to unsigned char
* here we just process the land data
*-------------------------------------------------------------------------
*/
TESTING2("make indexed image from land data");
for ( i = 0; i < n_elements; i++ )
{
if ( data[i] < 0 )
image_data[i] = 0;
else
image_data[i] = (unsigned char)(( 255 * (data[i] ) ) / xmax );
}
/* make the image */
if ((H5IMmake_image_8bit(fid,"Land data",(hsize_t)imax,(hsize_t)jmax,image_data))<0)
goto out;
PASSED();
/*-------------------------------------------------------------------------
* transform the data from floating point to unsigned char
* here we just process the sea data
*-------------------------------------------------------------------------
*/
TESTING2("make indexed image from sea data");
for ( i = 0; i < n_elements; i++ )
{
if ( data[i] > 0 )
image_data[i] = 0;
else
image_data[i] = (unsigned char)(( 255 * (data[i] - xmin ) ) / xmin );
}
/* make the image */
if ((H5IMmake_image_8bit(fid,"Sea data",(hsize_t)imax,(hsize_t)jmax,image_data))<0)
goto out;
PASSED();
/*-------------------------------------------------------------------------
* make a palette and attach it to the datasets
*-------------------------------------------------------------------------
*/
TESTING2("attaching palettes");
/* make a palette */
if ((H5IMmake_palette(fid,PAL1_NAME,pal_dims,pal_rgb))<0)
goto out;
/* attach the palette to the image datasets */
if ((H5IMlink_palette(fid,"All data",PAL1_NAME))<0)
goto out;
if ((H5IMlink_palette(fid,"Land data",PAL1_NAME))<0)
goto out;
if ((H5IMlink_palette(fid,"Sea data",PAL1_NAME))<0)
goto out;
PASSED();
/*-------------------------------------------------------------------------
* close
*-------------------------------------------------------------------------
*/
if (H5Fclose(fid)<0)
goto out;
/* Release memory buffers */
HDfree(data);
HDfree(image_data);
/* Indicate success */
return 0;
/* error zone, gracefully close */
out:
/* Release memory buffers */
if(data)
HDfree(data);
if(image_data)
HDfree(image_data);
H5E_BEGIN_TRY {
H5Fclose(fid);
} H5E_END_TRY;
if(f)
HDfclose(f);
H5_FAILED();
return retval;
}
static int test_data(void)
{
hid_t fid;
hsize_t pal_dims[2];
hsize_t width;
hsize_t height;
unsigned char pal[256*3]; /* buffer to hold an HDF5 palette */
rgb_t rgb[256]; /* buffer to hold a .pal file palette */
int i, n;
/* create a file using default properties */
if ((fid=H5Fcreate(FILE2,H5F_ACC_TRUNC,H5P_DEFAULT,H5P_DEFAULT))<0)
goto out;
printf("Testing read ascii image data and generate images\n");
/*-------------------------------------------------------------------------
* read 8bit image data
*-------------------------------------------------------------------------
*/
TESTING2("make indexed image");
/* read first data file */
if (read_data(DATA_FILE1,&width,&height)<0)
goto out;
/* make an image */
if (H5IMmake_image_8bit(fid,IMAGE1_NAME,width,height,image_data)<0)
goto out;
PASSED();
TESTING2("attaching palettes");
/*-------------------------------------------------------------------------
* palette #1. rainbow palette. data is contained in "pal_rgb.h"
*-------------------------------------------------------------------------
*/
/* initialize the palette data */
pal_dims[0] = 256;
pal_dims[1] = 3;
/* make a palette */
if (H5IMmake_palette(fid,PAL1_NAME,pal_dims,pal_rgb)<0)
goto out;
/* attach a palette to the image dataset */
if (H5IMlink_palette(fid,IMAGE1_NAME,PAL1_NAME)<0)
goto out;
/*-------------------------------------------------------------------------
* palette #2. sepia palette.
* read a PAL file and attach the palette to the HDF5 file
*-------------------------------------------------------------------------
*/
/* read a PAL file */
if (read_palette(PAL2_FILE, rgb, (sizeof(rgb) / sizeof(rgb[0]))) < 0)
goto out;
/* transfer to the HDF5 buffer */
for ( i=0, n=0; i<256*3; i+=3, n++)
{
pal[i] =rgb[n].r;
pal[i+1]=rgb[n].g;
pal[i+2]=rgb[n].b;
}
/* make a palette */
if (H5IMmake_palette(fid,PAL2_NAME,pal_dims,pal)<0)
goto out;
/* attach the palette to the image dataset */
if (H5IMlink_palette(fid,IMAGE1_NAME,PAL2_NAME)<0)
goto out;
/*-------------------------------------------------------------------------
* palette #3. earth palette.
* read a PAL file and attach the palette to the HDF5 file
*-------------------------------------------------------------------------
*/
/* read a PAL file */
if (read_palette(PAL3_FILE, rgb, (sizeof(rgb) / sizeof(rgb[0]))) < 0)
goto out;
/* transfer to the HDF5 buffer */
for ( i=0, n=0; i<256*3; i+=3, n++)
{
pal[i] =rgb[n].r;
pal[i+1]=rgb[n].g;
pal[i+2]=rgb[n].b;
}
/* make a palette */
if (H5IMmake_palette(fid,PAL3_NAME,pal_dims,pal)<0)
goto out;
/* attach the palette to the image dataset */
if (H5IMlink_palette(fid,IMAGE1_NAME,PAL3_NAME)<0)
goto out;
PASSED();
/*-------------------------------------------------------------------------
* palette #4. blue-red
* make a palette whith blue to red colors
*-------------------------------------------------------------------------
*/
for ( i=0, n=0; i<256*3; i+=3, n++)
{
pal[i] =(unsigned char)n;
pal[i+1]=0;
pal[i+2]=(unsigned char)(255 - n);
}
/* make a palette */
if (H5IMmake_palette(fid,PAL4_NAME,pal_dims,pal)<0)
goto out;
/* attach the palette to the image dataset */
if (H5IMlink_palette(fid,IMAGE1_NAME,PAL4_NAME)<0)
goto out;
/*-------------------------------------------------------------------------
* true color image example with pixel interlace
*-------------------------------------------------------------------------
*/
TESTING2("make true color image with pixel interlace");
/* read second data file */
if ((read_data(DATA_FILE2,&width,&height))<0)
goto out;
/* make image */
if ((H5IMmake_image_24bit(fid,IMAGE2_NAME,width,height,"INTERLACE_PIXEL",image_data))<0)
goto out;
PASSED();
/*-------------------------------------------------------------------------
* True color image example with plane interlace
*-------------------------------------------------------------------------
*/
TESTING2("make true color image with plane interlace");
/* read third data file */
if ((read_data(DATA_FILE3,&width,&height))<0)
goto out;
/* make image */
if ((H5IMmake_image_24bit(fid,IMAGE3_NAME,width,height,"INTERLACE_PLANE",image_data))<0)
goto out;
PASSED();
/*-------------------------------------------------------------------------
* close
*-------------------------------------------------------------------------
*/
if (H5Fclose(fid)<0)
goto out;
/* Release memory buffer */
HDfree(image_data);
return 0;
/* error zone, gracefully close */
out:
/* Release memory buffer */
if(image_data)
HDfree(image_data);
H5E_BEGIN_TRY {
H5Fclose(fid);
} H5E_END_TRY;
H5_FAILED();
return FAIL;
}
int
WriteHDF(GIFTOMEM GifMemoryStruct, char *HDFName , char *GIFFileName)
{
GIFHEAD gifHead; /* GIF Header structure */
GIFIMAGEDESC *gifImageDesc; /* Logical Image Descriptor struct */
int has_pal=0;
long ImageCount; /* number of images */
#ifdef UNUSED
long CommentCount, /* number of comments */
ApplicationCount, /* number of application extensions */
PlainTextCount; /* number of plain text extensions */
#endif /* UNUSED */
char ImageName[256]; /* Image name for the Image */
/* H5 variables */
hid_t file_id; /* H5 file id */
/* temp counter */
int i;
/* get the GIFMem stuff */
gifHead = *(GifMemoryStruct.GifHeader);
/* get some data from gifHead */
ImageCount = gifHead.ImageCount;
#ifdef UNUSED
CommentCount = (WORD)gifHead.CommentCount;
ApplicationCount = (WORD)gifHead.ApplicationCount;
PlainTextCount = (WORD)gifHead.PlainTextCount;
#endif /* UNUSED */
if ((file_id = H5Fcreate(HDFName , H5F_ACC_TRUNC , H5P_DEFAULT , H5P_DEFAULT)) < 0) {
/* error occured opening the HDF File for write */
fprintf(stderr , "HDF file could not be opened for writing\n");
fprintf(stderr , "NOTE: GIF file must be present in the same directory as the binary on UNIX systems.\n");
exit(1);
}
/* first create the global palette if there is one */
if (gifHead.PackedField & 0x80) { /* global palette exists */
hsize_t dims[2]; /* specify the dimensions of the palette */
/* size of the palette is tablesize (rows) X 3 (columns) */
dims[0] = gifHead.TableSize;
dims[1] = 3;
/* make a palette */
if (H5IMmake_palette(file_id,PAL_NAME,dims,(unsigned char *)gifHead.HDFPalette)<0)
return -1;
has_pal=1;
}
for(i = 0; i < ImageCount; i++) {
hsize_t dims[2]; /* dimensions for the dataset */
/* get the gifImageDesc */
gifImageDesc = GifMemoryStruct.GifImageDesc[i];
/* set the dimensions */
dims[0] = gifImageDesc->ImageHeight;
dims[1] = gifImageDesc->ImageWidth;
/* create the image name */
sprintf(ImageName , "Image%d" , i);
/* write image */
if (H5IMmake_image_8bit(file_id,ImageName,dims[1],dims[0],(gifImageDesc->Image))<0)
return -1;
/* attach the palette to the image dataset */
if (has_pal)
{
if (H5IMlink_palette(file_id,ImageName,PAL_NAME)<0)
return -1;
}
}
/* close the H5 file */
if (H5Fclose(file_id) < 0) {
fprintf(stderr , "Could not close HDF5 file. Aborting...\n");
return -1;
}
return 0;
}
