mirror of
https://github.com/HDFGroup/hdf5.git
synced 2024-12-09 07:32:32 +08:00
3cea3093c8
Purpose:
1. fix multiple defination warnings at sgi platform
2. adding chunking information from hdf4 to hdf5 property list.
Description:
1. Orginally global varibles were defined at one header file and this
header file were included by other .c file and .h file so multiple warnings are
generated.
2. Chunking information was not included in the previous version.
Solution:
1. use "extern" to define global variables at h4toh5util.h file and define global variables
at h4toh5main.c
2. retrieve the chunking info from sdgetchunkinfo and GRgetchunkinfo and store these information
into hdf5 property list.
Platforms tested:
eirene,arabica,paz,gondolin
1556 lines
40 KiB
C
1556 lines
40 KiB
C
/*** This file is the main program of converter. ***/
|
||
|
||
#include "h4toh5main.h"
|
||
|
||
int32 estnum_vg;
|
||
int32 estnum_vd;
|
||
int32 num_sds;
|
||
int32 num_images;
|
||
int num_objects;
|
||
int32 num_glsdsattrs;
|
||
int32 num_glgrattrs;
|
||
struct table* sds_hashtab;
|
||
struct table* gr_hashtab;
|
||
struct table* vg_hashtab;
|
||
struct table* vd_hashtab;
|
||
struct table* pal_hashtab;
|
||
struct name_table* name_hashtab;
|
||
struct name_table* dim_hashtab;
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: main
|
||
*
|
||
* Purpose: driver routine to handle all objects of hdf4 file.
|
||
*
|
||
* Return: FAIL if failed, SUCCEED if successful.
|
||
|
||
Modfication:
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
|
||
|
||
|
||
int main(int argc, char ** argv) {
|
||
|
||
char *h5_filename=NULL;
|
||
char *h4_filename=NULL;
|
||
char *h5_extension;
|
||
int status = 0;
|
||
|
||
|
||
argc--;
|
||
argv++;
|
||
|
||
if (argc == 0) {
|
||
fprintf(stderr,"\nError: Invalid Arguments\n");
|
||
PrintOptions_h4toh5();
|
||
return -1;
|
||
}
|
||
|
||
/* take care -h (help) option first */
|
||
{ int i;
|
||
for (i=0; i < argc; i++)
|
||
if ( HDstrcmp(argv[i],"-h") == 0 ) {
|
||
PrintOptions_h4toh5();
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
|
||
switch(argc) {
|
||
|
||
case 0:
|
||
|
||
PrintOptions_h4toh5();
|
||
break;
|
||
|
||
case 1: /* h4toh5 file1 */
|
||
h4_filename = argv[0];
|
||
|
||
if (test_file(h4_filename,O_EXCL,292) != 0 ) {
|
||
/* 292 Decimal - 0444 Octal, a+r */
|
||
printf("the current hdf4 file name is not set properly.\n");
|
||
status = -1;
|
||
break;
|
||
}
|
||
if (test_dir(h4_filename) != 0 ) {
|
||
fprintf(stderr,"%s: Is a directory\n",h4_filename);
|
||
status = -1;
|
||
break;
|
||
}
|
||
|
||
h5_extension = HDstrdup("h5");
|
||
h5_filename = BuildFilename(h4_filename,h5_extension);
|
||
if (h5_filename == NULL) {
|
||
printf("error in creating hdf5 file name.\n");
|
||
status = -1;
|
||
break;
|
||
}
|
||
|
||
if (test_file(h5_filename,O_CREAT|O_EXCL,436) != 0) {
|
||
/* 436 Decimal - 0664 Octal, ug+rw,o+r */
|
||
printf("permission of hdf5 file is not set properly.\n");
|
||
status = -1;
|
||
break;
|
||
}
|
||
|
||
/*0. check whether this file is a hdf file. */
|
||
|
||
if(!Hishdf(h4_filename)){
|
||
printf("error: not an hdf file. \n");
|
||
printf("the file will not be converted. \n");
|
||
return FAIL;
|
||
}
|
||
|
||
|
||
status = h4toh5(h4_filename, h5_filename);
|
||
|
||
if ( status == FAIL ) {
|
||
printf("error in converting %s into %s\n",h4_filename,h5_filename);
|
||
break;
|
||
}
|
||
if (h5_filename != NULL) {
|
||
free(h5_filename);
|
||
}
|
||
|
||
break;
|
||
|
||
case 2: /* h5toh4 file_in file_out */
|
||
h4_filename = argv[0];
|
||
h5_filename = argv[1];
|
||
|
||
if (test_file(h4_filename,O_EXCL,292) != 0 ) {
|
||
/* 292 Decimal - 0444 Octal, a+r */
|
||
printf("permission of hdf4 file is not set properly.\n");
|
||
status = -1;
|
||
break;
|
||
}
|
||
|
||
if (test_dir(h4_filename) != 0 ) {
|
||
fprintf(stderr,"%s: Is a directory\n",h4_filename);
|
||
status = -1;
|
||
break;
|
||
}
|
||
|
||
if (test_file(h5_filename,O_CREAT|O_RDWR,436) != 0) { /* 436 Decimal - 0664 Octal, ug+rw,o+r */
|
||
printf("permission of hdf5 file is not set properly.\n");
|
||
status = -1;
|
||
break;
|
||
}
|
||
if (test_dir(h4_filename) != 0 ) {
|
||
fprintf(stderr,"%s: Is a directory\n",h4_filename);
|
||
status = -1;
|
||
break;
|
||
}
|
||
|
||
/*0. check whether this file is a hdf file. */
|
||
|
||
if(!Hishdf(h4_filename)){
|
||
printf("error: not an hdf file. \n");
|
||
printf("the file will not be converted. \n");
|
||
return FAIL;
|
||
}
|
||
|
||
status = h4toh5(h4_filename, h5_filename);
|
||
if ( status == FAIL ) {
|
||
printf("error in converting %sinto %s\n",h4_filename,h5_filename);
|
||
break;
|
||
}
|
||
break;
|
||
|
||
default:
|
||
break;
|
||
}
|
||
|
||
return status;
|
||
|
||
}
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: h4toh5
|
||
*
|
||
* Purpose: This routine checks out arguments sent, makes sure that hdf4
|
||
file is valid, makes sure filename for hdf5 file is correct,
|
||
and then call h4toh5().
|
||
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
int h4toh5(char*filename4, char*filename5) {
|
||
|
||
/* define variables for hdf4. */
|
||
int32 istat ; /* hdf4 library routine return value. */
|
||
int32 file_id;/* file identfier of hdf file.*/
|
||
int32 sd_id;/* sd interface identifer*/
|
||
int32 gr_id;/* gr interface identifer*/
|
||
int check_glo;
|
||
|
||
/* define variables for hdf5. */
|
||
hid_t file5_id;/* hdf5 file identifier. */
|
||
hid_t h5_root;/* new hdf5 root group identifier.*/
|
||
|
||
hid_t h5_dimg;/* hdf5 dimensional scale group identifier. */
|
||
hid_t h5_palg;/* hdf5 palette group identifier. */
|
||
|
||
|
||
|
||
|
||
/*1. open the current hdf4 file. */
|
||
|
||
file_id = Hopen(filename4, DFACC_READ, 0);
|
||
if(file_id == FAIL) {
|
||
printf("error: no such hdf4 files. \n");
|
||
return FAIL;
|
||
}
|
||
|
||
/* open sd interface.*/
|
||
sd_id = SDstart(filename4,DFACC_READ);
|
||
if(sd_id == FAIL) {
|
||
printf("error: cannot start SD interface. \n");
|
||
Hclose(file_id);
|
||
return FAIL;
|
||
}
|
||
|
||
/* open gr interface.*/
|
||
gr_id = GRstart(file_id);
|
||
if(gr_id == FAIL) {
|
||
printf("error in obtaining gr id. \n");
|
||
SDend(sd_id);
|
||
Hclose(file_id);
|
||
return FAIL;
|
||
}
|
||
|
||
/* open V interface. */
|
||
istat = Vstart(file_id);
|
||
if(istat == FAIL) {
|
||
printf("error in starting V interface. \n");
|
||
SDend(sd_id);
|
||
GRend(gr_id);
|
||
Hclose(file_id);
|
||
return FAIL;
|
||
}
|
||
|
||
/* 2. obtain number of hdf4 objects(sds,image,vdata,vgroup,palette)
|
||
in this hdf4 file. */
|
||
|
||
if(get_numof_hdf4obj(filename4,file_id) == FAIL) {
|
||
printf("error in obtaining number of hdf4 objects.\n");
|
||
SDend(sd_id);
|
||
GRend(gr_id);
|
||
Vend(file_id);
|
||
Hclose(file_id);
|
||
return FAIL;
|
||
}
|
||
|
||
/* set up global hash tables for hdf4 objects. */
|
||
if(set_hashtables() == FAIL){
|
||
printf("error in setting hashtables. \n");
|
||
SDend(sd_id);
|
||
GRend(gr_id);
|
||
Vend(file_id);
|
||
Hclose(file_id);
|
||
return FAIL;
|
||
}
|
||
|
||
/* create hdf5 file. */
|
||
file5_id = H5Fcreate(filename5,H5F_ACC_TRUNC,H5P_DEFAULT,H5P_DEFAULT);
|
||
|
||
if (file5_id < 0) {
|
||
fprintf(stderr, "unable to create hdf5 file \n");
|
||
SDend(sd_id);
|
||
GRend(gr_id);
|
||
Vend(file_id);
|
||
Hclose(file_id);
|
||
free_allhashmemory();
|
||
return FAIL;
|
||
}
|
||
|
||
/* Initialize hdf5 group interface. */
|
||
h5_root = H5Gopen(file5_id,"/");
|
||
|
||
if(h5_root < 0) {
|
||
printf("error in opening hdf5 root group. \n");
|
||
SDend(sd_id);
|
||
GRend(gr_id);
|
||
Vend(file_id);
|
||
Hclose(file_id);
|
||
H5Fclose(file5_id);
|
||
free_allhashmemory();
|
||
return FAIL;
|
||
}
|
||
|
||
/**** build up helper groups(dimensional scale and palette) ****/
|
||
if(set_helpgroups(h5_root,&h5_dimg,&h5_palg)==FAIL) {
|
||
printf("error setting up dimensional scale and palette groups.\n");
|
||
SDend(sd_id);
|
||
GRend(gr_id);
|
||
Vend(file_id);
|
||
Hclose(file_id);
|
||
H5Fclose(file5_id);
|
||
free_allhashmemory();
|
||
return FAIL;
|
||
}
|
||
|
||
/* convert global sds attributes into global attributes under root group.*/
|
||
check_glo = 1;
|
||
|
||
if(sds_transattrs(sd_id, h5_root,num_glsdsattrs,check_glo)==FAIL) {
|
||
SDend(sd_id);
|
||
GRend(gr_id);
|
||
Vend(file_id);
|
||
Hclose(file_id);
|
||
H5Fclose(file5_id);
|
||
free_allhashmemory();
|
||
return FAIL;
|
||
}
|
||
|
||
|
||
/* convert global image attributes into global attributes under root group.*/
|
||
check_glo = 1;
|
||
|
||
if(gr_tranattrs(gr_id, h5_root,num_glgrattrs,check_glo)==FAIL) {
|
||
SDend(sd_id);
|
||
GRend(gr_id);
|
||
Vend(file_id);
|
||
Hclose(file_id);
|
||
H5Fclose(file5_id);
|
||
free_allhashmemory();
|
||
return FAIL;
|
||
}
|
||
|
||
/* convert all objects in lone vgroups into corresponding hdf5 objects. */
|
||
if(h4toh5lonevgs(file_id,sd_id,h5_root,h5_dimg,h5_palg)== FAIL) {
|
||
printf("error in translating lone vgroup into hdf5 objects.\n");
|
||
SDend(sd_id);
|
||
GRend(gr_id);
|
||
Vend(file_id);
|
||
Hclose(file_id);
|
||
if(num_sds >0) H5Gclose(h5_dimg);
|
||
if(num_images >0) H5Gclose(h5_palg);
|
||
H5Gclose(h5_root);
|
||
H5Fclose(file5_id);
|
||
free_allhashmemory();
|
||
return FAIL;
|
||
}
|
||
|
||
/*convert all objects in group rings into corresponding hdf5 objects. */
|
||
if(h4toh5vgrings(file_id,sd_id,h5_root,h5_dimg,h5_palg) == FAIL){
|
||
printf("error in translating vgroup rings into hdf5 objects.\n");
|
||
SDend(sd_id);
|
||
GRend(gr_id);
|
||
Vend(file_id);
|
||
Hclose(file_id);
|
||
if(num_sds >0) H5Gclose(h5_dimg);
|
||
if(num_images >0) H5Gclose(h5_palg);
|
||
H5Gclose(h5_root);
|
||
H5Fclose(file5_id);
|
||
free_allhashmemory();
|
||
return FAIL;
|
||
}
|
||
|
||
/*convert all independent lone vdata into corresponding hdf5 datasets with
|
||
compound data type. */
|
||
if(h4toh5lonevds(file_id,h5_root) == FAIL){
|
||
printf("error in translating lone independent vdata into hdf5 objects.\n");
|
||
SDend(sd_id);
|
||
GRend(gr_id);
|
||
Vend(file_id);
|
||
Hclose(file_id);
|
||
if(num_sds >0) H5Gclose(h5_dimg);
|
||
if(num_images >0) H5Gclose(h5_palg);
|
||
H5Gclose(h5_root);
|
||
H5Fclose(file5_id);
|
||
free_allhashmemory();
|
||
return FAIL;
|
||
}
|
||
|
||
/*** convert hdf file annotations into hdf5 attributes under the root.***/
|
||
if(Annofil_h4_to_h5(file_id,h5_root) == FAIL) {
|
||
printf("error in translating file annotations into root attributes.\n");
|
||
SDend(sd_id);
|
||
GRend(gr_id);
|
||
Vend(file_id);
|
||
Hclose(file_id);
|
||
if(num_sds >0) H5Gclose(h5_dimg);
|
||
if(num_images >0) H5Gclose(h5_palg);
|
||
H5Gclose(h5_root);
|
||
H5Fclose(file5_id);
|
||
free_allhashmemory();
|
||
return FAIL;
|
||
}
|
||
|
||
/*** deal with untouched sds objects.convert them into hdf5 datasets under root group.***/
|
||
|
||
if(h4toh5unvisitedsds(file_id,sd_id,h5_root,h5_dimg) == FAIL) {
|
||
printf("error in converting unvisited sds objects into hdf5 file.\n"); SDend(sd_id);
|
||
GRend(gr_id);
|
||
Vend(file_id);
|
||
Hclose(file_id);
|
||
if(num_sds >0) H5Gclose(h5_dimg);
|
||
if(num_images >0) H5Gclose(h5_palg);
|
||
H5Gclose(h5_root);
|
||
H5Fclose(file5_id);
|
||
free_allhashmemory();
|
||
return FAIL;
|
||
}
|
||
|
||
/*** deal with untouched image objects. convert them into hdf5 datasets under root group. ***/
|
||
|
||
if(h4toh5unvisitedimages(file_id,h5_root,h5_palg) == FAIL) {
|
||
printf("error in converting unvisited image objects into hdf5 file.\n");
|
||
SDend(sd_id);
|
||
GRend(gr_id);
|
||
Vend(file_id);
|
||
Hclose(file_id);
|
||
if(num_sds >0) H5Gclose(h5_dimg);
|
||
if(num_images >0) H5Gclose(h5_palg);
|
||
H5Gclose(h5_root);
|
||
H5Fclose(file5_id);
|
||
free_allhashmemory();
|
||
return FAIL;
|
||
}
|
||
|
||
free_allhashmemory();
|
||
SDend(sd_id);
|
||
GRend(gr_id);
|
||
Vend(file_id);
|
||
Hclose(file_id);
|
||
if(num_sds >0) H5Gclose(h5_dimg);
|
||
if(num_images >0) H5Gclose(h5_palg);
|
||
H5Gclose(h5_root);
|
||
H5Fclose(file5_id);
|
||
return SUCCEED;
|
||
}
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: get_numof_hdf4obj
|
||
*
|
||
* Purpose: get number or estimated number of hdf4 objects
|
||
*
|
||
* Return: FAIL if failed, SUCCEED if successful.
|
||
*
|
||
* In :
|
||
file_id: hdf file identifier
|
||
filename: hdf file name
|
||
Out:
|
||
Modification:
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
int get_numof_hdf4obj(char*filename,int32 file_id) {
|
||
|
||
int32 sd_id;/* sd interface identifer*/
|
||
int32 gr_id;/* gr interface identifer*/
|
||
int num_lonevd;/* number of lone vdata*/
|
||
int num_lonevg;/* number of lone vgroup.*/
|
||
int32 istat;
|
||
|
||
estnum_vg = 0;
|
||
estnum_vd = 0;
|
||
num_sds = 0;
|
||
num_images = 0;
|
||
num_objects = 0;
|
||
|
||
/* obtain number of sds and number of global sds attribute. */
|
||
|
||
sd_id = SDstart(filename,DFACC_READ);
|
||
if(sd_id == FAIL) {
|
||
printf("error: cannot start SD interface. \n");
|
||
return FAIL;
|
||
}
|
||
|
||
if(SDfileinfo(sd_id,&num_sds,&num_glsdsattrs) == FAIL) {
|
||
printf("error in obtaining SDS information from the file.\n");
|
||
return FAIL;
|
||
}
|
||
|
||
|
||
/* obtain number of images and number of global image attributes.*/
|
||
|
||
gr_id = GRstart(file_id);
|
||
if(gr_id == FAIL) {
|
||
printf("error in obtaining gr id. \n");
|
||
return FAIL;
|
||
}
|
||
|
||
if(GRfileinfo(gr_id,&num_images,&num_glgrattrs) == FAIL) {
|
||
printf("error in obtaining GR information from the file. \n");
|
||
return FAIL;
|
||
}
|
||
|
||
/* obtain number of lone vgroup and lone vdata. */
|
||
|
||
istat = Vstart(file_id);
|
||
if (istat == FAIL) {
|
||
fprintf(stderr, "unable to start hdf4 V interface.\n");
|
||
return FAIL;
|
||
}
|
||
|
||
num_lonevd = VSlone(file_id,NULL,0);
|
||
if(num_lonevd == FAIL) {
|
||
printf("error in obtaining lone vdata number. \n");
|
||
return FAIL;
|
||
}
|
||
|
||
num_lonevg = Vlone(file_id,NULL,0);
|
||
if(num_lonevg == FAIL) {
|
||
printf("error in obtaining lone vgroup number. \n");
|
||
return FAIL;
|
||
}
|
||
|
||
/* intelligent guess of the total number of vgroups,total number of
|
||
independent vdata. */
|
||
|
||
estnum_vg = 6* num_lonevg;
|
||
estnum_vd = 4* num_lonevd;
|
||
|
||
/* set the size of name hashtable to num_objects. */
|
||
num_objects = estnum_vg + estnum_vd + num_sds + num_images;
|
||
|
||
return SUCCEED;
|
||
}
|
||
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: set_helpgroups
|
||
*
|
||
* Purpose: get number or estimated number of hdf4 objects
|
||
*
|
||
* Return: FAIL if failed, SUCCEED if successful.
|
||
*
|
||
* In :
|
||
h5root: hdf5 group identifier
|
||
h5dimgptr: h5 dimensional group pointer
|
||
h5palgptr: h5 palette group pointer
|
||
Modification:
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
|
||
int set_helpgroups(hid_t h5root,hid_t* h5dimgptr,hid_t* h5palgptr){
|
||
|
||
hid_t h5_dimg;/* hdf5 dimensional scale group identifier. */
|
||
hid_t h5_palg;/* hdf5 palette group identifier. */
|
||
|
||
/*1. dimensional scale group.*/
|
||
|
||
if(num_sds > 0) {
|
||
h5_dimg = H5Gcreate(h5root,HDF4_DIMG,0);
|
||
if (h5_dimg <0) {
|
||
printf("error in creating hdf5 dimensional scale group. \n");
|
||
return FAIL;
|
||
}
|
||
|
||
*h5dimgptr = h5_dimg;
|
||
}
|
||
|
||
/*2. palette group.*/
|
||
|
||
if(num_images >0) {
|
||
h5_palg = H5Gcreate(h5root,HDF4_PALG,0);
|
||
if(h5_palg <0) {
|
||
printf("error in creating hdf5 palette group. \n");
|
||
H5Gclose(h5_dimg);
|
||
return FAIL;
|
||
}
|
||
|
||
*h5palgptr = h5_palg;
|
||
}
|
||
|
||
return SUCCEED;
|
||
|
||
}
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: set_hashtables
|
||
*
|
||
* Purpose: set up hashtables
|
||
*
|
||
* Return: FAIL if failed, SUCCEED if successful.
|
||
*
|
||
* In :
|
||
|
||
Out:
|
||
Modification:
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
int set_hashtables(void) {
|
||
|
||
if(num_sds != 0) {
|
||
sds_hashtab = malloc(sizeof(struct table)*2*num_sds);
|
||
if(init_tab(2*num_sds,sds_hashtab)== FAIL){
|
||
printf("cannot initialize sds hashing table. \n");
|
||
return FAIL;
|
||
}
|
||
}
|
||
|
||
if(num_images != 0) {
|
||
gr_hashtab = malloc(sizeof(struct table)*2*num_images);
|
||
if(init_tab(2*num_images,gr_hashtab) == FAIL){
|
||
printf("cannot initialize image hashing table. \n");
|
||
return FAIL;
|
||
}
|
||
}
|
||
|
||
/*hashtable is made to be fixed for dimensional scale and palette.*/
|
||
|
||
if(num_sds != 0) {
|
||
dim_hashtab = malloc(sizeof(struct name_table)*DIM_HASHSIZE);
|
||
if(init_nametab(DIM_HASHSIZE,dim_hashtab) == FAIL) {
|
||
printf("can not initialize dimension hashing table.\n");
|
||
return FAIL;
|
||
}
|
||
}
|
||
|
||
/* initialize the palette table */
|
||
if(num_images != 0){
|
||
pal_hashtab = malloc(sizeof(struct table)*PAL_HASHSIZE);
|
||
if(init_tab(PAL_HASHSIZE,pal_hashtab) == FAIL) {
|
||
printf("can not initialize palette hashing table.\n");
|
||
return FAIL;
|
||
}
|
||
}
|
||
|
||
/* initialize the vgroup table */
|
||
if(estnum_vg > 0) {
|
||
vg_hashtab = malloc(sizeof(struct table)*estnum_vg);
|
||
}
|
||
else {
|
||
estnum_vg = VG_DEFHASHSIZE;
|
||
vg_hashtab = malloc(sizeof(struct table)*estnum_vg);
|
||
}
|
||
if(init_tab(estnum_vg,vg_hashtab) == FAIL) {
|
||
printf("error in allocating memory for vgroup hashing table.\n");
|
||
return FAIL;
|
||
}
|
||
|
||
/* initialize the vdata table.*/
|
||
if(estnum_vd > 0) {
|
||
vd_hashtab = malloc(sizeof(struct table)*estnum_vd);
|
||
}
|
||
else {
|
||
estnum_vd = VD_DEFHASHSIZE;
|
||
vd_hashtab = malloc(sizeof(struct table)*estnum_vd);
|
||
}
|
||
|
||
if(init_tab(estnum_vd,vd_hashtab)== FAIL) {
|
||
printf("cannot initialize vdata hashing table.\n");
|
||
return FAIL;
|
||
}
|
||
|
||
/* The name hashtable is only for dealing with name clashing,
|
||
num_objects is the size of the hash table. */
|
||
|
||
if(num_objects != 0){
|
||
name_hashtab = malloc(sizeof(struct name_table)*num_objects);
|
||
if(init_nametab(num_objects,name_hashtab)== FAIL) {
|
||
printf("cannot initialize name hashing table. \n");
|
||
return FAIL;
|
||
}
|
||
}
|
||
|
||
return SUCCEED;
|
||
}
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: h4toh5lonevgs
|
||
*
|
||
* Purpose: Recursively convert hdf4 objects in lone vgroups into
|
||
corresponding hdf5 datasets
|
||
*
|
||
* Return: FAIL if failed, SUCCEED if successful.
|
||
*
|
||
* In : file_id: hdf file id
|
||
sd_id: hdf sd interface id
|
||
h5group: hdf5 group id
|
||
h5_dimg: hdf5 dimensional scale group id
|
||
h5_palg: hdf5 palette group id
|
||
|
||
Out:
|
||
Modification:
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
int h4toh5lonevgs(int32 file_id,int32 sd_id,hid_t h5group,hid_t h5_dimg,hid_t h5_palg) {
|
||
|
||
int32 vgroup_id;
|
||
int num_lonevg; /* number of lone vgroup.*/
|
||
int32 *ref_array;
|
||
int32 istat;
|
||
char vgroup_name[VGNAMELENMAX];
|
||
char* cor_vgroupname;
|
||
char vgroup_class[VGNAMELENMAX];
|
||
char refstr[MAXREF_LENGTH];
|
||
int check_vgroup;
|
||
int check_tabst;
|
||
int lone_vg_number;
|
||
char *h5cgroup_name;
|
||
|
||
istat = Vstart(file_id);
|
||
if (istat == FAIL) {
|
||
fprintf(stderr, "unable to start hdf4 V interface.\n");
|
||
return FAIL;
|
||
}
|
||
|
||
num_lonevg = Vlone(file_id,NULL,0);
|
||
|
||
if (num_lonevg == FAIL) {
|
||
printf("error in obtaining lone vgroup number. \n");
|
||
return FAIL;
|
||
}
|
||
|
||
/* obtain object reference array. */
|
||
|
||
ref_array = (int32 *)malloc(sizeof(int32) *num_lonevg);
|
||
|
||
if(ref_array == NULL) {
|
||
printf("error in allocating memory for ref_array.\n");
|
||
return FAIL;
|
||
}
|
||
|
||
num_lonevg = Vlone(file_id,ref_array,num_lonevg);
|
||
|
||
/* walk through every lone group in the file */
|
||
|
||
for(lone_vg_number = 0; lone_vg_number < num_lonevg;
|
||
lone_vg_number++) {
|
||
|
||
vgroup_id = Vattach(file_id,ref_array[lone_vg_number],"r");
|
||
|
||
if(vgroup_id ==FAIL) {
|
||
printf("error in attaching lone vgroup.\n");
|
||
free(ref_array);
|
||
return FAIL;
|
||
}
|
||
|
||
/*obtain group name and class name.*/
|
||
h4toh5_ZeroMemory(vgroup_class,VGNAMELENMAX);
|
||
istat = Vgetclass(vgroup_id,vgroup_class);
|
||
if(istat == FAIL) {
|
||
printf("error in getting vgroup class.\n");
|
||
free(ref_array);
|
||
Vdetach(vgroup_id);
|
||
return FAIL;
|
||
}
|
||
|
||
h4toh5_ZeroMemory(vgroup_name,VGNAMELENMAX);
|
||
istat = Vgetname(vgroup_id,vgroup_name);
|
||
if(istat == FAIL ) {
|
||
printf("error in getting vgroup name. \n");
|
||
Vdetach(vgroup_id);
|
||
free(ref_array);
|
||
return FAIL;
|
||
}
|
||
|
||
/* check for CDF0.0 and RIG0.0, if yes
|
||
don't go into this group.*/
|
||
|
||
if(strcmp(vgroup_class,_HDF_CDF)==0) {
|
||
Vdetach(vgroup_id);
|
||
continue;
|
||
}
|
||
if(strcmp(vgroup_class,GR_NAME)==0) {
|
||
Vdetach(vgroup_id);
|
||
continue;
|
||
}
|
||
|
||
/* converting integer number into string format. */
|
||
if(conv_int_str(ref_array[lone_vg_number],refstr) == FAIL) {
|
||
printf("ref. is negative, error in converting\n");
|
||
Vdetach(vgroup_id);
|
||
free(ref_array);
|
||
return FAIL;
|
||
}
|
||
|
||
/* checking whether vgroup name contains ORI_SLASH, changing into CHA_SLASH.*/
|
||
cor_vgroupname = correct_name(vgroup_name);
|
||
if(cor_vgroupname == NULL) {
|
||
printf("error in generating corrected vgroup name. \n");
|
||
Vdetach(vgroup_id);
|
||
free(ref_array);
|
||
return FAIL;
|
||
}
|
||
|
||
/* obtaining group name of the converted lone vgroup. In this call,
|
||
we will deal with cases such as name clashing and no available vgroup
|
||
name. */
|
||
|
||
h5cgroup_name = get_obj_aboname(cor_vgroupname,refstr,NULL,HDF4_VGROUP);
|
||
|
||
if(h5cgroup_name == NULL) {
|
||
printf("error in getting group name.\n");
|
||
Vdetach(vgroup_id);
|
||
free(ref_array);
|
||
free(cor_vgroupname);
|
||
return FAIL;
|
||
}
|
||
|
||
/* printf("h5cgroup_name %s\n",h5cgroup_name);*/
|
||
free(cor_vgroupname);
|
||
|
||
/* updating lookup table for vgroups.*/
|
||
|
||
check_vgroup = lookup(ref_array[lone_vg_number],estnum_vg,vg_hashtab);
|
||
|
||
if(check_vgroup == 0) { /* adding this vgroup into the list. */
|
||
|
||
check_tabst = set_name(ref_array[lone_vg_number],estnum_vg,
|
||
vg_hashtab,h5cgroup_name);
|
||
if(check_tabst == FAIL) {
|
||
printf("not enough memory to be allocated for vgroup name. \n");
|
||
Vdetach(vgroup_id);
|
||
free(h5cgroup_name);
|
||
free(ref_array);
|
||
return FAIL;
|
||
}
|
||
}
|
||
|
||
/* this line is for debugging. */
|
||
|
||
if(check_vgroup == 1){
|
||
fprintf(stderr,"this vgroup should not be touched. \n");
|
||
Vdetach(vgroup_id);
|
||
free(h5cgroup_name);
|
||
free(ref_array);
|
||
return FAIL;
|
||
}
|
||
|
||
if(Vgroup_h4_to_h5(file_id,vgroup_id,sd_id,h5group,h5_dimg,h5_palg)==FAIL){
|
||
printf("error in translating vgroup into hdf5 objects.\n");
|
||
Vdetach(vgroup_id);
|
||
free(h5cgroup_name);
|
||
free(ref_array);
|
||
return FAIL;
|
||
}
|
||
|
||
Vdetach(vgroup_id);
|
||
free(h5cgroup_name);
|
||
}
|
||
free(ref_array);
|
||
return SUCCEED;
|
||
}
|
||
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: h4toh5vgrings
|
||
*
|
||
* Purpose: Recursively convert objects at special hdf4 vgroups
|
||
(vgroup rings)
|
||
into objects of corresponding hdf5 groups. The strategy here
|
||
is to arbitrily grab any vgroup in the group ring and put it
|
||
under hdf5 root.
|
||
*
|
||
* Return: FAIL if failed, SUCCEED if successful.
|
||
*
|
||
* In : file_id: hdf file id
|
||
sd_id: hdf sds id
|
||
h5group: hdf5 group id
|
||
h5_dimg: hdf5 dimensional scale group id
|
||
h5_palg: hdf5 palette group id
|
||
|
||
Out:
|
||
Modification:
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
|
||
int h4toh5vgrings(int32 file_id,int32 sd_id,hid_t h5group,hid_t h5_dimg,hid_t h5_palg){
|
||
|
||
int32 vgroup_id;
|
||
int32 ref_num;
|
||
char vgroup_name[VGNAMELENMAX];
|
||
char* cor_vgroupname;
|
||
char vgroup_class[VGNAMELENMAX];
|
||
char refstr[MAXREF_LENGTH];
|
||
int check_vgroup;
|
||
int32 istat;
|
||
char *h5cgroup_name;
|
||
|
||
ref_num = Vgetid(file_id,-1);
|
||
|
||
while (ref_num != -1) {
|
||
|
||
/* if we find a group that is not touched, grab it under root group.*/
|
||
|
||
check_vgroup = lookup(ref_num,estnum_vg,vg_hashtab);
|
||
|
||
if (check_vgroup == 0){
|
||
|
||
vgroup_id = Vattach(file_id,ref_num,"r");
|
||
if(vgroup_id ==FAIL) {
|
||
printf("error in attaching group in a group ring. \n");
|
||
return FAIL;
|
||
}
|
||
|
||
h4toh5_ZeroMemory(vgroup_name,VGNAMELENMAX);
|
||
istat = Vgetname(vgroup_id,vgroup_name);
|
||
if(istat ==FAIL) {
|
||
printf("error in obtaining vgroup names. \n");
|
||
Vdetach(vgroup_id);
|
||
return FAIL;
|
||
}
|
||
|
||
h4toh5_ZeroMemory(vgroup_class,VGNAMELENMAX);
|
||
if(Vgetclass(vgroup_id,vgroup_class) == FAIL) {
|
||
printf("error in obtaining vgroup class name. \n");
|
||
Vdetach(vgroup_id);
|
||
return FAIL;
|
||
}
|
||
|
||
/* do nothing for those predefined attribute.*/
|
||
|
||
if(vgroup_class != NULL) {
|
||
|
||
if(strcmp(vgroup_class,_HDF_ATTRIBUTE)==0) {
|
||
ref_num = Vgetid(file_id,ref_num);
|
||
Vdetach(vgroup_id);
|
||
continue;
|
||
}
|
||
|
||
if(strcmp(vgroup_class,_HDF_VARIABLE)==0) {
|
||
ref_num = Vgetid(file_id,ref_num);
|
||
Vdetach(vgroup_id);
|
||
continue;
|
||
}
|
||
|
||
if(strcmp(vgroup_class,_HDF_DIMENSION)==0) {
|
||
ref_num = Vgetid(file_id,ref_num);
|
||
Vdetach(vgroup_id);
|
||
continue;
|
||
}
|
||
|
||
if(strcmp(vgroup_class,_HDF_UDIMENSION)==0) {
|
||
ref_num = Vgetid(file_id,ref_num);
|
||
Vdetach(vgroup_id);
|
||
continue;
|
||
}
|
||
|
||
if(strcmp(vgroup_class,_HDF_CDF)==0) {
|
||
ref_num = Vgetid(file_id,ref_num);
|
||
Vdetach(vgroup_id);
|
||
continue;
|
||
}
|
||
|
||
if(strcmp(vgroup_class,GR_NAME)==0) {
|
||
ref_num = Vgetid(file_id,ref_num);
|
||
Vdetach(vgroup_id);
|
||
continue;
|
||
}
|
||
|
||
if(strcmp(vgroup_class,RI_NAME)==0) {
|
||
ref_num = Vgetid(file_id,ref_num);
|
||
Vdetach(vgroup_id);
|
||
continue;
|
||
}
|
||
}
|
||
|
||
if(vgroup_name != NULL) {
|
||
if(strcmp(vgroup_name,GR_NAME)==0) {
|
||
ref_num = Vgetid(file_id,ref_num);
|
||
Vdetach(vgroup_id);
|
||
continue;
|
||
}
|
||
}
|
||
|
||
/* convert reference number into string format. */
|
||
if(conv_int_str(ref_num,refstr) == FAIL) {
|
||
printf("ref. is negative, error in converting\n");
|
||
Vdetach(vgroup_id);
|
||
return FAIL;
|
||
}
|
||
|
||
/* checking whether vgroup name contains ORI_SLASH, changing into CHA_SLASH.*/
|
||
cor_vgroupname = correct_name(vgroup_name);
|
||
if(cor_vgroupname == NULL) {
|
||
printf("error in generating corrected vgroup name. \n");
|
||
Vdetach(vgroup_id);
|
||
return FAIL;
|
||
}
|
||
/* obtain the hdf5 group name. */
|
||
h5cgroup_name = get_obj_aboname(cor_vgroupname,refstr,NULL,HDF4_VGROUP);
|
||
|
||
if(h5cgroup_name == NULL) {
|
||
printf("error in getting vgroup name.\n");
|
||
Vdetach(vgroup_id);
|
||
free(cor_vgroupname);
|
||
return FAIL;
|
||
}
|
||
|
||
free(cor_vgroupname);
|
||
if(set_name(ref_num,estnum_vg,vg_hashtab,h5cgroup_name)==FAIL) {
|
||
printf("error in setting h5 group name.\n");
|
||
Vdetach(vgroup_id);
|
||
free(h5cgroup_name);
|
||
return FAIL;
|
||
}
|
||
|
||
if(Vgroup_h4_to_h5(file_id,vgroup_id,sd_id,h5group,h5_dimg,h5_palg)
|
||
==FAIL){
|
||
|
||
printf("error in translating vgroup into hdf5 group\n");
|
||
Vdetach(vgroup_id);
|
||
free(h5cgroup_name);
|
||
return FAIL;
|
||
}
|
||
|
||
Vdetach(vgroup_id);
|
||
free(h5cgroup_name);
|
||
}
|
||
ref_num = Vgetid(file_id,ref_num);
|
||
}
|
||
return SUCCEED;
|
||
|
||
}
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: h4toh5lonevds
|
||
*
|
||
* Purpose: convert hdf4 lone vdata into
|
||
the corresponding hdf5 datasets
|
||
*
|
||
* Return: FAIL if failed, SUCCEED if successful.
|
||
*
|
||
* In : file_id: hdf file id
|
||
h5group: hdf5 group id
|
||
|
||
Out:
|
||
Modification:
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
int h4toh5lonevds(int32 file_id, hid_t h5group){
|
||
|
||
int32 vdata_id;
|
||
int32 *ref_vdata_array;
|
||
int32 vdata_tag;
|
||
int32 vdata_ref;
|
||
int32 istat;
|
||
char vdata_name[VGNAMELENMAX];
|
||
char* cor_vdataname;
|
||
char vdata_class[VGNAMELENMAX];
|
||
char refstr[MAXREF_LENGTH];
|
||
int check_vdata;
|
||
int lone_vd_number;
|
||
int num_lonevd;
|
||
char *h5cvdata_name;
|
||
|
||
num_lonevd = VSlone(file_id,NULL,0);
|
||
|
||
if (num_lonevd == FAIL) {
|
||
printf("error in obtaining lone vgroup number. \n");
|
||
return FAIL;
|
||
}
|
||
|
||
if (num_lonevd > 0) {
|
||
|
||
ref_vdata_array = (int32 *)malloc(sizeof(int32) *(num_lonevd));
|
||
|
||
num_lonevd = VSlone(file_id,ref_vdata_array,num_lonevd);
|
||
if(num_lonevd == FAIL) {
|
||
printf("error in obtaining lone vdata number the second time.\n");
|
||
free(ref_vdata_array);
|
||
}
|
||
/* walk through all lone vdatas. */
|
||
|
||
for(lone_vd_number = 0; lone_vd_number < num_lonevd;lone_vd_number++)
|
||
{
|
||
vdata_id = VSattach(file_id,ref_vdata_array[lone_vd_number],"r");
|
||
|
||
if(vdata_id == FAIL) {
|
||
printf("error in obtaining vdata id for lone vdata.\n");
|
||
free(ref_vdata_array);
|
||
}
|
||
|
||
/* Make sure this vdata is not an attribute of other hdf4 objects.*/
|
||
|
||
if(!VSisattr(vdata_id)) {
|
||
vdata_ref = VSQueryref(vdata_id);
|
||
if(vdata_ref == FAIL) {
|
||
printf("error in getting vdata reference number.\n");
|
||
free(ref_vdata_array);
|
||
VSdetach(vdata_id);
|
||
return FAIL;
|
||
}
|
||
|
||
vdata_tag = VSQuerytag(vdata_id);
|
||
if(vdata_tag == FAIL){
|
||
printf("error in getting vdata tag.\n");
|
||
free(ref_vdata_array);
|
||
VSdetach(vdata_id);
|
||
return FAIL;
|
||
}
|
||
|
||
h4toh5_ZeroMemory(vdata_class,VGNAMELENMAX);
|
||
istat = VSgetclass(vdata_id,vdata_class);
|
||
if(istat == FAIL) {
|
||
printf("error in getting vdata class name.\n");
|
||
free(ref_vdata_array);
|
||
VSdetach(vdata_id);
|
||
return FAIL;
|
||
}
|
||
|
||
h4toh5_ZeroMemory(vdata_name,VGNAMELENMAX);
|
||
istat = VSQueryname(vdata_id,vdata_name);
|
||
if(istat == FAIL) {
|
||
printf("error in getting vdata name. \n");
|
||
free(ref_vdata_array);
|
||
VSdetach(vdata_id);
|
||
return FAIL;
|
||
}
|
||
|
||
/* converting reference number into string format.*/
|
||
if(conv_int_str(ref_vdata_array[lone_vd_number],refstr)==FAIL) {
|
||
printf("error in converting int to string.\n");
|
||
free(ref_vdata_array);
|
||
VSdetach(vdata_id);
|
||
return FAIL;
|
||
}
|
||
/* checking whether vdata name contains ORI_SLASH, changing into CHA_SLASH.*/
|
||
cor_vdataname = correct_name(vdata_name);
|
||
if(cor_vdataname == NULL) {
|
||
printf("error in generating corrected vgroup name. \n");
|
||
VSdetach(vdata_id);
|
||
free(ref_vdata_array);
|
||
return FAIL;
|
||
}
|
||
/* obtaining hdf5 dataset name that is converted from hdf4 vdata.*/
|
||
h5cvdata_name = get_obj_aboname(cor_vdataname,refstr,NULL,HDF4_VDATA);
|
||
if(h5cvdata_name == NULL) {
|
||
printf("error in getting vdata name.\n");
|
||
free(ref_vdata_array);
|
||
VSdetach(vdata_id);
|
||
free(cor_vdataname);
|
||
return FAIL;
|
||
}
|
||
|
||
free(cor_vdataname);
|
||
check_vdata = lookup(ref_vdata_array[lone_vd_number],estnum_vd,
|
||
vd_hashtab);
|
||
if(check_vdata == 1){
|
||
printf("lone vdata should not be checked before.\n");
|
||
free(h5cvdata_name);
|
||
free(ref_vdata_array);
|
||
VSdetach(vdata_id);
|
||
return FAIL;
|
||
}
|
||
|
||
if(set_name(ref_vdata_array[lone_vd_number],estnum_vd,vd_hashtab,
|
||
h5cvdata_name)==FAIL) {
|
||
printf("error in setting lone vdata name. \n");
|
||
free(ref_vdata_array);
|
||
free(h5cvdata_name);
|
||
VSdetach(vdata_id);
|
||
return FAIL;
|
||
}
|
||
|
||
if(Vdata_h4_to_h5(file_id,vdata_id,h5group)== FAIL) {
|
||
printf("error in translating independent vdata into");
|
||
printf(" hdf5 datasets.\n");
|
||
free(h5cvdata_name);
|
||
free(ref_vdata_array);
|
||
VSdetach(vdata_id);
|
||
return FAIL;
|
||
}
|
||
free(h5cvdata_name);
|
||
}
|
||
|
||
VSdetach(vdata_id);
|
||
}
|
||
free(ref_vdata_array);
|
||
}
|
||
return SUCCEED;
|
||
}
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: h4toh5unvisitedsds
|
||
*
|
||
* Purpose: convert unvisited sds objects into hdf5 datasets and put these
|
||
datasets under hdf5 root group
|
||
This routine will cover old hdf file that doesn't have vgroups.
|
||
*
|
||
* Return: FAIL if failed, SUCCEED if successful.
|
||
*
|
||
* In :
|
||
sd_id: hdf sds id
|
||
h5root: hdf5 root id
|
||
h5_dimg: hdf5 dimensional scale group id
|
||
|
||
Out:
|
||
Modification:
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
|
||
|
||
int h4toh5unvisitedsds(int32 file_id,int32 sd_id,hid_t h5root,hid_t h5_dimg) {
|
||
|
||
int i;
|
||
int32 sds_id;/* sd dataset identifer*/
|
||
int32 sds_rank;/* sds dataset dimension rank.*/
|
||
int32 sds_dimsizes[DIM_HASHSIZE];/* array that contains the size of the each dimension in sds dataset.*/
|
||
int32 sds_dtype;/*sds dataset datatype.*/
|
||
int32 num_sdsattrs;/* number of sds attributes. */
|
||
char sds_name[MAX_NC_NAME];/* sds name.*/
|
||
char* cor_sdsname;
|
||
int32 obj_ref; /* obj reference number assigned to sds and images.*/
|
||
char refstr[MAXREF_LENGTH];/*object reference number in character string format.*/
|
||
int check_sds;/* flag to check whether this sds is visited. 1 for visited and 0 for non-visited.*/
|
||
char *h5csds_name;/* absolute path name of hdf5 dataset transferred from old sds.*/
|
||
|
||
if(sd_id == FAIL) {
|
||
printf("error: cannot start SD interface. \n");
|
||
return FAIL;
|
||
}
|
||
|
||
/* check all sds objects. */
|
||
for(i=0;i<num_sds;i++){
|
||
|
||
sds_id = SDselect(sd_id,i);
|
||
|
||
if (sds_id == FAIL) {
|
||
printf("error in obtaining sd id.\n");
|
||
return FAIL;
|
||
}
|
||
|
||
/* if this sds is dimensional scale, the converting should be ignored. */
|
||
if(SDiscoordvar(sds_id)) continue;
|
||
|
||
/* obtain sds information. */
|
||
if(SDgetinfo(sds_id,sds_name,&sds_rank,sds_dimsizes,
|
||
&sds_dtype,&num_sdsattrs)== FAIL) {
|
||
printf("error in obtaining SD info at ");
|
||
printf("the unvisited sds routine.\n");
|
||
SDendaccess(sds_id);
|
||
return FAIL;
|
||
}
|
||
|
||
/* obtain object reference number of the current sds dataset.*/
|
||
obj_ref = SDidtoref(sds_id);
|
||
if(obj_ref == FAIL) {
|
||
printf("error in obtaining sds object reference at ");
|
||
printf("the unvisited sds routine.\n");
|
||
SDendaccess(sds_id);
|
||
return FAIL;
|
||
}
|
||
|
||
/* convert object reference number into string format. */
|
||
if(conv_int_str(obj_ref,refstr) == FAIL) {
|
||
printf("error in converting integer into string.\n");
|
||
SDendaccess(sds_id);
|
||
return FAIL;
|
||
}
|
||
|
||
/* check whether the current sds is visited or not. */
|
||
check_sds = lookup(obj_ref,2*num_sds,sds_hashtab);
|
||
|
||
/* if not visited, we will do the convertion. */
|
||
|
||
if(check_sds == 0) {
|
||
/* since different hdf sds may hold the same name and it is also
|
||
legal that sds may not have a name; but for hdf5 dataset,
|
||
it must hold a name, so we will use get_obj_aboname to guarrtte
|
||
that each new hdf5 dataset converted from
|
||
sds objects will have a disabiguous name. */
|
||
|
||
/* checking whether vgroup name contains ORI_SLASH, changing into CHA_SLASH.*/
|
||
cor_sdsname = correct_name(sds_name);
|
||
if(cor_sdsname == NULL) {
|
||
printf("error in generating corrected sds name. \n");
|
||
SDendaccess(sds_id);
|
||
return FAIL;
|
||
}
|
||
h5csds_name = get_obj_aboname(cor_sdsname,refstr,NULL,HDF4_SDS);
|
||
if(h5csds_name == NULL) {
|
||
printf("error in obtaining sds name.\n");
|
||
SDendaccess(sds_id);
|
||
free(cor_sdsname);
|
||
return FAIL;
|
||
}
|
||
free(cor_sdsname);
|
||
/* put this name into hashtable. */
|
||
if(set_name(obj_ref,2*num_sds,sds_hashtab,h5csds_name)==FAIL) {
|
||
printf("error in setting object name.\n");
|
||
SDendaccess(sds_id);
|
||
free(h5csds_name);
|
||
return FAIL;
|
||
}
|
||
|
||
/* do the convertion from sds into hdf5 dataset.*/
|
||
if(Sds_h4_to_h5(file_id,sds_id,h5root,h5_dimg)== FAIL){
|
||
printf("error in translating sds into hdf5 dataset.\n");
|
||
SDendaccess(sds_id);
|
||
free(h5csds_name);
|
||
return FAIL;
|
||
}
|
||
free(h5csds_name);
|
||
}
|
||
SDendaccess(sds_id);
|
||
}
|
||
return SUCCEED;
|
||
}
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: h4toh5unvisitedimages
|
||
*
|
||
* Purpose: convert unvisited images into hdf5 dataset and put it
|
||
under hdf5 root group
|
||
This routine will cover old hdf file.
|
||
*
|
||
* Return: FAIL if failed, SUCCEED if successful.
|
||
*
|
||
* In :
|
||
file_id: hdf file id
|
||
h5_root: hdf5 root id
|
||
h5_palg: hdf5 palette group id
|
||
|
||
Out:
|
||
Modification:
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
int h4toh5unvisitedimages(int32 file_id,hid_t h5_root,hid_t h5_palg) {
|
||
|
||
int i;
|
||
int32 istat;
|
||
int32 gr_id;
|
||
int32 ri_id;/*raster image identifer.*/
|
||
char image_name[MAX_GR_NAME];/* image name.*/
|
||
char* cor_imagename;
|
||
int check_image;/* flag to check whether this image is visited. 1 for visited and 0 for non-visited.*/
|
||
int32 obj_ref; /* obj reference number assigned to sds and images.*/
|
||
char refstr[MAXREF_LENGTH];/*object reference number in character string format.*/
|
||
char *h5cimage_name;/* absolute path name of hdf5 dataset transferred from old image.*/
|
||
|
||
gr_id = GRstart(file_id);
|
||
if(gr_id == FAIL) {
|
||
printf("error in obtaining gr id. \n");
|
||
return FAIL;
|
||
}
|
||
|
||
/* check all images. */
|
||
for (i=0;i<num_images;i++) {
|
||
|
||
ri_id = GRselect(gr_id,i);
|
||
if(ri_id ==FAIL) {
|
||
printf("error in selecting gr interface.\n");
|
||
return FAIL;
|
||
}
|
||
|
||
/* obtain information of GR */
|
||
istat = GRgetiminfo(ri_id, image_name, NULL, NULL, NULL, NULL, NULL);
|
||
|
||
if(istat == FAIL) {
|
||
printf("error in getting GR images.\n");
|
||
GRendaccess(ri_id);
|
||
return FAIL;
|
||
}
|
||
|
||
/* obtain object reference number and convert it into string format. */
|
||
obj_ref = GRidtoref(ri_id);
|
||
if(obj_ref == 0) {
|
||
printf("error in obtaining image reference number");
|
||
printf(" at h4toh5unvisitedimages routine.\n");
|
||
GRendaccess(ri_id);
|
||
return FAIL;
|
||
}
|
||
|
||
if(conv_int_str(obj_ref,refstr)== FAIL) {
|
||
printf("error in converting object reference number");
|
||
printf(" into string at h4toh5unvisitedimages routine.\n");
|
||
GRendaccess(ri_id);
|
||
return FAIL;
|
||
}
|
||
|
||
/* check whether the current image is visited or not. */
|
||
check_image = lookup(obj_ref,2*num_images,gr_hashtab);
|
||
|
||
if(check_image == 0) {
|
||
|
||
/* since different hdf image may hold the same name and it is
|
||
also legal that an image may not have a name; but for hdf5
|
||
dataset, it must hold a name, so we will use get_obj_aboname
|
||
to guarrtte that each new hdf5 dataset converted from
|
||
image objects will have a disabiguous name. */
|
||
|
||
/* checking whether vgroup name contains ORI_SLASH,
|
||
changing into CHA_SLASH.*/
|
||
|
||
cor_imagename = correct_name(image_name);
|
||
if(cor_imagename == NULL) {
|
||
printf("error in generating corrected image name. \n");
|
||
GRendaccess(ri_id);
|
||
return FAIL;
|
||
}
|
||
h5cimage_name = get_obj_aboname(cor_imagename,refstr,NULL,
|
||
HDF4_IMAGE);
|
||
if(h5cimage_name == NULL) {
|
||
printf("error in getting image name.\n");
|
||
GRendaccess(ri_id);
|
||
free(cor_imagename);
|
||
return FAIL;
|
||
}
|
||
free(cor_imagename);
|
||
|
||
if(set_name(obj_ref,2*num_images,gr_hashtab,h5cimage_name)==FAIL) {
|
||
printf("error setting image name.\n");
|
||
GRendaccess(ri_id);
|
||
free(h5cimage_name);
|
||
return FAIL;
|
||
}
|
||
|
||
/* do the convertion from the image into hdf5 dataset.*/
|
||
if(Image_h4_to_h5(file_id,ri_id,h5_root,h5_palg)== FAIL) {
|
||
printf("error in transferring image name into hdf5 dataset.\n");
|
||
GRendaccess(ri_id);
|
||
free(h5cimage_name);
|
||
return FAIL;
|
||
}
|
||
free(h5cimage_name);
|
||
}
|
||
GRendaccess(ri_id);
|
||
}
|
||
return SUCCEED;
|
||
}
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: free_allhashmemory()
|
||
*
|
||
* Purpose: free memory allocated for all hashtables
|
||
*
|
||
* Return:
|
||
*
|
||
* In :
|
||
|
||
|
||
Out:
|
||
Modification:
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
|
||
void free_allhashmemory(){
|
||
|
||
if(estnum_vg != 0) freetable(estnum_vg,vg_hashtab);
|
||
if(estnum_vd != 0) freetable(estnum_vd,vd_hashtab);
|
||
|
||
if(num_sds !=0) {
|
||
freetable(2*num_sds,sds_hashtab);
|
||
freenametable(DIM_HASHSIZE,dim_hashtab);
|
||
}
|
||
|
||
if(num_images !=0) {
|
||
freetable(2*num_images,gr_hashtab);
|
||
freetable(PAL_HASHSIZE,pal_hashtab);
|
||
}
|
||
|
||
if(num_objects !=0) freenametable(num_objects,name_hashtab);
|
||
|
||
}
|
||
|
||
void PrintOptions_h4toh5(void)
|
||
{
|
||
fprintf(stderr,"\nh4toh5 -h (gives this print-out)\n");
|
||
fprintf(stderr,"h4toh5 file.hdf file.h5\n");
|
||
fprintf(stderr,"h4toh5 file.hdf\n");
|
||
}
|
||
|
||
/********The following routines are adapted from h5toh4 converter. *******/
|
||
/*****************************************************************************
|
||
|
||
Routine: test_file
|
||
|
||
Description: Test a file for read/write - ability.
|
||
|
||
Input: filename - Unix filename
|
||
|
||
Output: function return, global variable - errno
|
||
|
||
*****************************************************************************/
|
||
|
||
int test_file(char *filename,int oflag,mode_t mode)
|
||
{
|
||
int fid;
|
||
|
||
errno = 0;
|
||
|
||
fid = open(filename, oflag, mode);
|
||
if (fid < 0) {
|
||
perror(filename);
|
||
}
|
||
close(fid);
|
||
|
||
return errno;
|
||
|
||
}
|
||
|
||
|
||
/*****************************************************************************
|
||
|
||
Routine: test_dir
|
||
|
||
Description: Test pathway to determine if it is a directory
|
||
|
||
Input: path - pathname given
|
||
|
||
Output: function return TRUE/FALSE
|
||
|
||
*****************************************************************************/
|
||
|
||
int test_dir(char *path)
|
||
{
|
||
|
||
struct stat buf;
|
||
struct stat *buf_ptr;
|
||
int idir;
|
||
|
||
buf_ptr = &buf;
|
||
|
||
idir = stat(path, buf_ptr);
|
||
if (idir < 0) {
|
||
if (errno == 2) {
|
||
return 0;
|
||
} else {
|
||
perror(path);
|
||
}
|
||
}
|
||
|
||
return S_ISDIR(buf_ptr->st_mode);
|
||
}
|
||
|
||
/*****************************************************************************
|
||
|
||
Routine: BuildFilename()
|
||
|
||
Description: Build a filename with new extension
|
||
|
||
Input: filename - present filename
|
||
ext - extension to root of filename
|
||
|
||
Output: (filename:r).ext
|
||
|
||
*****************************************************************************/
|
||
|
||
char *BuildFilename(char *filename, char *ext)
|
||
{
|
||
/* build outgoing filename */
|
||
|
||
char *filename_out;
|
||
char *lastper_ptr, *lastdir_ptr;
|
||
int root_len;
|
||
|
||
lastper_ptr = strrchr(filename,'.');
|
||
lastdir_ptr = strrchr(filename,'/');
|
||
|
||
if ( lastper_ptr <= lastdir_ptr ) { /* no extension */
|
||
root_len = strlen(filename);
|
||
} else { /* existing extension */
|
||
root_len = (int)(lastper_ptr - filename);
|
||
}
|
||
|
||
filename_out = (char *)HDmalloc(root_len + strlen(ext) + 2);
|
||
filename_out = strncpy(filename_out, filename, (size_t)root_len);
|
||
filename_out[root_len] = '\0';
|
||
filename_out = strcat(filename_out,".");
|
||
filename_out = strcat(filename_out,ext);
|
||
|
||
return filename_out;
|
||
}
|
||
|
||
|