18#include "config_hdf.h"
23#include <libdap/debug.h>
24#include <libdap/InternalErr.h>
27#include "HDFEOS2ArraySwathDimMapField.h"
28#include "HDF4RequestHandler.h"
29#define SIGNED_BYTE_TO_INT32 1
33HDFEOS2ArraySwathDimMapField::read ()
36 BESDEBUG(
"h4",
"Coming to HDFEOS2ArraySwathDimMapField read "<<endl);
40 bool check_pass_fileid_key = HDF4RequestHandler::get_pass_fileid();
53 int nelms = format_constraint(offset.data(),step.data(),count.data());
56 vector<int32>offset32;
57 offset32.resize(rank);
66 for (
int i = 0; i < rank; i++) {
67 offset32[i] = (int32) offset[i];
68 count32[i] = (int32) count[i];
69 step32[i] = (int32) step[i];
73 int32 (*openfunc) (
char *, intn);
74 intn (*closefunc) (int32);
75 int32 (*attachfunc) (int32,
char *);
76 intn (*detachfunc) (int32);
80 if (swathname ==
"") {
81 throw InternalErr (__FILE__, __LINE__,
"It should be either grid or swath.");
83 else if (gridname ==
"") {
86 attachfunc = SWattach;
87 detachfunc = SWdetach;
88 datasetname = swathname;
91 throw InternalErr (__FILE__, __LINE__,
"It should be either grid or swath.");
98 if (
true == isgeofile ||
false == check_pass_fileid_key) {
101 sfid = openfunc (
const_cast < char *
>(filename.c_str ()), DFACC_READ);
105 eherr <<
"File " << filename.c_str () <<
" cannot be open.";
106 throw InternalErr (__FILE__, __LINE__, eherr.str ());
112 swathid = attachfunc (sfid,
const_cast < char *
>(datasetname.c_str ()));
116 eherr <<
"Grid/Swath " << datasetname.c_str () <<
" cannot be attached.";
117 throw InternalErr (__FILE__, __LINE__, eherr.str ());
126 if(
true == dimmaps.empty()) {
132 if ((nummaps = SWnentries(swathid, HDFE_NENTMAP, &bufsize)) == -1){
135 throw InternalErr (__FILE__, __LINE__,
"cannot obtain the number of dimmaps");
141 throw InternalErr (__FILE__,__LINE__,
142 "Number of dimension maps should be greater than 0");
145 vector<char> namelist;
146 vector<int32> map_offset;
147 vector<int32> increment;
149 namelist.resize(bufsize + 1);
150 map_offset.resize(nummaps);
151 increment.resize(nummaps);
152 if (SWinqmaps(swathid, namelist.data(), map_offset.data(), increment.data())
156 throw InternalErr (__FILE__,__LINE__,
"fail to inquiry dimension maps");
159 vector<string> mapnames;
163 for (vector<string>::const_iterator i = mapnames.begin();
164 i != mapnames.end(); ++i) {
166 for (
auto const &mapname:mapnames) {
167 vector<string> parts;
169 if (parts.size() != 2){
172 throw InternalErr (__FILE__,__LINE__,
"the dimmaps should only include two parts");
176 tempdimmap.geodim = parts[0];
177 tempdimmap.datadim = parts[1];
178 tempdimmap.offset = map_offset[map_count];
179 tempdimmap.inc = increment[map_count];
187 dimmaps.push_back(tempdimmap);
193for(
int i = 0; i <dimmaps.size();i++) {
194cerr<<
"dimmap geodim is: "<<dimmaps[i].geodim <<endl;
195cerr<<
"dimmap datadim is: "<<dimmaps[i].datadim <<endl;
196cerr<<
"offset is: "<<dimmaps[i].offset <<endl;
197cerr<<
"inc is: "<<dimmaps[i].inc <<endl;
205 if (sotype!=DEFAULT_CF_EQU) {
207 if(
"MODIS_SWATH_Type_L1B" == swathname) {
209 string emissive_str =
"Emissive";
210 string RefSB_str =
"RefSB";
211 bool is_emissive_field =
false;
212 bool is_refsb_field =
false;
214 if(fieldname.find(emissive_str)!=string::npos) {
215 if(0 == fieldname.compare(fieldname.size()-emissive_str.size(),
216 emissive_str.size(),emissive_str))
217 is_emissive_field =
true;
220 if(fieldname.find(RefSB_str)!=string::npos) {
221 if(0 == fieldname.compare(fieldname.size()-RefSB_str.size(),
222 RefSB_str.size(),RefSB_str))
223 is_refsb_field =
true;
226 if ((
true == is_emissive_field) || (
true == is_refsb_field)) {
229 throw InternalErr (__FILE__, __LINE__,
230 "Currently don't support MODIS Level 1B swath dim. map for data ");
235 bool is_modis1b =
false;
236 if(
"MODIS_SWATH_Type_L1B" == swathname)
241 if(
true == HDF4RequestHandler::get_disable_scaleoffset_comp() &&
false== is_modis1b)
242 write_dap_data_disable_scale_comp(swathid,nelms,offset32,count32,step32);
244 write_dap_data_scale_comp(swathid,nelms,offset32,count32,step32);
253 r = detachfunc (swathid);
258 eherr <<
"Grid/Swath " << datasetname.c_str () <<
" cannot be detached.";
259 throw InternalErr (__FILE__, __LINE__, eherr.str ());
263 if(
true == isgeofile ||
false == check_pass_fileid_key) {
264 r = closefunc (sfid);
267 eherr <<
"Grid/Swath " << filename.c_str () <<
" cannot be closed.";
268 throw InternalErr (__FILE__, __LINE__, eherr.str ());
279HDFEOS2ArraySwathDimMapField::format_constraint (
int *offset,
int *step,
int *count)
284 Dim_iter p = dim_begin ();
285 while (p != dim_end ()) {
287 int start = dimension_start (p,
true);
288 int stride = dimension_stride (p,
true);
289 int stop = dimension_stop (p,
true);
294 oss <<
"Array/Grid hyperslab start point "<< start <<
295 " is greater than stop point " << stop <<
".";
296 throw Error(malformed_expr, oss.str());
301 count[id] = ((stop - start) / stride) + 1;
305 "=format_constraint():"
306 <<
"id=" <<
id <<
" offset=" << offset[
id]
307 <<
" step=" << step[
id]
308 <<
" count=" << count[
id]
320template <
class T >
int
321HDFEOS2ArraySwathDimMapField::
322GetFieldValue (int32 swathid,
const string & geofieldname,
323 vector < struct dimmap_entry >&sw_dimmaps,
324 vector < T > &vals, vector<int32>&newdims)
336 ret = SWfieldinfo (swathid,
const_cast < char *
>(geofieldname.c_str ()),
337 &sw_rank, dims, &type, dimlist);
342 for (
int i = 0; i <sw_rank; i++)
347 ret = SWreadfield (swathid,
const_cast < char *
>(geofieldname.c_str ()),
348 NULL, NULL, NULL, (
void *) vals.data());
352 vector < string > dimname;
355 for (
int i = 0; i < sw_rank; i++) {
356 vector < struct dimmap_entry >::iterator it;
358 for (it = sw_dimmaps.begin (); it != sw_dimmaps.end (); it++) {
359 if (it->geodim == dimname[i]) {
365 int32 ddimsize = SWdiminfo (swathid, (
char *) it->datadim.c_str ());
370 r = _expand_dimmap_field (&vals, sw_rank, dims, i, ddimsize, it->offset, it->inc);
378 for (
int i = 0; i < sw_rank; i++) {
381 newdims[i] = dims[i];
388template <
class T >
int
389HDFEOS2ArraySwathDimMapField::_expand_dimmap_field (vector < T >
390 *pvals, int32 sw_rank,
397 vector < T > orig = *pvals;
398 vector < int32 > pos;
399 vector < int32 > dims;
400 vector < int32 > newdims;
401 pos.resize (sw_rank);
402 dims.resize (sw_rank);
404 for (
int i = 0; i < sw_rank; i++) {
409 newdims[dimindex] = ddimsize;
410 dimsa[dimindex] = ddimsize;
414 for (
int i = 0; i < sw_rank; i++) {
415 newsize *= newdims[i];
418 pvals->resize (newsize);
422 if (pos[0] == dims[0]) {
426 else if (pos[dimindex] == 0) {
429 for (
int i = 0; i < dims[dimindex]; i++) {
431 v.push_back (orig[INDEX_nD_TO_1D (dims, pos)]);
436 for (int32 j = 0; j < ddimsize; j++) {
437 int32 i = (j - offset) / inc;
440 if (i * inc + offset == j)
446 int32 i2 = (i<=0)?1:0;
456 if ((
unsigned int) i + 1 >= v.size ()) {
464 j1 = i1 * inc + offset;
465 j2 = i2 * inc + offset;
466 f = (((j - j1) * v[i2] + (j2 - j) * v[i1]) / (j2 - j1));
470 (*pvals)[INDEX_nD_TO_1D (newdims, pos)] = f;
476 for (
int i = sw_rank - 1; i > 0; i--) {
477 if (pos[i] == dims[i]) {
488bool HDFEOS2ArraySwathDimMapField::FieldSubset (T * outlatlon,
489 const vector<int32>&newdims,
491 const int32 * offset,
496 if (newdims.size() == 1)
497 Field1DSubset(outlatlon,newdims[0],latlon,offset,count,step);
498 else if (newdims.size() == 2)
499 Field2DSubset(outlatlon,newdims[0],newdims[1],latlon,offset,count,step);
500 else if (newdims.size() == 3)
501 Field3DSubset(outlatlon,newdims,latlon,offset,count,step);
503 throw InternalErr(__FILE__, __LINE__,
504 "Currently doesn't support rank >3 when interpolating with dimension map");
511bool HDFEOS2ArraySwathDimMapField::Field1DSubset (T * outlatlon,
514 const int32 * offset,
518 if (majordim < count[0])
519 throw InternalErr(__FILE__, __LINE__,
520 "The number of elements is greater than the total dimensional size");
522 for (
int i = 0; i < count[0]; i++)
523 outlatlon[i] = latlon[offset[0]+i*step[0]];
530bool HDFEOS2ArraySwathDimMapField::Field2DSubset (T * outlatlon,
534 const int32 * offset,
539 T (*templatlonptr)[majordim][minordim] = (T *[][]) latlon;
546 int dim0count = count[0];
547 int dim1count = count[1];
549 int dim0index[dim0count];
550 int dim1index[dim1count];
552 for (i = 0; i < count[0]; i++)
553 dim0index[i] = offset[0] + i * step[0];
556 for (j = 0; j < count[1]; j++)
557 dim1index[j] = offset[1] + j * step[1];
562 for (i = 0; i < count[0]; i++) {
563 for (j = 0; j < count[1]; j++) {
565 outlatlon[k] = (*templatlonptr)[dim0index[i]][dim1index[j]];
567 outlatlon[k] = *(latlon + (dim0index[i] * minordim) + dim1index[j]);
576bool HDFEOS2ArraySwathDimMapField::Field3DSubset (T * outlatlon,
577 const vector<int32>& newdims,
579 const int32 * offset,
583 if (newdims.size() !=3)
584 throw InternalErr(__FILE__, __LINE__,
585 "the rank must be 3 to call this function");
587 T (*templatlonptr)[newdims[0]][newdims[1]][newdims[2]] = (T *[][][]) latlon;
595 int dim0count = count[0];
596 int dim1count = count[1];
597 int dim2count = count[2];
599 int dim0index[dim0count];
600 int dim1index[dim1count];
601 int dim2index[dim2count];
603 for (i = 0; i < count[0]; i++)
604 dim0index[i] = offset[0] + i * step[0];
607 for (j = 0; j < count[1]; j++)
608 dim1index[j] = offset[1] + j * step[1];
610 for (k = 0; k < count[2]; k++)
611 dim2index[k] = offset[2] + k * step[2];
616 for (i = 0; i < count[0]; i++) {
617 for (j = 0; j < count[1]; j++) {
618 for (k =0; k < count[2]; k++) {
620 outlatlon[l] = (*templatlonptr)[dim0index[i]][dim1index[j]][dim2index[k]];
622 outlatlon[l] = *(latlon + (dim0index[i] * newdims[1] * newdims[2]) + (dim1index[j] * newdims[2])+ dim2index[k]);
631HDFEOS2ArraySwathDimMapField::write_dap_data_scale_comp(int32 swathid,
633 vector<int32>& offset32,
634 vector<int32>& count32,
635 vector<int32>& step32) {
638 string check_pass_fileid_key_str=
"H4.EnablePassFileID";
639 bool check_pass_fileid_key =
false;
640 check_pass_fileid_key = HDFCFUtil::check_beskeys(check_pass_fileid_key_str);
643 bool check_pass_fileid_key = HDF4RequestHandler::get_pass_fileid();
646 intn (*fieldinfofunc) (int32,
char *, int32 *, int32 *, int32 *,
char *);
649 fieldinfofunc = SWfieldinfo;
652 int32 attrcount = -1;
653 int32 attrindex = -1;
655 int32 scale_factor_attr_index = -1;
656 int32 add_offset_attr_index =-1;
660 float fillvalue = 0.;
662 if (sotype!=DEFAULT_CF_EQU) {
667 if (
true == isgeofile ||
false == check_pass_fileid_key) {
668 sdfileid = SDstart(filename.c_str (), DFACC_READ);
669 if (FAIL == sdfileid) {
671 eherr <<
"Cannot Start the SD interface for the file " << filename <<endl;
672 throw InternalErr (__FILE__, __LINE__, eherr.str ());
681 sdsindex = SDnametoindex(sdfileid, fieldname.c_str());
682 if (FAIL == sdsindex) {
683 if(
true == isgeofile ||
false == check_pass_fileid_key)
686 eherr <<
"Cannot obtain the index of " << fieldname;
687 throw InternalErr (__FILE__, __LINE__, eherr.str ());
690 sdsid = SDselect(sdfileid, sdsindex);
692 if(
true == isgeofile ||
false == check_pass_fileid_key)
695 eherr <<
"Cannot obtain the SDS ID of " << fieldname;
696 throw InternalErr (__FILE__, __LINE__, eherr.str ());
699 char attrname[H4_MAX_NC_NAME + 1];
700 vector<char> attrbuf;
701 vector<char> attrbuf2;
703 scale_factor_attr_index = SDfindattr(sdsid,
"scale_factor");
704 if(scale_factor_attr_index!=FAIL)
707 ret = SDattrinfo(sdsid, scale_factor_attr_index, attrname, &attrtype, &attrcount);
711 if(
true == isgeofile ||
false == check_pass_fileid_key)
714 eherr <<
"Attribute 'scale_factor' in "
715 << fieldname.c_str () <<
" cannot be obtained.";
716 throw InternalErr (__FILE__, __LINE__, eherr.str ());
720 attrbuf.resize(DFKNTsize(attrtype)*attrcount);
721 ret = SDreadattr(sdsid, scale_factor_attr_index, (VOIDP)attrbuf.data());
725 if(
true == isgeofile ||
false == check_pass_fileid_key)
728 eherr <<
"Attribute 'scale_factor' in "
729 << fieldname.c_str () <<
" cannot be obtained.";
730 throw InternalErr (__FILE__, __LINE__, eherr.str ());
740#define GET_SCALE_FACTOR_ATTR_VALUE(TYPE, CAST) \
743 CAST tmpvalue = *(CAST*)attrbuf.data(); \
744 scale = (float)tmpvalue; \
747 GET_SCALE_FACTOR_ATTR_VALUE(FLOAT32,
float)
748 GET_SCALE_FACTOR_ATTR_VALUE(FLOAT64,
double)
750 throw InternalErr(__FILE__,__LINE__,
"unsupported data type.");
754#undef GET_SCALE_FACTOR_ATTR_VALUE
757 add_offset_attr_index = SDfindattr(sdsid,
"add_offset");
758 if(add_offset_attr_index!=FAIL)
761 ret = SDattrinfo(sdsid, add_offset_attr_index, attrname, &attrtype, &attrcount);
765 if(
true == isgeofile ||
false == check_pass_fileid_key)
768 eherr <<
"Attribute 'add_offset' in "
769 << fieldname.c_str () <<
" cannot be obtained.";
770 throw InternalErr (__FILE__, __LINE__, eherr.str ());
773 attrbuf.resize(DFKNTsize(attrtype)*attrcount);
774 ret = SDreadattr(sdsid, add_offset_attr_index, (VOIDP)attrbuf.data());
778 if(
true == isgeofile ||
false == check_pass_fileid_key)
781 eherr <<
"Attribute 'add_offset' in "
782 << fieldname.c_str () <<
" cannot be obtained.";
783 throw InternalErr (__FILE__, __LINE__, eherr.str ());
787#define GET_ADD_OFFSET_ATTR_VALUE(TYPE, CAST) \
790 CAST tmpvalue = *(CAST*)attrbuf.data(); \
791 offset2 = (float)tmpvalue; \
794 GET_ADD_OFFSET_ATTR_VALUE(FLOAT32,
float)
795 GET_ADD_OFFSET_ATTR_VALUE(FLOAT64,
double)
797 throw InternalErr(__FILE__,__LINE__,
"unsupported data type.");
799#undef GET_ADD_OFFSET_ATTR_VALUE
802 attrindex = SDfindattr(sdsid,
"_FillValue");
803 if(sotype!=DEFAULT_CF_EQU && attrindex!=FAIL)
806 ret = SDattrinfo(sdsid, attrindex, attrname, &attrtype, &attrcount);
810 if(
true == isgeofile ||
false == check_pass_fileid_key)
813 eherr <<
"Attribute '_FillValue' in "
814 << fieldname.c_str () <<
" cannot be obtained.";
815 throw InternalErr (__FILE__, __LINE__, eherr.str ());
818 attrbuf.resize(DFKNTsize(attrtype)*attrcount);
819 ret = SDreadattr(sdsid, attrindex, (VOIDP)attrbuf.data());
823 if(
true == isgeofile ||
false == check_pass_fileid_key)
826 eherr <<
"Attribute '_FillValue' in "
827 << fieldname.c_str () <<
" cannot be obtained.";
828 throw InternalErr (__FILE__, __LINE__, eherr.str ());
833#define GET_FILLVALUE_ATTR_VALUE(TYPE, CAST) \
836 CAST tmpvalue = *(CAST*)attrbuf.data(); \
837 fillvalue = (float)tmpvalue; \
840 GET_FILLVALUE_ATTR_VALUE(INT8, int8)
841 GET_FILLVALUE_ATTR_VALUE(INT16, int16)
842 GET_FILLVALUE_ATTR_VALUE(INT32, int32)
843 GET_FILLVALUE_ATTR_VALUE(UINT8, uint8)
844 GET_FILLVALUE_ATTR_VALUE(UINT16, uint16)
845 GET_FILLVALUE_ATTR_VALUE(UINT32, uint32)
854#undef GET_FILLVALUE_ATTR_VALUE
861 float orig_valid_min = 0.;
862 float orig_valid_max = 0.;
868 attrindex = SDfindattr(sdsid,
"valid_range");
872 ret = SDattrinfo(sdsid, attrindex, attrname, &attrtype, &attrcount);
880 eherr <<
"Attribute '_FillValue' in " << fieldname.c_str () <<
" cannot be obtained.";
881 throw InternalErr (__FILE__, __LINE__, eherr.str ());
884 attrbuf.resize(DFKNTsize(attrtype)*attrcount);
885 ret = SDreadattr(sdsid, attrindex, (VOIDP)attrbuf.data());
893 eherr <<
"Attribute '_FillValue' in " << fieldname.c_str () <<
" cannot be obtained.";
894 throw InternalErr (__FILE__, __LINE__, eherr.str ());
897 string attrbuf_str(attrbuf.begin(),attrbuf.end());
905 size_t found = attrbuf_str.find_first_of(
",");
906 size_t found_from_end = attrbuf_str.find_last_of(
",");
908 if (string::npos == found)
909 throw InternalErr(__FILE__,__LINE__,
"should find the separator ,");
910 if (found != found_from_end)
911 throw InternalErr(__FILE__,__LINE__,
"Only one separator , should be available.");
916 orig_valid_min = atof((attrbuf_str.substr(0,found)).c_str());
917 orig_valid_max = atof((attrbuf_str.substr(found+1)).c_str());
924 if (2 == temp_attrcount) {
925 orig_valid_min = (float)attrbuf[0];
926 orig_valid_max = (float)attrbuf[1];
929 throw InternalErr(__FILE__,__LINE__,
"The number of attribute count should be greater than 1.");
937 if (temp_attrcount != 2)
938 throw InternalErr(__FILE__,__LINE__,
"The number of attribute count should be 2 for the DFNT_UINT8 type.");
940 unsigned char* temp_valid_range = (
unsigned char *)attrbuf.data();
941 orig_valid_min = (float)(temp_valid_range[0]);
942 orig_valid_max = (float)(temp_valid_range[1]);
948 if (temp_attrcount != 2)
949 throw InternalErr(__FILE__,__LINE__,
"The number of attribute count should be 2 for the DFNT_INT16 type.");
951 short* temp_valid_range = (
short *)attrbuf.data();
952 orig_valid_min = (float)(temp_valid_range[0]);
953 orig_valid_max = (float)(temp_valid_range[1]);
959 if (temp_attrcount != 2)
960 throw InternalErr(__FILE__,__LINE__,
"The number of attribute count should be 2 for the DFNT_UINT16 type.");
962 unsigned short* temp_valid_range = (
unsigned short *)attrbuf.data();
963 orig_valid_min = (float)(temp_valid_range[0]);
964 orig_valid_max = (float)(temp_valid_range[1]);
970 if (temp_attrcount != 2)
971 throw InternalErr(__FILE__,__LINE__,
"The number of attribute count should be 2 for the DFNT_INT32 type.");
973 int* temp_valid_range = (
int *)attrbuf.data();
974 orig_valid_min = (float)(temp_valid_range[0]);
975 orig_valid_max = (float)(temp_valid_range[1]);
981 if (temp_attrcount != 2)
982 throw InternalErr(__FILE__,__LINE__,
"The number of attribute count should be 2 for the DFNT_UINT32 type.");
984 unsigned int* temp_valid_range = (
unsigned int *)attrbuf.data();
985 orig_valid_min = (float)(temp_valid_range[0]);
986 orig_valid_max = (float)(temp_valid_range[1]);
992 if (temp_attrcount != 2)
993 throw InternalErr(__FILE__,__LINE__,
"The number of attribute count should be 2 for the DFNT_FLOAT32 type.");
995 float* temp_valid_range = (
float *)attrbuf.data();
996 orig_valid_min = temp_valid_range[0];
997 orig_valid_max = temp_valid_range[1];
1003 if (temp_attrcount != 2)
1004 throw InternalErr(__FILE__,__LINE__,
"The number of attribute count should be 2 for the DFNT_FLOAT32 type.");
1005 double* temp_valid_range = (
double *)attrbuf.data();
1010 orig_valid_min = temp_valid_range[0];
1011 orig_valid_max = temp_valid_range[1];
1015 throw InternalErr(__FILE__,__LINE__,
"Unsupported data type.");
1030 if(
true == isgeofile ||
false == check_pass_fileid_key)
1062 if (MODIS_EQ_SCALE == sotype || MODIS_MUL_SCALE == sotype) {
1064 sotype = MODIS_DIV_SCALE;
1065 (*BESLog::TheLog())<<
"The field " << fieldname <<
" scale factor is "
1067 <<
" But the original scale factor type is MODIS_MUL_SCALE or MODIS_EQ_SCALE. "
1069 <<
" Now change it to MODIS_DIV_SCALE. "<<endl;
1073 if (MODIS_DIV_SCALE == sotype) {
1075 sotype = MODIS_MUL_SCALE;
1076 (*BESLog::TheLog())<<
"The field " << fieldname <<
" scale factor is "
1078 <<
" But the original scale factor type is MODIS_DIV_SCALE. "
1080 <<
" Now change it to MODIS_MUL_SCALE. "<<endl;
1097#define RECALCULATE(CAST, DODS_CAST, VAL) \
1099 bool change_data_value = false; \
1100 if(sotype!=DEFAULT_CF_EQU) \
1102 if(scale_factor_attr_index!=FAIL && !(scale==1 && offset2==0)) \
1104 vector<float>tmpval; \
1105 tmpval.resize(nelms); \
1106 CAST tmptr = (CAST)VAL; \
1107 for(int l=0; l<nelms; l++) \
1108 tmpval[l] = (float)tmptr[l]; \
1109 float temp_scale = scale; \
1110 float temp_offset = offset2; \
1111 if(sotype==MODIS_MUL_SCALE) \
1112 temp_offset = -1. *offset2*temp_scale;\
1113 else if (sotype==MODIS_DIV_SCALE) \
1115 temp_scale = 1/scale; \
1116 temp_offset = -1. *temp_scale *offset2;\
1118 for(int l=0; l<nelms; l++) \
1119 if(attrindex!=FAIL && ((float)tmptr[l])!=fillvalue) \
1120 tmpval[l] = tmptr[l]*temp_scale + temp_offset; \
1121 change_data_value = true; \
1122 set_value((dods_float32 *)tmpval.data(), nelms); \
1125 if(!change_data_value) \
1127 set_value ((DODS_CAST)VAL, nelms); \
1134 char tmp_dimlist[1024];
1137 int32 tmp_dims[rank];
1140 int32 field_dtype = 0;
1147 r = fieldinfofunc (swathid,
const_cast < char *
>(fieldname.c_str ()),
1148 &tmp_rank, tmp_dims, &field_dtype, tmp_dimlist);
1150 ostringstream eherr;
1151 eherr <<
"Field " << fieldname.c_str ()
1152 <<
" information cannot be obtained.";
1153 throw InternalErr (__FILE__, __LINE__, eherr.str ());
1158 vector<int32> newdims;
1159 newdims.resize(rank);
1162 switch (field_dtype) {
1168 vector < int8 > total_val8;
1169 r = GetFieldValue (swathid, fieldname, dimmaps, total_val8, newdims);
1171 ostringstream eherr;
1172 eherr <<
"field " << fieldname.c_str ()
1173 <<
"cannot be read.";
1174 throw InternalErr (__FILE__, __LINE__, eherr.str ());
1177 check_num_elems_constraint(nelms,newdims);
1182 FieldSubset (val8.data(), newdims, total_val8.data(),
1183 offset32.data(), count32.data(), step32.data());
1185#ifndef SIGNED_BYTE_TO_INT32
1186 RECALCULATE(int8*, dods_byte*, val8.data());
1188 vector<int32>newval;
1189 newval.resize(nelms);
1191 for (
int counter = 0; counter < nelms; counter++)
1192 newval[counter] = (int32) (val8[counter]);
1194 RECALCULATE(int32*, dods_int32*, newval.data());
1203 vector < uint8 > total_val_u8;
1204 r = GetFieldValue (swathid, fieldname, dimmaps, total_val_u8, newdims);
1206 ostringstream eherr;
1207 eherr <<
"field " << fieldname.c_str () <<
"cannot be read.";
1208 throw InternalErr (__FILE__, __LINE__, eherr.str ());
1211 check_num_elems_constraint(nelms,newdims);
1212 vector<uint8>val_u8;
1213 val_u8.resize(nelms);
1215 FieldSubset (val_u8.data(), newdims, total_val_u8.data(),
1216 offset32.data(), count32.data(), step32.data());
1217 RECALCULATE(uint8*, dods_byte*, val_u8.data());
1224 vector < int16 > total_val16;
1225 r = GetFieldValue (swathid, fieldname, dimmaps, total_val16, newdims);
1227 ostringstream eherr;
1228 eherr <<
"field " << fieldname.c_str () <<
"cannot be read.";
1229 throw InternalErr (__FILE__, __LINE__, eherr.str ());
1232 check_num_elems_constraint(nelms,newdims);
1234 val16.resize(nelms);
1236 FieldSubset (val16.data(), newdims, total_val16.data(),
1237 offset32.data(), count32.data(), step32.data());
1239 RECALCULATE(int16*, dods_int16*, val16.data());
1246 vector < uint16 > total_val_u16;
1247 r = GetFieldValue (swathid, fieldname, dimmaps, total_val_u16, newdims);
1249 ostringstream eherr;
1251 eherr <<
"field " << fieldname.c_str () <<
"cannot be read.";
1252 throw InternalErr (__FILE__, __LINE__, eherr.str ());
1255 check_num_elems_constraint(nelms,newdims);
1256 vector<uint16>val_u16;
1257 val_u16.resize(nelms);
1259 FieldSubset (val_u16.data(), newdims, total_val_u16.data(),
1260 offset32.data(), count32.data(), step32.data());
1261 RECALCULATE(uint16*, dods_uint16*, val_u16.data());
1269 vector < int32 > total_val32;
1270 r = GetFieldValue (swathid, fieldname, dimmaps, total_val32, newdims);
1272 ostringstream eherr;
1274 eherr <<
"field " << fieldname.c_str () <<
"cannot be read.";
1275 throw InternalErr (__FILE__, __LINE__, eherr.str ());
1278 check_num_elems_constraint(nelms,newdims);
1279 vector<int32> val32;
1280 val32.resize(nelms);
1282 FieldSubset (val32.data(), newdims, total_val32.data(),
1283 offset32.data(), count32.data(), step32.data());
1285 RECALCULATE(int32*, dods_int32*, val32.data());
1293 vector < uint32 > total_val_u32;
1294 r = GetFieldValue (swathid, fieldname, dimmaps, total_val_u32, newdims);
1296 ostringstream eherr;
1297 eherr <<
"field " << fieldname.c_str () <<
"cannot be read.";
1298 throw InternalErr (__FILE__, __LINE__, eherr.str ());
1301 check_num_elems_constraint(nelms,newdims);
1302 vector<uint32>val_u32;
1303 val_u32.resize(nelms);
1305 FieldSubset (val_u32.data(), newdims, total_val_u32.data(),
1306 offset32.data(), count32.data(), step32.data());
1307 RECALCULATE(uint32*, dods_uint32*, val_u32.data());
1315 vector < float32 > total_val_f32;
1316 r = GetFieldValue (swathid, fieldname, dimmaps, total_val_f32, newdims);
1318 ostringstream eherr;
1319 eherr <<
"field " << fieldname.c_str () <<
"cannot be read.";
1320 throw InternalErr (__FILE__, __LINE__, eherr.str ());
1323 check_num_elems_constraint(nelms,newdims);
1324 vector<float32>val_f32;
1325 val_f32.resize(nelms);
1327 FieldSubset (val_f32.data(), newdims, total_val_f32.data(),
1328 offset32.data(), count32.data(), step32.data());
1329 RECALCULATE(float32*, dods_float32*, val_f32.data());
1335 vector < float64 > total_val_f64;
1336 r = GetFieldValue (swathid, fieldname, dimmaps, total_val_f64, newdims);
1338 ostringstream eherr;
1339 eherr <<
"field " << fieldname.c_str () <<
"cannot be read.";
1340 throw InternalErr (__FILE__, __LINE__, eherr.str ());
1343 check_num_elems_constraint(nelms,newdims);
1344 vector<float64>val_f64;
1345 val_f64.resize(nelms);
1346 FieldSubset (val_f64.data(), newdims, total_val_f64.data(),
1347 offset32.data(), count32.data(), step32.data());
1348 RECALCULATE(float64*, dods_float64*, val_f64.data());
1354 throw InternalErr (__FILE__, __LINE__,
"unsupported data type.");
1362HDFEOS2ArraySwathDimMapField::write_dap_data_disable_scale_comp(int32 swathid,
1364 vector<int32>& offset32,
1365 vector<int32>& count32,
1366 vector<int32>& step32) {
1369 intn (*fieldinfofunc) (int32,
char *, int32 *, int32 *, int32 *,
char *);
1371 fieldinfofunc = SWfieldinfo;
1377 char tmp_dimlist[1024];
1380 int32 tmp_dims[rank];
1383 int32 field_dtype = 0;
1390 r = fieldinfofunc (swathid,
const_cast < char *
>(fieldname.c_str ()),
1391 &tmp_rank, tmp_dims, &field_dtype, tmp_dimlist);
1393 ostringstream eherr;
1394 eherr <<
"Field " << fieldname.c_str () <<
" information cannot be obtained.";
1395 throw InternalErr (__FILE__, __LINE__, eherr.str ());
1400 vector<int32> newdims;
1401 newdims.resize(rank);
1404 switch (field_dtype) {
1409 vector < int8 > total_val8;
1410 r = GetFieldValue (swathid, fieldname, dimmaps, total_val8, newdims);
1412 ostringstream eherr;
1413 eherr <<
"field " << fieldname.c_str () <<
"cannot be read.";
1414 throw InternalErr (__FILE__, __LINE__, eherr.str ());
1417 check_num_elems_constraint(nelms,newdims);
1421 FieldSubset (val8.data(), newdims, total_val8.data(),
1422 offset32.data(), count32.data(), step32.data());
1425#ifndef SIGNED_BYTE_TO_INT32
1426 set_value((dods_byte*)val8.data(),nelms);
1428 vector<int32>newval;
1429 newval.resize(nelms);
1431 for (
int counter = 0; counter < nelms; counter++)
1432 newval[counter] = (int32) (val8[counter]);
1434 set_value ((dods_int32 *) newval.data(), nelms);
1442 vector < uint8 > total_val_u8;
1443 r = GetFieldValue (swathid, fieldname, dimmaps, total_val_u8, newdims);
1445 ostringstream eherr;
1446 eherr <<
"field " << fieldname.c_str () <<
"cannot be read.";
1447 throw InternalErr (__FILE__, __LINE__, eherr.str ());
1450 check_num_elems_constraint(nelms,newdims);
1451 vector<uint8>val_u8;
1452 val_u8.resize(nelms);
1454 FieldSubset (val_u8.data(), newdims, total_val_u8.data(),
1455 offset32.data(), count32.data(), step32.data());
1456 set_value ((dods_byte *) val_u8.data(), nelms);
1462 vector < int16 > total_val16;
1463 r = GetFieldValue (swathid, fieldname, dimmaps, total_val16, newdims);
1465 ostringstream eherr;
1466 eherr <<
"field " << fieldname.c_str () <<
"cannot be read.";
1467 throw InternalErr (__FILE__, __LINE__, eherr.str ());
1470 check_num_elems_constraint(nelms,newdims);
1472 val16.resize(nelms);
1474 FieldSubset (val16.data(), newdims, total_val16.data(),
1475 offset32.data(), count32.data(), step32.data());
1477 set_value ((dods_int16 *) val16.data(), nelms);
1483 vector < uint16 > total_val_u16;
1484 r = GetFieldValue (swathid, fieldname, dimmaps, total_val_u16, newdims);
1486 ostringstream eherr;
1487 eherr <<
"field " << fieldname.c_str () <<
"cannot be read.";
1488 throw InternalErr (__FILE__, __LINE__, eherr.str ());
1491 check_num_elems_constraint(nelms,newdims);
1492 vector<uint16>val_u16;
1493 val_u16.resize(nelms);
1495 FieldSubset (val_u16.data(), newdims, total_val_u16.data(),
1496 offset32.data(), count32.data(), step32.data());
1497 set_value ((dods_uint16 *) val_u16.data(), nelms);
1504 vector < int32 > total_val32;
1505 r = GetFieldValue (swathid, fieldname, dimmaps, total_val32, newdims);
1507 ostringstream eherr;
1509 eherr <<
"field " << fieldname.c_str () <<
"cannot be read.";
1510 throw InternalErr (__FILE__, __LINE__, eherr.str ());
1513 check_num_elems_constraint(nelms,newdims);
1514 vector<int32> val32;
1515 val32.resize(nelms);
1517 FieldSubset (val32.data(), newdims, total_val32.data(),
1518 offset32.data(), count32.data(), step32.data());
1519 set_value ((dods_int32 *) val32.data(), nelms);
1526 vector < uint32 > total_val_u32;
1527 r = GetFieldValue (swathid, fieldname, dimmaps, total_val_u32, newdims);
1529 ostringstream eherr;
1531 eherr <<
"field " << fieldname.c_str () <<
"cannot be read.";
1532 throw InternalErr (__FILE__, __LINE__, eherr.str ());
1535 check_num_elems_constraint(nelms,newdims);
1536 vector<uint32>val_u32;
1537 val_u32.resize(nelms);
1539 FieldSubset (val_u32.data(), newdims, total_val_u32.data(),
1540 offset32.data(), count32.data(), step32.data());
1541 set_value ((dods_uint32 *) val_u32.data(), nelms);
1548 vector < float32 > total_val_f32;
1549 r = GetFieldValue (swathid, fieldname, dimmaps, total_val_f32, newdims);
1551 ostringstream eherr;
1553 eherr <<
"field " << fieldname.c_str () <<
"cannot be read.";
1554 throw InternalErr (__FILE__, __LINE__, eherr.str ());
1557 check_num_elems_constraint(nelms,newdims);
1558 vector<float32>val_f32;
1559 val_f32.resize(nelms);
1561 FieldSubset (val_f32.data(), newdims, total_val_f32.data(),
1562 offset32.data(), count32.data(), step32.data());
1564 set_value ((dods_float32 *) val_f32.data(), nelms);
1570 vector < float64 > total_val_f64;
1571 r = GetFieldValue (swathid, fieldname, dimmaps, total_val_f64, newdims);
1573 ostringstream eherr;
1575 eherr <<
"field " << fieldname.c_str () <<
"cannot be read.";
1576 throw InternalErr (__FILE__, __LINE__, eherr.str ());
1579 check_num_elems_constraint(nelms,newdims);
1580 vector<float64>val_f64;
1581 val_f64.resize(nelms);
1582 FieldSubset (val_f64.data(), newdims, total_val_f64.data(),
1583 offset32.data(), count32.data(), step32.data());
1584 set_value ((dods_float64 *) val_f64.data(), nelms);
1590 throw InternalErr (__FILE__, __LINE__,
"unsupported data type.");
1597void HDFEOS2ArraySwathDimMapField::close_fileid(
const int32 swfileid,
const int32 sdfileid) {
1600 if(
true == isgeofile ||
false == HDF4RequestHandler::get_pass_fileid()) {
1612bool HDFEOS2ArraySwathDimMapField::check_num_elems_constraint(
const int num_elems,
1613 const vector<int32>&newdims)
const {
1615 int total_dim_size = 1;
1616 for (
int i =0;i<rank;i++)
1617 total_dim_size*=newdims[i];
1619 if(total_dim_size < num_elems) {
1620 ostringstream eherr;
1621 eherr <<
"The total number of elements for the array " << total_dim_size
1622 <<
"is less than the user-requested number of elements " << num_elems;
1623 throw InternalErr (__FILE__, __LINE__, eherr.str ());
void close_fileid(hid_t fid)
static void Split(const char *s, int len, char sep, std::vector< std::string > &names)