static int read_basic_type(const coda_cursor *cursor, void *dst) { int32 start[MAX_HDF4_VAR_DIMS]; int32 stride[MAX_HDF4_VAR_DIMS]; int32 edge[MAX_HDF4_VAR_DIMS]; long index; long i; index = cursor->stack[cursor->n - 1].index; assert(cursor->n > 1); switch (((coda_hdf4_type *)cursor->stack[cursor->n - 2].type)->tag) { case tag_hdf4_basic_type_array: { coda_cursor array_cursor; char *buffer; int native_type_size; long num_elements; /* we first read the whole array and then return only the requested element */ array_cursor = *cursor; array_cursor.n--; if (coda_cursor_get_num_elements(&array_cursor, &num_elements) != 0) { return -1; } assert(index < num_elements); native_type_size = get_native_type_size(((coda_hdf4_type *)cursor->stack[cursor->n - 1].type)->definition->read_type); buffer = malloc(num_elements * native_type_size); if (buffer == NULL) { coda_set_error(CODA_ERROR_OUT_OF_MEMORY, "out of memory (could not allocate %lu bytes) (%s:%u)", (long)(num_elements * native_type_size), __FILE__, __LINE__); return -1; } if (read_attribute(&array_cursor, buffer, -1) != 0) { free(buffer); return -1; } memcpy(dst, &buffer[index * native_type_size], native_type_size); free(buffer); } break; case tag_hdf4_attributes: case tag_hdf4_file_attributes: if (read_attribute(cursor, dst, -1) != 0) { return -1; } break; case tag_hdf4_GRImage: { coda_hdf4_GRImage *type; stride[0] = 1; stride[1] = 1; edge[0] = 1; edge[1] = 1; type = (coda_hdf4_GRImage *)cursor->stack[cursor->n - 2].type; if (type->ncomp != 1) { uint8 *buffer; int component_size; int component_index; component_size = get_native_type_size(type->basic_type->definition->read_type); /* HDF4 does not allow reading a single component of a GRImage, so we have to first read all * components and then return only the data item that was requested */ buffer = malloc(component_size * type->ncomp); if (buffer == NULL) { coda_set_error(CODA_ERROR_OUT_OF_MEMORY, "out of memory (could not allocate %lu bytes) (%s:%u)", (long)(component_size * type->ncomp), __FILE__, __LINE__); return -1; } component_index = index % type->ncomp; index /= type->ncomp; /* For GRImage data the first dimension is the fastest running */ start[0] = index % type->dim_sizes[0]; start[1] = index / type->dim_sizes[0]; if (GRreadimage(type->ri_id, start, stride, edge, buffer) != 0) { coda_set_error(CODA_ERROR_HDF4, NULL); free(buffer); return -1; } memcpy(dst, &buffer[component_index * component_size], component_size); free(buffer); } else { /* For GRImage data the first dimension is the fastest running */ start[0] = index % type->dim_sizes[0]; start[1] = index / type->dim_sizes[0]; if (GRreadimage(type->ri_id, start, stride, edge, dst) != 0) { coda_set_error(CODA_ERROR_HDF4, NULL); return -1; } } } break; case tag_hdf4_SDS: { coda_hdf4_SDS *type; type = (coda_hdf4_SDS *)cursor->stack[cursor->n - 2].type; if (type->rank == 0) { start[0] = 0; edge[1] = 1; } else { for (i = type->rank - 1; i >= 0; i--) { start[i] = index % type->dimsizes[i]; index /= type->dimsizes[i]; edge[i] = 1; } } if (SDreaddata(type->sds_id, start, NULL, edge, dst) != 0) { coda_set_error(CODA_ERROR_HDF4, NULL); return -1; } } break; case tag_hdf4_Vdata_field: { coda_hdf4_Vdata *type; coda_hdf4_Vdata_field *field_type; int record_pos; int order_pos; assert(cursor->n > 2); type = (coda_hdf4_Vdata *)cursor->stack[cursor->n - 3].type; field_type = (coda_hdf4_Vdata_field *)cursor->stack[cursor->n - 2].type; order_pos = index % field_type->order; record_pos = index / field_type->order; if (VSseek(type->vdata_id, record_pos) < 0) { coda_set_error(CODA_ERROR_HDF4, NULL); return -1; } if (VSsetfields(type->vdata_id, field_type->field_name) != 0) { coda_set_error(CODA_ERROR_HDF4, NULL); return -1; } if (field_type->order > 1) { /* HDF4 does not allow reading part of a vdata field, so we have to first read the full field and * then return only the data item that was requested */ uint8 *buffer; int element_size; int size; size = VSsizeof(type->vdata_id, field_type->field_name); if (size < 0) { coda_set_error(CODA_ERROR_HDF4, NULL); return -1; } buffer = malloc(size); if (buffer == NULL) { coda_set_error(CODA_ERROR_OUT_OF_MEMORY, "out of memory (could not allocate %lu bytes) (%s:%u)", (long)size, __FILE__, __LINE__); return -1; } if (VSread(type->vdata_id, buffer, 1, FULL_INTERLACE) < 0) { coda_set_error(CODA_ERROR_HDF4, NULL); free(buffer); return -1; } /* the size of a field element is the field size divided by the order of the field */ element_size = size / field_type->order; memcpy(dst, &buffer[order_pos * element_size], element_size); free(buffer); } else { if (VSread(type->vdata_id, (uint8 *)dst, 1, FULL_INTERLACE) < 0) { coda_set_error(CODA_ERROR_HDF4, NULL); return -1; } } } break; default: assert(0); exit(1); } return 0; }
//// [[Rcpp::export]] int binlist(int x) { int numbins = 0, *binnums = NULL; int i; int file_id,vdata_ref, vdata_id,numrecs,pvd_id; char PARAM[] = "chlor_a"; initbin(); /* Open the HDF file. */ file_id = Hopen("S1998001.L3b_DAY_CHL.main", DFACC_READ, 0); if(file_id == FAIL){ fprintf(stderr,"-E- %s line %d: Hopen(%s,DFACC_READ,0) failed.\n", __FILE__,__LINE__,"S1998001.L3b_DAY_CHL.main"); return(EXIT_FAILURE); } /* Initialize the Vdata interface. */ if(Vstart(file_id) == FAIL){ fprintf(stderr,"-E- %s line %d: Vstart(%d) failed.\n", __FILE__,__LINE__,file_id); return(EXIT_FAILURE); } /* Open the "BinList" Vdata. */ vdata_ref = VSfind(file_id,"BinList"); if(vdata_ref == FAIL){ fprintf(stderr,"-E- %s line %d: VSfind(%d,\"BinList\") failed.\n", __FILE__,__LINE__,file_id); return(EXIT_FAILURE); } vdata_id = VSattach(file_id, vdata_ref, "r"); if(vdata_id == FAIL){ fprintf(stderr,"-E- %s line %d: VSattach(%d,%d,\"r\") failed.\n", __FILE__,__LINE__,file_id,vdata_ref); return(EXIT_FAILURE); } /* Find out how many bins are stored in this file. */ numrecs = VSelts(vdata_id); if(numrecs == FAIL){ fprintf(stderr,"-E- %s line %d: VSelts(%d) failed.\n", __FILE__,__LINE__,vdata_id); return(EXIT_FAILURE); } // this doesn't seem to be necessary? /* Set up to read the fields in the BinList Vdata records. */ // if(VSsetfields(vdata_id,BLIST_FIELDS) == FAIL){ // fprintf(stderr,"-E- %s line %d: VSsetfields(%d,%s) failed.\n", // __FILE__,__LINE__,vdata_id,BLIST_FIELDS); // return(EXIT_FAILURE); // } /* Open the parameter-specific Vdata. */ vdata_ref = VSfind(file_id,PARAM); if(vdata_ref == 0){ fprintf(stderr,"-E- %s line %d: VSfind(%d,\"%s\") failed.\n", __FILE__,__LINE__,file_id,PARAM); return(EXIT_FAILURE); } pvd_id = VSattach(file_id, vdata_ref, "r"); if(pvd_id == FAIL){ fprintf(stderr,"-E- %s line %d: VSattach(%d,%d,\"r\") failed.\n", __FILE__,__LINE__,file_id,vdata_ref); return(EXIT_FAILURE); } /* Set up to read the fields in the parameter-specific Vdata records. */ { int len; len = 2*strlen(PARAM) + strlen("_sum,") + strlen("_sum_sq") + 1; param_fields = (char *)malloc(len); if(param_fields == NULL){ fprintf(stderr,"-E- %s line %d: Memory allocation failed.\n", __FILE__,__LINE__); return(EXIT_FAILURE); } strcpy(param_fields,PARAM); strcat(param_fields,"_sum,"); strcat(param_fields,PARAM); strcat(param_fields,"_sum_sq"); } if(VSsetfields(pvd_id,param_fields) == FAIL){ fprintf(stderr,"-E- %s line %d: VSsetfields(%d,%s) failed.\n", __FILE__,__LINE__,pvd_id,param_fields); return(EXIT_FAILURE); } printf(param_fields); printf("\n"); /* Output a header record to identify the fields written out below. */ printf("%80s%15.15s %15.15s\n"," ",PARAM,PARAM); printf(" bin centerlat centerlon"); printf(" north south west east"); printf(" n N sum_obs sum_squared_obs weight"); printf(" time_trend_bits l2_flag_bits sel\n"); printf("------- --------- ----------"); printf(" --------- --------- ---------- ----------"); printf(" ---- --- --------------- --------------- ---------------"); printf(" ---------------- -------------------------------- ---\n"); // for(i = 0; i < numbins; i++){ for(i = 0; i < 10; i++){ int recno; // recno = binsearch(binnums[i],vdata_id,numrecs); recno = i; if(recno >= 0){ double n,s,w,e,clat,clon; /* Read the sum and sum-of-squares for the the specified parameter for this bin. */ if(VSseek(pvd_id,recno) == FAIL){ fprintf(stderr,"-E- %s line %d: VSseek(%d,%d) failed.\n", __FILE__,__LINE__,pvd_id,recno); return(EXIT_FAILURE); } if(VSread(pvd_id,paramrec,1,FULL_INTERLACE) != 1){ fprintf(stderr,"-E- %s line %d: ",__FILE__,__LINE__); fprintf(stderr,"VSread(%d,paramrec,1,FULL_INTERLACE) failed.\n", pvd_id); return(EXIT_FAILURE); } /* VSfpack() sets the global sum and sum_sq variables via the paramptrs pointer array. */ if( VSfpack( pvd_id,_HDF_VSUNPACK,param_fields,paramrec,PREC_SIZE,1,NULL,paramptrs ) == FAIL){ fprintf(stderr,"-E- %s line %d: ",__FILE__,__LINE__); fprintf(stderr,"VSfpack(%d, ...) failed.\n", pvd_id); return(EXIT_FAILURE); } /* Get the geographical coordinates associated with this bin. */ // bin2latlon(binnums[i],&clat,&clon); // bin2bounds(binnums[i],&n,&s,&w,&e); /* Output the results. */ // printf("%7d %9.5f %10.5f %9.5f %9.5f %10.5f %10.5f ", // binnums[i],clat,clon,n,s,w,e); // printf("%4d %3d ",nobs,nscenes); // printf("% .8e % .8e % .8e ",sum,sum_sq,weights); printf("% .8e % .8e % .8e ",sum,sum_sq,0.0); // printf("%.16s %.32s ",bitstr16(time_rec),bitstr32(flags_set)); // printf("%3d",sel_cat); printf("\n"); } } if(VSdetach(pvd_id) == FAIL){ fprintf(stderr,"-E- %s line %d: VSdetach(%d) failed.\n", __FILE__,__LINE__,pvd_id); return(EXIT_FAILURE); } if(VSdetach(vdata_id) == FAIL){ fprintf(stderr,"-E- %s line %d: VSdetach(%d) failed.\n", __FILE__,__LINE__,vdata_id); return(EXIT_FAILURE); } if(Vend(file_id) == FAIL){ fprintf(stderr,"-E- %s line %d: Vend(%d) failed.\n", __FILE__,__LINE__,file_id); return(EXIT_FAILURE); } if(Hclose(file_id) == FAIL){ fprintf(stderr,"-E- %s line %d: Hclose(%d) failed.\n", __FILE__,__LINE__,file_id); return(EXIT_FAILURE); } free(param_fields); free(binnums); return 2; }
static int read_array(const coda_cursor *cursor, void *dst) { int32 start[MAX_HDF4_VAR_DIMS]; int32 stride[MAX_HDF4_VAR_DIMS]; int32 edge[MAX_HDF4_VAR_DIMS]; long num_elements; long i; if (coda_hdf4_cursor_get_num_elements(cursor, &num_elements) != 0) { return -1; } if (num_elements <= 0) { /* no data to be read */ return 0; } switch (((coda_hdf4_type *)cursor->stack[cursor->n - 1].type)->tag) { case tag_hdf4_basic_type_array: if (read_attribute(cursor, dst, -1) != 0) { return -1; } break; case tag_hdf4_GRImage: { coda_hdf4_GRImage *type; type = (coda_hdf4_GRImage *)cursor->stack[cursor->n - 1].type; start[0] = 0; start[1] = 0; stride[0] = 1; stride[1] = 1; edge[0] = type->dim_sizes[0]; edge[1] = type->dim_sizes[1]; if (GRreadimage(type->ri_id, start, stride, edge, dst) != 0) { coda_set_error(CODA_ERROR_HDF4, NULL); return -1; } } break; case tag_hdf4_SDS: { coda_hdf4_SDS *type; type = (coda_hdf4_SDS *)cursor->stack[cursor->n - 1].type; if (type->rank == 0) { start[0] = 0; edge[0] = 1; } else { for (i = 0; i < type->rank; i++) { start[i] = 0; edge[i] = type->dimsizes[i]; } } if (SDreaddata(type->sds_id, start, NULL, edge, dst) != 0) { coda_set_error(CODA_ERROR_HDF4, NULL); return -1; } } break; case tag_hdf4_Vdata_field: { coda_hdf4_Vdata *type; coda_hdf4_Vdata_field *field_type; assert(cursor->n > 1); type = (coda_hdf4_Vdata *)cursor->stack[cursor->n - 2].type; field_type = (coda_hdf4_Vdata_field *)cursor->stack[cursor->n - 1].type; if (VSseek(type->vdata_id, 0) < 0) { coda_set_error(CODA_ERROR_HDF4, NULL); return -1; } if (VSsetfields(type->vdata_id, field_type->field_name) != 0) { coda_set_error(CODA_ERROR_HDF4, NULL); return -1; } if (VSread(type->vdata_id, (uint8 *)dst, field_type->num_records, FULL_INTERLACE) < 0) { coda_set_error(CODA_ERROR_HDF4, NULL); return -1; } } break; default: assert(0); exit(1); } return 0; }
int main( ) { /************************* Variable declaration **************************/ intn status_n; /* returned status for functions returning an intn */ int32 status_32, /* returned status for functions returning an int32 */ file_id, vgroup_id, vgroup_ref, vdata_id, vdata_ref, num_of_records, num_of_vals_per_rec, record_pos, obj_index, /* index of an object within a vgroup */ num_of_pairs, /* number of tag/ref number pairs, i.e., objects */ obj_tag, obj_ref, /* tag/ref number of an HDF object */ vgroup_pos = 0; /* position of a vgroup in the file */ float32 databuf[N_RECORDS][N_VALS_PER_REC]; int16 rec_num; /********************** End of variable declaration ***********************/ char FIELDNAME_LIST[MAX_FIELDNAME_LIST_LENGTH]; memset(FIELDNAME_LIST, 0x00, MAX_FIELDNAME_LIST_LENGTH); int i; for (i = 0; i < N_VALS_PER_REC; i++) { char buffer[256]; if (i == 0) { sprintf(buffer, "%d", i); } else { sprintf(buffer, " %d", i); } strcat(FIELDNAME_LIST, buffer); } file_id = Hopen (FILE_NAME, DFACC_READ, 0); status_n = Vstart (file_id); vgroup_ref = -1; vgroup_ref = Vgetid (file_id, vgroup_ref); if (vgroup_ref == -1) exit(1); vgroup_ref = Vgetid (file_id, vgroup_ref); if (vgroup_ref == -1) exit(1); vgroup_id = Vattach (file_id, vgroup_ref, "r"); num_of_pairs = Vntagrefs (vgroup_id); if (num_of_pairs > 0) { printf ("\nVgroup #%d contains:\n", vgroup_pos); for (obj_index = 0; obj_index < num_of_pairs; obj_index++) { status_n = Vgettagref (vgroup_id, obj_index, &obj_tag, &obj_ref); printf ("tag = %d, ref = %d", obj_tag, obj_ref); if (Visvg (vgroup_id, obj_ref)) printf (" <-- is a vgroup\n"); else if (Visvs (vgroup_id, obj_ref)) { printf (" <-- is a vdata\n"); vdata_ref = VSfind (file_id, VDATA_NAME); vdata_id = VSattach (file_id, vdata_ref, "r"); status_n = VSsetfields (vdata_id, FIELDNAME_LIST); record_pos = VSseek (vdata_id, RECORD_INDEX); num_of_records = VSread (vdata_id, (uint8 *)databuf, N_RECORDS, FULL_INTERLACE); for (rec_num = 0; rec_num < num_of_records; rec_num++) { for (num_of_vals_per_rec = 0; num_of_vals_per_rec < N_VALS_PER_REC; num_of_vals_per_rec++) { printf ("%6.2f\n", databuf[rec_num][num_of_vals_per_rec]); } } } else { printf (" <-- neither vdata nor vgroup\n"); } } /* for */ } /* if */ else printf ("Vgroup #%d contains no HDF objects\n", vgroup_pos); /* * Terminate access to the current vgroup. */ status_32 = Vdetach (vgroup_id); /* * Move to the next vgroup position. */ vgroup_pos++; /* * Terminate access to the V interface and close the file. */ status_n = Vend (file_id); status_n = Hclose (file_id); return 0; }