[27] | 1 | /* |
---|
| 2 | $Id: BUFR.cpp,v 1.5 2007/02/19 12:53:34 dhurtma Exp $ |
---|
| 3 | $Id: BUFR.cpp,v 1.6 2007/06/10 cboonne $ |
---|
| 4 | */ |
---|
| 5 | #include <stdlib.h> |
---|
| 6 | #include <stdio.h> |
---|
| 7 | #include <string.h> |
---|
| 8 | #include <memory.h> |
---|
| 9 | #include <math.h> |
---|
| 10 | #include <time.h> |
---|
| 11 | |
---|
| 12 | // Usefull Window Definitions |
---|
| 13 | typedef unsigned char BYTE; |
---|
| 14 | typedef unsigned short WORD; |
---|
| 15 | typedef unsigned long DWORD,DWORD_PTR,LONG; |
---|
| 16 | |
---|
| 17 | #define BOOL bool |
---|
| 18 | #define TRUE 1 |
---|
| 19 | #define FALSE 0 |
---|
| 20 | #define MAX_PATH 260 |
---|
| 21 | |
---|
| 22 | #define MAKEWORD(a, b) ((WORD)(((BYTE)((DWORD_PTR)(a) & 0xff)) | ((WORD)((BYTE)((DWORD_PTR)(b) & 0xff))) << 8)) |
---|
| 23 | #define MAKELONG(a, b) ((LONG)(((WORD)((DWORD_PTR)(a) & 0xffff)) | ((DWORD)((WORD)((DWORD_PTR)(b) & 0xffff))) << 16)) |
---|
| 24 | #define LOWORD(l) ((WORD)((DWORD_PTR)(l) & 0xffff)) |
---|
| 25 | #define HIWORD(l) ((WORD)((DWORD_PTR)(l) >> 16)) |
---|
| 26 | #define LOBYTE(w) ((BYTE)((DWORD_PTR)(w) & 0xff)) |
---|
| 27 | #define HIBYTE(w) ((BYTE)((DWORD_PTR)(w) >> 8)) |
---|
| 28 | |
---|
| 29 | |
---|
| 30 | |
---|
| 31 | unsigned long convert24_32(unsigned char *lpData) |
---|
| 32 | { |
---|
| 33 | unsigned long l_data; |
---|
| 34 | |
---|
| 35 | l_data=lpData[0]; |
---|
| 36 | l_data=(l_data<<8)+lpData[1]; |
---|
| 37 | l_data=(l_data<<8)+lpData[2]; |
---|
| 38 | |
---|
| 39 | return l_data; |
---|
| 40 | } |
---|
| 41 | |
---|
| 42 | unsigned short convert16_16(unsigned char *lpData) |
---|
| 43 | { |
---|
| 44 | unsigned short l_data; |
---|
| 45 | |
---|
| 46 | l_data=lpData[0]; |
---|
| 47 | l_data=(l_data<<8)+lpData[1]; |
---|
| 48 | |
---|
| 49 | return l_data; |
---|
| 50 | } |
---|
| 51 | |
---|
| 52 | typedef struct _bufr_section_ptrs |
---|
| 53 | { |
---|
| 54 | long p0; |
---|
| 55 | long p1; |
---|
| 56 | long p2; |
---|
| 57 | long p3; |
---|
| 58 | long p4; |
---|
| 59 | long p5; |
---|
| 60 | } SECTION_PTR; |
---|
| 61 | |
---|
| 62 | typedef struct bufr_section_0 |
---|
| 63 | { |
---|
| 64 | char BUFR[4]; |
---|
| 65 | static const unsigned long length=8; |
---|
| 66 | unsigned long FileLength; |
---|
| 67 | unsigned char edition; |
---|
| 68 | } SECTION_0,*LPSECTION_0; |
---|
| 69 | |
---|
| 70 | typedef enum |
---|
| 71 | { |
---|
| 72 | DC_Surface_Land=0, |
---|
| 73 | DC_Surface_Sea, |
---|
| 74 | DC_Vertical, |
---|
| 75 | DC_Vertical_Satellite, |
---|
| 76 | DC_Single_Level_Upper, |
---|
| 77 | DC_Single_Level_Upper_Satellite, |
---|
| 78 | DC_Surface_Satellite=12, |
---|
| 79 | DC_Oceanographic=31 |
---|
| 80 | } DATA_CATEGORY; |
---|
| 81 | |
---|
| 82 | typedef struct bufr_section_1 |
---|
| 83 | { |
---|
| 84 | unsigned long length; |
---|
| 85 | unsigned char Master_Table_Number; |
---|
| 86 | unsigned char Sub_Centre; |
---|
| 87 | unsigned char Centre; |
---|
| 88 | unsigned char Update_Sequence; |
---|
| 89 | bool bOptional; |
---|
| 90 | DATA_CATEGORY Data_Category; |
---|
| 91 | unsigned char Data_Sub_Category; |
---|
| 92 | unsigned char Master_Table_Version; |
---|
| 93 | unsigned char Local_Table_Version; |
---|
| 94 | unsigned short Year; |
---|
| 95 | unsigned char Month; |
---|
| 96 | unsigned char Day; |
---|
| 97 | unsigned char Hour; |
---|
| 98 | unsigned char Minute; |
---|
| 99 | unsigned char *lpADP_Reserved; |
---|
| 100 | } SECTION_1,*LPSECTION_1; |
---|
| 101 | |
---|
| 102 | typedef struct bufr_section_2 |
---|
| 103 | { |
---|
| 104 | unsigned long length; |
---|
| 105 | unsigned char dummy; |
---|
| 106 | unsigned char *lpADP_Reserved; |
---|
| 107 | } SECTION_2,*LPSECTION_2; |
---|
| 108 | |
---|
| 109 | typedef struct bufr_descriptor |
---|
| 110 | { |
---|
| 111 | unsigned char X : 6; // F=0,3 Class; F=1 # of parameters, F=2 |
---|
| 112 | unsigned char F : 2; // 0 --> Element Table B, 1 --> Replicator, 2 --> Operator Table C, 3 --> Sequence Table D |
---|
| 113 | unsigned char Y; // F=0,3 Entry within class, F=1 times to replicate if 0 read in data |
---|
| 114 | } DESCRIPTOR,*LPDESCRIPTOR; |
---|
| 115 | |
---|
| 116 | typedef struct bufr_section_3 |
---|
| 117 | { |
---|
| 118 | unsigned long length; |
---|
| 119 | unsigned char dummy; |
---|
| 120 | unsigned short Number_Subsets; |
---|
| 121 | bool bObserved; |
---|
| 122 | bool bCompressed; |
---|
| 123 | unsigned long Number_Descriptors; |
---|
| 124 | LPDESCRIPTOR lpDescriptors; |
---|
| 125 | } SECTION_3,*LPSECTION_3; |
---|
| 126 | |
---|
| 127 | typedef struct bufr_section_4 |
---|
| 128 | { |
---|
| 129 | unsigned long length; |
---|
| 130 | unsigned char dummy; |
---|
| 131 | unsigned char *lpData; |
---|
| 132 | } SECTION_4,*LPSECTION_4; |
---|
| 133 | |
---|
| 134 | typedef struct bufr_3_40_002 |
---|
| 135 | { |
---|
| 136 | unsigned short Start_Channel; // 14 bits |
---|
| 137 | unsigned short End_Channel; // 14 bits |
---|
| 138 | unsigned char Channel_Scale_Factor; // 6 bits |
---|
| 139 | }DESCR_3_40_002; |
---|
| 140 | |
---|
| 141 | typedef struct bufr_3_40_003 |
---|
| 142 | { |
---|
| 143 | unsigned short Channel_Number[100]; // 14 bits |
---|
| 144 | unsigned short Scaled_Iasi_Radiance[100];// 16 bits |
---|
| 145 | }DESCR_3_40_003; |
---|
| 146 | |
---|
| 147 | typedef struct bufr_3_40_004 |
---|
| 148 | { |
---|
| 149 | unsigned long Y_angular_position; // 24 bits |
---|
| 150 | unsigned long Z_angular_position; // 24 bits |
---|
| 151 | unsigned char Fraction_clear_pixels_HIRS;// 7 bits |
---|
| 152 | |
---|
| 153 | unsigned char Channel_Number[6]; // 6 bits |
---|
| 154 | unsigned char Channel_Scale_Factor_1[6]; // 6 bits |
---|
| 155 | unsigned long Scaled_Mean_AVHRR_Rad[6]; // 31 bits |
---|
| 156 | unsigned char Channel_Scale_Factor_2[6]; // 6 bits |
---|
| 157 | unsigned long Scaled_Std_AVHRR_Rad[6]; // 31 bits |
---|
| 158 | }DESCR_3_40_004; |
---|
| 159 | |
---|
| 160 | typedef struct bufr_3_40_001 |
---|
| 161 | { |
---|
| 162 | unsigned short Satellite_Identifier; // 10 bits |
---|
| 163 | unsigned short Originating_Centre; // 16 bits |
---|
| 164 | unsigned short Satellite_Instruments_1; // 11 bits |
---|
| 165 | unsigned short Satellite_Classification; // 9 bits |
---|
| 166 | unsigned short Year; // 12 bits |
---|
| 167 | unsigned char Month; // 4 bits |
---|
| 168 | unsigned char Day; // 6 bits |
---|
| 169 | unsigned char Hour; // 5 bits |
---|
| 170 | unsigned char Minute; // 6 bits |
---|
| 171 | unsigned short Second; // 16 bits |
---|
| 172 | unsigned long Latitude; // 25 bits |
---|
| 173 | unsigned long Longitude; // 26 bits |
---|
| 174 | unsigned short Satellite_Zenith_Angle; // 15 bits |
---|
| 175 | unsigned short Azimuth; // 16 bits |
---|
| 176 | unsigned short Solar_Zenith_Angle; // 15 bits |
---|
| 177 | unsigned short Solar_Azimuth; // 16 bits |
---|
| 178 | unsigned char FOV_Number; // 8 bits |
---|
| 179 | unsigned long Orbit_Number; // 24 bits |
---|
| 180 | unsigned short Scan_Line_Number; // 13 bits |
---|
| 181 | unsigned char Major_Frame_Count; // 8 bits |
---|
| 182 | unsigned short Height_of_Station; // 15 bits |
---|
| 183 | unsigned char GQisFlagQual; // 2 bits |
---|
| 184 | unsigned char QGisQualIndex; // 7 bits |
---|
| 185 | unsigned char QGisQualIndexLoc; // 7 bits |
---|
| 186 | unsigned char QGisQualIndexRad; // 7 bits |
---|
| 187 | unsigned char QGisQualIndexSpect; // 7 bits |
---|
| 188 | unsigned long GQisQualIndexTexSondQual; // 24 bits |
---|
| 189 | DESCR_3_40_002 Band_Description[10]; |
---|
| 190 | DESCR_3_40_003 Channels_Sequence[87]; |
---|
| 191 | unsigned short Satellite_Instruments_2; // 11 bits |
---|
| 192 | unsigned char AVHRR_channel_combination;// 7 bits |
---|
| 193 | DESCR_3_40_004 AVHRR_Scene_Sequence[7]; |
---|
| 194 | }DESCR_3_40_001; |
---|
| 195 | |
---|
| 196 | typedef struct iasi_amp |
---|
| 197 | { |
---|
| 198 | char szMagic[16]; // AMP_IASI_V1 |
---|
| 199 | double date; |
---|
| 200 | double Latitude; |
---|
| 201 | double Longitude; |
---|
| 202 | unsigned char QualFlag; |
---|
| 203 | double Satellite_Zenith_Angle; |
---|
| 204 | double Azimuth; |
---|
| 205 | double Solar_Zenith_Angle; |
---|
| 206 | double Solar_Azimuth; |
---|
| 207 | unsigned long Orbit_Number; |
---|
| 208 | double Height_of_Station; |
---|
| 209 | double Cloud_Free_Fraction[7]; |
---|
| 210 | double AVHRR_Mean[6][7]; |
---|
| 211 | double AVHRR_Std[6][7]; |
---|
| 212 | double nu_start; |
---|
| 213 | double nu_end; |
---|
| 214 | long nbp; |
---|
| 215 | double Radiance[8700]; |
---|
| 216 | } IASI_AMP,*LPIASI_AMP; |
---|
| 217 | |
---|
| 218 | IASI_AMP specs[120]; |
---|
| 219 | |
---|
| 220 | BOOL ProcessCompressedIasiLevel1CData(SECTION_1 s1,SECTION_3 s3,SECTION_4 s4,LPIASI_AMP specs); |
---|
| 221 | |
---|
| 222 | void bufr_parse_section_4(unsigned char *lpData,SECTION_4 &s4) |
---|
| 223 | { |
---|
| 224 | unsigned short offset=3; |
---|
| 225 | unsigned long length_Data; |
---|
| 226 | |
---|
| 227 | s4.length=convert24_32(lpData); |
---|
| 228 | s4.dummy=lpData[offset++]; |
---|
| 229 | length_Data=s4.length-offset; |
---|
| 230 | |
---|
| 231 | s4.lpData=(unsigned char*)malloc(length_Data); |
---|
| 232 | memcpy(s4.lpData,lpData+offset,length_Data); |
---|
| 233 | } |
---|
| 234 | |
---|
| 235 | void bufr_free_s4(SECTION_4 &s4) |
---|
| 236 | { |
---|
| 237 | if (s4.lpData) |
---|
| 238 | free(s4.lpData); |
---|
| 239 | } |
---|
| 240 | |
---|
| 241 | void bufr_parse_section_3(unsigned char *lpData,SECTION_3 &s3) |
---|
| 242 | { |
---|
| 243 | unsigned short offset=3; |
---|
| 244 | unsigned long length_Descriptor; |
---|
| 245 | |
---|
| 246 | s3.length=convert24_32(lpData); |
---|
| 247 | s3.dummy=lpData[offset++]; |
---|
| 248 | s3.Number_Subsets=convert16_16(lpData+offset) ; |
---|
| 249 | offset=6; |
---|
| 250 | s3.bObserved=((lpData[offset]&128)==128); |
---|
| 251 | s3.bCompressed=((lpData[offset]&64)==64); |
---|
| 252 | offset=7; |
---|
| 253 | length_Descriptor=s3.length-offset; |
---|
| 254 | s3.Number_Descriptors=length_Descriptor/2; |
---|
| 255 | s3.lpDescriptors=(LPDESCRIPTOR)malloc(length_Descriptor); |
---|
| 256 | memcpy(s3.lpDescriptors,lpData+offset,length_Descriptor); |
---|
| 257 | } |
---|
| 258 | |
---|
| 259 | void bufr_free_s3(SECTION_3 &s3) |
---|
| 260 | { |
---|
| 261 | if (s3.lpDescriptors) |
---|
| 262 | free(s3.lpDescriptors); |
---|
| 263 | } |
---|
| 264 | |
---|
| 265 | void bufr_parse_section_2(unsigned char *lpData,SECTION_2 &s2) |
---|
| 266 | { |
---|
| 267 | unsigned short offset=4; |
---|
| 268 | unsigned long length_Reserved; |
---|
| 269 | |
---|
| 270 | s2.length=convert24_32(lpData); |
---|
| 271 | s2.dummy=lpData[3]; |
---|
| 272 | length_Reserved=s2.length-offset; |
---|
| 273 | s2.lpADP_Reserved=(unsigned char*)malloc(length_Reserved); |
---|
| 274 | memcpy(s2.lpADP_Reserved,lpData+offset,length_Reserved); |
---|
| 275 | } |
---|
| 276 | |
---|
| 277 | void bufr_free_s2(SECTION_2 &s2) |
---|
| 278 | { |
---|
| 279 | if (s2.lpADP_Reserved) |
---|
| 280 | free(s2.lpADP_Reserved); |
---|
| 281 | } |
---|
| 282 | |
---|
| 283 | void bufr_parse_section_1(unsigned char *lpData,SECTION_1 &s1) |
---|
| 284 | { |
---|
| 285 | unsigned short offset=3; |
---|
| 286 | unsigned long length_Reserved; |
---|
| 287 | |
---|
| 288 | s1.length=convert24_32(lpData); |
---|
| 289 | s1.Master_Table_Number=lpData[offset++]; |
---|
| 290 | s1.Sub_Centre=lpData[offset++]; |
---|
| 291 | s1.Centre=lpData[offset++]; |
---|
| 292 | s1.Update_Sequence=lpData[offset++]; |
---|
| 293 | s1.bOptional=((lpData[offset++]&128)==128); |
---|
| 294 | s1.Data_Category=(DATA_CATEGORY)lpData[offset++]; |
---|
| 295 | s1.Data_Sub_Category=lpData[offset++]; |
---|
| 296 | s1.Master_Table_Version=lpData[offset++]; |
---|
| 297 | s1.Local_Table_Version=lpData[offset++]; |
---|
| 298 | s1.Year=2000+lpData[offset++]; |
---|
| 299 | s1.Month=lpData[offset++]; |
---|
| 300 | s1.Day=lpData[offset++]; |
---|
| 301 | s1.Hour=lpData[offset++]; |
---|
| 302 | s1.Minute=lpData[offset++]; |
---|
| 303 | length_Reserved=s1.length-offset; |
---|
| 304 | s1.lpADP_Reserved=(unsigned char*)malloc(length_Reserved); |
---|
| 305 | memcpy(s1.lpADP_Reserved,lpData+offset,length_Reserved); |
---|
| 306 | } |
---|
| 307 | |
---|
| 308 | void bufr_free_s1(SECTION_1 &s1) |
---|
| 309 | { |
---|
| 310 | if (s1.lpADP_Reserved) |
---|
| 311 | free(s1.lpADP_Reserved); |
---|
| 312 | } |
---|
| 313 | |
---|
| 314 | void bufr_parse_section_0(unsigned char *lpData,SECTION_0 &s0) |
---|
| 315 | { |
---|
| 316 | memcpy(s0.BUFR,lpData,4); |
---|
| 317 | s0.FileLength=convert24_32(lpData+4); |
---|
| 318 | s0.edition=lpData[7]; |
---|
| 319 | } |
---|
| 320 | |
---|
| 321 | int main(int argc, char* argv[]) |
---|
| 322 | { |
---|
| 323 | FILE *fin; |
---|
| 324 | unsigned char *lpData; |
---|
| 325 | unsigned long DataAllocated; |
---|
| 326 | unsigned long length; |
---|
| 327 | SECTION_0 s0={0}; |
---|
| 328 | SECTION_1 s1={0}; |
---|
| 329 | SECTION_2 s2={0}; |
---|
| 330 | SECTION_3 s3={0}; |
---|
| 331 | SECTION_4 s4={0}; |
---|
| 332 | long it=0; |
---|
| 333 | long filelength; |
---|
| 334 | unsigned long i,j,k; |
---|
| 335 | SECTION_PTR sp; |
---|
| 336 | BOOL bAnswer; |
---|
| 337 | |
---|
| 338 | |
---|
| 339 | fin=fopen(argv[1],"rb"); |
---|
| 340 | |
---|
| 341 | DataAllocated=8; |
---|
| 342 | lpData=(unsigned char*)malloc(DataAllocated); |
---|
| 343 | fseek(fin,0,SEEK_END); |
---|
| 344 | filelength=ftell(fin); |
---|
| 345 | sp.p0=0; |
---|
| 346 | |
---|
| 347 | L_AGAIN: |
---|
| 348 | it++; |
---|
| 349 | // Add preamble |
---|
| 350 | sp.p0+=34; //Orbit, hour,...? |
---|
| 351 | // Section 0 |
---|
| 352 | if (fseek(fin,sp.p0,SEEK_SET)>0) |
---|
| 353 | goto L_FIN; |
---|
| 354 | // Section 0 is always 8 bytes long |
---|
| 355 | length=8; |
---|
| 356 | // Read & parse |
---|
| 357 | if (fread(lpData,length,1,fin)<1) |
---|
| 358 | goto L_FIN; |
---|
| 359 | bufr_parse_section_0(lpData,s0); |
---|
| 360 | sp.p1=sp.p0+s0.length; |
---|
| 361 | |
---|
| 362 | // Section 1 |
---|
| 363 | fseek(fin,sp.p1,SEEK_SET); |
---|
| 364 | // Get length |
---|
| 365 | fread(lpData,3,1,fin); |
---|
| 366 | length=convert24_32(lpData); |
---|
| 367 | // Reallocate buffer if needed |
---|
| 368 | if (length>DataAllocated) |
---|
| 369 | { |
---|
| 370 | DataAllocated=length; |
---|
| 371 | lpData=(unsigned char*)realloc(lpData,length); |
---|
| 372 | } |
---|
| 373 | // Read & parse |
---|
| 374 | fseek(fin,sp.p1,SEEK_SET); |
---|
| 375 | fread(lpData,length,1,fin); |
---|
| 376 | bufr_parse_section_1(lpData,s1); |
---|
| 377 | if (s1.bOptional) |
---|
| 378 | { |
---|
| 379 | sp.p2=sp.p1+s1.length; |
---|
| 380 | |
---|
| 381 | // Section 2 |
---|
| 382 | fseek(fin,sp.p2,SEEK_SET); |
---|
| 383 | |
---|
| 384 | // Get length |
---|
| 385 | fread(lpData,3,1,fin); |
---|
| 386 | length=convert24_32(lpData); |
---|
| 387 | // Reallocate buffer if needed |
---|
| 388 | if (length>DataAllocated) |
---|
| 389 | { |
---|
| 390 | DataAllocated=length; |
---|
| 391 | lpData=(unsigned char*)realloc(lpData,length); |
---|
| 392 | } |
---|
| 393 | // Read & parse |
---|
| 394 | fseek(fin,sp.p2,SEEK_SET); |
---|
| 395 | fread(lpData,length,1,fin); |
---|
| 396 | bufr_parse_section_2(lpData,s2); |
---|
| 397 | |
---|
| 398 | sp.p3=sp.p2+s2.length; |
---|
| 399 | } |
---|
| 400 | else |
---|
| 401 | { |
---|
| 402 | sp.p2=-1; |
---|
| 403 | sp.p3=sp.p1+s1.length; |
---|
| 404 | } |
---|
| 405 | |
---|
| 406 | // Section 3 |
---|
| 407 | fseek(fin,sp.p3,SEEK_SET); |
---|
| 408 | // Get length |
---|
| 409 | fread(lpData,3,1,fin); |
---|
| 410 | length=convert24_32(lpData); |
---|
| 411 | // Reallocate buffer if needed |
---|
| 412 | if (length>DataAllocated) |
---|
| 413 | { |
---|
| 414 | DataAllocated=length; |
---|
| 415 | lpData=(unsigned char*)realloc(lpData,length); |
---|
| 416 | } |
---|
| 417 | // Read & parse |
---|
| 418 | fseek(fin,sp.p3,SEEK_SET); |
---|
| 419 | fread(lpData,length,1,fin); |
---|
| 420 | bufr_parse_section_3(lpData,s3); |
---|
| 421 | sp.p4=sp.p3+s3.length; |
---|
| 422 | |
---|
| 423 | // Section 4 |
---|
| 424 | fseek(fin,sp.p4,SEEK_SET); |
---|
| 425 | // Get length |
---|
| 426 | fread(lpData,3,1,fin); |
---|
| 427 | length=convert24_32(lpData); |
---|
| 428 | |
---|
| 429 | // Reallocate buffer if needed |
---|
| 430 | if (length>DataAllocated) |
---|
| 431 | { |
---|
| 432 | DataAllocated=length; |
---|
| 433 | lpData=(unsigned char*)realloc(lpData,length); |
---|
| 434 | } |
---|
| 435 | |
---|
| 436 | // Read & parse |
---|
| 437 | fseek(fin,sp.p4,SEEK_SET); |
---|
| 438 | memset(lpData,0xff,length); |
---|
| 439 | |
---|
| 440 | fread(lpData,1,length,fin); |
---|
| 441 | |
---|
| 442 | bufr_parse_section_4(lpData,s4); |
---|
| 443 | sp.p5=sp.p4+s4.length; |
---|
| 444 | |
---|
| 445 | /* |
---|
| 446 | for (i=0;i<s3.Number_Descriptors;++i) |
---|
| 447 | { |
---|
| 448 | printf ("%.2d:%.2d => %.1d %.2d %.3d\n",it,i,s3.lpDescriptors[i].F,s3.lpDescriptors[i].X,s3.lpDescriptors[i].Y); |
---|
| 449 | } |
---|
| 450 | */ |
---|
| 451 | |
---|
| 452 | //Check section 5 is 7777 |
---|
| 453 | fseek(fin,sp.p5,SEEK_SET); |
---|
| 454 | fread(lpData,4,1,fin); |
---|
| 455 | if (strncmp((char*)lpData,"7777",4)!=0) |
---|
| 456 | printf("Error\n"); |
---|
| 457 | |
---|
| 458 | // Process lpdata |
---|
| 459 | bAnswer=ProcessCompressedIasiLevel1CData(s1,s3,s4,specs); |
---|
| 460 | /* |
---|
| 461 | if (bAnswer) |
---|
| 462 | printf("AVHRR status : Seems OK\n"); |
---|
| 463 | else |
---|
| 464 | printf("AVHRR status : Seems Corrupt\n"); |
---|
| 465 | */ |
---|
| 466 | |
---|
| 467 | // Save spectra... |
---|
| 468 | for (k=0;k<120;++k) |
---|
| 469 | { |
---|
| 470 | char szFName[MAX_PATH]; |
---|
| 471 | FILE *fSpec; |
---|
| 472 | |
---|
| 473 | sprintf(szFName,"%15.6lf_%.3d_%.5d_%.5d.asc",specs[k].date,k+1,int((specs[k].Latitude+90)*100),int((specs[k].Longitude+180)*100)); |
---|
| 474 | fSpec=fopen(szFName,"w"); |
---|
| 475 | |
---|
| 476 | fprintf(fSpec,"==========================================================\n"); |
---|
| 477 | { |
---|
| 478 | struct tm *newTime; |
---|
| 479 | time_t szClock; |
---|
| 480 | |
---|
| 481 | // Get time in seconds |
---|
| 482 | time( &szClock ); |
---|
| 483 | |
---|
| 484 | // Convert time to struct tm form |
---|
| 485 | newTime = localtime( &szClock ); |
---|
| 486 | |
---|
| 487 | // Note: asctime is deprecated; consider using asctime_s instead |
---|
| 488 | fprintf(fSpec,"IASI file converted on %s", asctime(newTime)) ; |
---|
| 489 | } |
---|
| 490 | |
---|
| 491 | fprintf(fSpec,"==========================================================\n"); |
---|
| 492 | fprintf(fSpec,"%15.9lf : Date\n",specs[k].date); |
---|
| 493 | fprintf(fSpec,"%.08d : Orbit Number\n",specs[k].Orbit_Number); |
---|
| 494 | switch (specs[k].QualFlag) |
---|
| 495 | { |
---|
| 496 | case 0: |
---|
| 497 | fprintf(fSpec,"good : Quality Flag\n"); |
---|
| 498 | break; |
---|
| 499 | case 1: |
---|
| 500 | fprintf(fSpec,"bad : Quality Flag\n"); |
---|
| 501 | break; |
---|
| 502 | case 2: |
---|
| 503 | fprintf(fSpec,"reserved : Quality Flag\n"); |
---|
| 504 | break; |
---|
| 505 | case 3: |
---|
| 506 | fprintf(fSpec,"missing : Quality Flag\n"); |
---|
| 507 | break; |
---|
| 508 | } |
---|
| 509 | /* |
---|
| 510 | if (bAnswer) |
---|
| 511 | fprintf(fSpec,"AVHRR status : Seems OK\n"); |
---|
| 512 | else |
---|
| 513 | fprintf(fSpec,"AVHRR status : Seems Corrupt\n"); |
---|
| 514 | */ |
---|
| 515 | printf("%+7.5lf,%+7.5lf,%5.2lf,%5.1lf,%15.9lf,%.08d,%s,%.1d\n",specs[k].Latitude,specs[k].Longitude,specs[k].Satellite_Zenith_Angle, |
---|
| 516 | specs[k].Height_of_Station,specs[k].date,specs[k].Orbit_Number,szFName,specs[k].QualFlag); |
---|
| 517 | fprintf(fSpec,"%+7.5lf : Latitude(?)\n",specs[k].Latitude); |
---|
| 518 | fprintf(fSpec,"%+7.5lf : Longitude(?)\n",specs[k].Longitude); |
---|
| 519 | fprintf(fSpec,"%5.2lf : Sat ZA(?)\n",specs[k].Satellite_Zenith_Angle); |
---|
| 520 | fprintf(fSpec,"%5.2lf : Sat AZ(?)\n",specs[k].Azimuth); |
---|
| 521 | fprintf(fSpec,"%5.2lf : Sun ZA(?)\n",specs[k].Solar_Zenith_Angle); |
---|
| 522 | fprintf(fSpec,"%5.2lf : Sun AZ(?)\n",specs[k].Solar_Azimuth); |
---|
| 523 | fprintf(fSpec,"%5.1lf : Altitude(km)\n",specs[k].Height_of_Station); |
---|
| 524 | fprintf(fSpec," "); |
---|
| 525 | for (i=0;i<7;++i) |
---|
| 526 | fprintf(fSpec,"%+2.0lf ",specs[k].Cloud_Free_Fraction[i]); |
---|
| 527 | fprintf(fSpec," : Cloud Free(%%)\n"); |
---|
| 528 | for (j=0;j<6;++j) |
---|
| 529 | { |
---|
| 530 | fprintf(fSpec,"AVHRR Pixel : %.1d\n",j+1); |
---|
| 531 | fprintf(fSpec," Mean : "); |
---|
| 532 | for (i=0;i<7;++i) |
---|
| 533 | fprintf(fSpec,"%.4le ",specs[k].AVHRR_Mean[j][i]); |
---|
| 534 | fprintf(fSpec,"\n"); |
---|
| 535 | fprintf(fSpec," Std : "); |
---|
| 536 | for (i=0;i<7;++i) |
---|
| 537 | fprintf(fSpec,"%.4le ",specs[k].AVHRR_Std[j][i]); |
---|
| 538 | fprintf(fSpec,"\n"); |
---|
| 539 | } |
---|
| 540 | |
---|
| 541 | fprintf(fSpec,"%7.2lf : nu start(cm-1)\n",specs[k].nu_start); |
---|
| 542 | fprintf(fSpec,"%7.2lf : nu end(cm-1)\n",specs[k].nu_end); |
---|
| 543 | fprintf(fSpec,"%.3d : nbp\n",specs[k].nbp); |
---|
| 544 | fprintf(fSpec,"==========================================================\n"); |
---|
| 545 | for (int i=0;i<8700;++i) |
---|
| 546 | fprintf(fSpec,"%+.4le\n",specs[k].Radiance[i]); |
---|
| 547 | fclose(fSpec); |
---|
| 548 | } |
---|
| 549 | |
---|
| 550 | // Cleanup and free |
---|
| 551 | bufr_free_s1(s1); |
---|
| 552 | bufr_free_s2(s2); |
---|
| 553 | bufr_free_s3(s3); |
---|
| 554 | bufr_free_s4(s4); |
---|
| 555 | |
---|
| 556 | sp.p0=sp.p5+4; // size of section 5 |
---|
| 557 | sp.p0+=4; // End of message post bytes |
---|
| 558 | |
---|
| 559 | |
---|
| 560 | if (sp.p0<filelength) |
---|
| 561 | { |
---|
| 562 | goto L_AGAIN; |
---|
| 563 | } |
---|
| 564 | |
---|
| 565 | L_FIN: |
---|
| 566 | free(lpData); |
---|
| 567 | fclose(fin); |
---|
| 568 | return 0; |
---|
| 569 | } |
---|
| 570 | |
---|
| 571 | void GetNextBits(unsigned char *lpData,unsigned char NbBits,unsigned char ReturnSize,void* lpReturn,bool bReset=false) |
---|
| 572 | { |
---|
| 573 | static long BytePos; |
---|
| 574 | static int BitPos; |
---|
| 575 | unsigned char ByteTempBuffer[5]; |
---|
| 576 | unsigned char *lpTempReturn; |
---|
| 577 | int nBytes; |
---|
| 578 | |
---|
| 579 | if (bReset) |
---|
| 580 | { |
---|
| 581 | BytePos=0; |
---|
| 582 | BitPos=0; |
---|
| 583 | return; |
---|
| 584 | } |
---|
| 585 | lpTempReturn=(unsigned char*)lpReturn; |
---|
| 586 | memset(ByteTempBuffer,0,5*sizeof(unsigned char)); |
---|
| 587 | nBytes=(NbBits+BitPos)/8+((NbBits+BitPos)%8>0); |
---|
| 588 | // Transfer from lpData to Buffer with byte reversing |
---|
| 589 | for (int i=0;i<nBytes;++i) |
---|
| 590 | { |
---|
| 591 | ByteTempBuffer[i]=lpData[BytePos+i]; |
---|
| 592 | } |
---|
| 593 | memset(lpReturn,0,ReturnSize); |
---|
| 594 | |
---|
| 595 | // Mask |
---|
| 596 | switch (nBytes) |
---|
| 597 | { |
---|
| 598 | case 1: |
---|
| 599 | { |
---|
| 600 | char Shift_8; |
---|
| 601 | unsigned char Mask; |
---|
| 602 | unsigned char Work; |
---|
| 603 | |
---|
| 604 | Shift_8=(8-BitPos)-NbBits; |
---|
| 605 | |
---|
| 606 | Mask=((unsigned char)1<<NbBits)-1; // Build the Mask (eg: 00111111 for 6 bits data) |
---|
| 607 | Work=ByteTempBuffer[0]; // Transfer data to Work |
---|
| 608 | Work>>=Shift_8; // Align bits to the window |
---|
| 609 | Work&=Mask; // Apply the mask |
---|
| 610 | ByteTempBuffer[0]=Work; // Save Work back in buffer |
---|
| 611 | break; |
---|
| 612 | } |
---|
| 613 | |
---|
| 614 | case 2: |
---|
| 615 | { |
---|
| 616 | char Shift_16; |
---|
| 617 | unsigned short Mask; |
---|
| 618 | unsigned short Work; |
---|
| 619 | |
---|
| 620 | Shift_16=(16-BitPos)-NbBits; |
---|
| 621 | |
---|
| 622 | Mask=((unsigned short)1<<NbBits)-1; // Build the Mask |
---|
| 623 | Work=MAKEWORD(ByteTempBuffer[1],ByteTempBuffer[0]); // Transfer data to Work |
---|
| 624 | Work>>=Shift_16; // Align bits to the window |
---|
| 625 | Work&=Mask; // Apply the mask |
---|
| 626 | ByteTempBuffer[0]=LOBYTE(Work); // Save Work back in buffer with proper "endianness" |
---|
| 627 | ByteTempBuffer[1]=HIBYTE(Work); |
---|
| 628 | break; |
---|
| 629 | } |
---|
| 630 | |
---|
| 631 | case 3: |
---|
| 632 | { |
---|
| 633 | char Shift_24; |
---|
| 634 | unsigned long Mask; // Work in 4 bytes as there is no 3 bytes types |
---|
| 635 | unsigned long Work; |
---|
| 636 | unsigned short W1,W2; |
---|
| 637 | |
---|
| 638 | Shift_24=(24-BitPos)-NbBits; |
---|
| 639 | |
---|
| 640 | Mask=((unsigned long)1<<NbBits)-1; // Build the Mask |
---|
| 641 | W2=MAKEWORD(ByteTempBuffer[2],ByteTempBuffer[1]); // Transfer data to High Word of Work |
---|
| 642 | W1=MAKEWORD(ByteTempBuffer[0],0); // Transfer data to Low Word of Work |
---|
| 643 | Work=MAKELONG(W2,W1); |
---|
| 644 | Work>>=Shift_24; // Align bits to the window |
---|
| 645 | Work&=Mask; // Apply the mask |
---|
| 646 | W1=LOWORD(Work); |
---|
| 647 | W2=HIWORD(Work); |
---|
| 648 | ByteTempBuffer[0]=LOBYTE(W1); // Save Work back in buffer with proper "endianness" |
---|
| 649 | ByteTempBuffer[1]=HIBYTE(W1); |
---|
| 650 | ByteTempBuffer[2]=LOBYTE(W2); |
---|
| 651 | ByteTempBuffer[3]=0; |
---|
| 652 | break; |
---|
| 653 | } |
---|
| 654 | |
---|
| 655 | case 4: |
---|
| 656 | { |
---|
| 657 | char Shift_32; |
---|
| 658 | unsigned long Mask; |
---|
| 659 | unsigned long Work; |
---|
| 660 | unsigned short W1,W2; |
---|
| 661 | |
---|
| 662 | Shift_32=(32-BitPos)-NbBits; |
---|
| 663 | |
---|
| 664 | Mask=((unsigned long)1<<NbBits)-1; // Build the Mask |
---|
| 665 | W2=MAKEWORD(ByteTempBuffer[3],ByteTempBuffer[2]); // Transfer data to High Word of Work |
---|
| 666 | W1=MAKEWORD(ByteTempBuffer[1],ByteTempBuffer[0]); // Transfer data to Low Word of Work |
---|
| 667 | Work=MAKELONG(W2,W1); |
---|
| 668 | Work>>=Shift_32; // Align bits to the window |
---|
| 669 | Work&=Mask; // Apply the mask |
---|
| 670 | W1=LOWORD(Work); |
---|
| 671 | W2=HIWORD(Work); |
---|
| 672 | ByteTempBuffer[0]=LOBYTE(W1); // Save Work back in buffer with proper "endianness" |
---|
| 673 | ByteTempBuffer[1]=HIBYTE(W1); |
---|
| 674 | ByteTempBuffer[2]=LOBYTE(W2); |
---|
| 675 | ByteTempBuffer[3]=HIBYTE(W2); |
---|
| 676 | break; |
---|
| 677 | } |
---|
| 678 | |
---|
| 679 | case 5: |
---|
| 680 | unsigned char Shift_40; |
---|
| 681 | unsigned long Mask; // Use more than 4 bytes but store only on 4 |
---|
| 682 | unsigned long Work; |
---|
| 683 | unsigned char WorkLSB; |
---|
| 684 | unsigned char ShiftLSB; |
---|
| 685 | unsigned short W1,W2; |
---|
| 686 | |
---|
| 687 | Shift_40=BitPos+NbBits-32; |
---|
| 688 | |
---|
| 689 | Mask=((unsigned long)1<<NbBits)-1; // Build the Mask |
---|
| 690 | ShiftLSB=7-Shift_40; |
---|
| 691 | |
---|
| 692 | W2=MAKEWORD(ByteTempBuffer[3],ByteTempBuffer[2]); // Transfer data to High Word of Work |
---|
| 693 | W1=MAKEWORD(ByteTempBuffer[1],ByteTempBuffer[0]); // Transfer data to Low Word of Work |
---|
| 694 | Work=MAKELONG(W2,W1); |
---|
| 695 | Work<<=Shift_40; // We work reverse here. |
---|
| 696 | WorkLSB=ByteTempBuffer[4]; |
---|
| 697 | WorkLSB>>=ShiftLSB; |
---|
| 698 | Work|=WorkLSB; // Join the shifted LSB bits to Work |
---|
| 699 | Work&=Mask; // Apply the mask |
---|
| 700 | W1=LOWORD(Work); |
---|
| 701 | W2=HIWORD(Work); |
---|
| 702 | ByteTempBuffer[0]=LOBYTE(W1); // Save Work back in buffer with proper "endianness" |
---|
| 703 | ByteTempBuffer[1]=HIBYTE(W1); |
---|
| 704 | ByteTempBuffer[2]=LOBYTE(W2); |
---|
| 705 | ByteTempBuffer[3]=HIBYTE(W2); |
---|
| 706 | break; |
---|
| 707 | } |
---|
| 708 | // Set return value |
---|
| 709 | memcpy(lpTempReturn,ByteTempBuffer,ReturnSize); |
---|
| 710 | |
---|
| 711 | // Update position |
---|
| 712 | BitPos+=NbBits; |
---|
| 713 | BytePos+=BitPos/8; |
---|
| 714 | BitPos%=8; |
---|
| 715 | } |
---|
| 716 | |
---|
| 717 | BOOL ProcessCompressedIasiLevel1CData(SECTION_1 s1,SECTION_3 s3,SECTION_4 s4,LPIASI_AMP specs) |
---|
| 718 | { |
---|
| 719 | unsigned char NbBits; |
---|
| 720 | |
---|
| 721 | DESCR_3_40_002 LocalChannel[120*10]; |
---|
| 722 | DESCR_3_40_001 LocalBufr; |
---|
| 723 | |
---|
| 724 | for (int k=0;k<120;++k) |
---|
| 725 | { |
---|
| 726 | specs[k].nbp=8700; |
---|
| 727 | specs[k].nu_start=645.; |
---|
| 728 | specs[k].nu_end=2819.75; |
---|
| 729 | strcpy(specs[k].szMagic,"AMP_IASI_V1"); |
---|
| 730 | } |
---|
| 731 | |
---|
| 732 | GetNextBits(0,0,0,0,true); |
---|
| 733 | GetNextBits(s4.lpData,10,sizeof(LocalBufr.Satellite_Identifier),&LocalBufr.Satellite_Identifier,false); |
---|
| 734 | GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false); |
---|
| 735 | if (NbBits>0) |
---|
| 736 | { |
---|
| 737 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 738 | { |
---|
| 739 | unsigned short temp; |
---|
| 740 | GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false); |
---|
| 741 | temp+=LocalBufr.Satellite_Identifier; |
---|
| 742 | } |
---|
| 743 | } |
---|
| 744 | else |
---|
| 745 | { |
---|
| 746 | } |
---|
| 747 | |
---|
| 748 | GetNextBits(s4.lpData,16,sizeof(LocalBufr.Originating_Centre),&LocalBufr.Originating_Centre,false); |
---|
| 749 | GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false); |
---|
| 750 | if (NbBits>0) |
---|
| 751 | { |
---|
| 752 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 753 | { |
---|
| 754 | unsigned short temp; |
---|
| 755 | GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false); |
---|
| 756 | temp+=LocalBufr.Originating_Centre; |
---|
| 757 | } |
---|
| 758 | } |
---|
| 759 | else |
---|
| 760 | { |
---|
| 761 | } |
---|
| 762 | |
---|
| 763 | GetNextBits(s4.lpData,11,sizeof(LocalBufr.Satellite_Instruments_1),&LocalBufr.Satellite_Instruments_1,false); |
---|
| 764 | GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false); |
---|
| 765 | if (NbBits>0) |
---|
| 766 | { |
---|
| 767 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 768 | { |
---|
| 769 | unsigned short temp; |
---|
| 770 | GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false); |
---|
| 771 | temp+=LocalBufr.Satellite_Instruments_1; |
---|
| 772 | } |
---|
| 773 | } |
---|
| 774 | else |
---|
| 775 | { |
---|
| 776 | } |
---|
| 777 | |
---|
| 778 | GetNextBits(s4.lpData, 9,sizeof(LocalBufr.Satellite_Classification),&LocalBufr.Satellite_Classification,false); |
---|
| 779 | GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false); |
---|
| 780 | if (NbBits>0) |
---|
| 781 | { |
---|
| 782 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 783 | { |
---|
| 784 | unsigned short temp; |
---|
| 785 | GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false); |
---|
| 786 | temp+=LocalBufr.Satellite_Classification; |
---|
| 787 | } |
---|
| 788 | } |
---|
| 789 | else |
---|
| 790 | { |
---|
| 791 | } |
---|
| 792 | |
---|
| 793 | GetNextBits(s4.lpData,12,sizeof(LocalBufr.Year),&LocalBufr.Year,false); |
---|
| 794 | GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false); |
---|
| 795 | if (NbBits>0) |
---|
| 796 | { |
---|
| 797 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 798 | { |
---|
| 799 | unsigned short temp; |
---|
| 800 | GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false); |
---|
| 801 | temp+=LocalBufr.Year; |
---|
| 802 | specs[k].date=temp*10000; |
---|
| 803 | } |
---|
| 804 | } |
---|
| 805 | else |
---|
| 806 | { |
---|
| 807 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 808 | specs[k].date=LocalBufr.Year*10000; |
---|
| 809 | } |
---|
| 810 | |
---|
| 811 | GetNextBits(s4.lpData, 4,sizeof(LocalBufr.Month),&LocalBufr.Month,false); |
---|
| 812 | GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false); |
---|
| 813 | if (NbBits>0) |
---|
| 814 | { |
---|
| 815 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 816 | { |
---|
| 817 | unsigned char temp; |
---|
| 818 | GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false); |
---|
| 819 | temp+=LocalBufr.Month; |
---|
| 820 | specs[k].date+=temp*100; |
---|
| 821 | } |
---|
| 822 | } |
---|
| 823 | else |
---|
| 824 | { |
---|
| 825 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 826 | specs[k].date+=LocalBufr.Month*100; |
---|
| 827 | } |
---|
| 828 | GetNextBits(s4.lpData, 6,sizeof(LocalBufr.Day),&LocalBufr.Day,false); |
---|
| 829 | GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false); |
---|
| 830 | if (NbBits>0) |
---|
| 831 | { |
---|
| 832 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 833 | { |
---|
| 834 | unsigned char temp; |
---|
| 835 | GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false); |
---|
| 836 | temp+=LocalBufr.Day; |
---|
| 837 | specs[k].date+=temp; |
---|
| 838 | } |
---|
| 839 | } |
---|
| 840 | else |
---|
| 841 | { |
---|
| 842 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 843 | specs[k].date+=LocalBufr.Day; |
---|
| 844 | } |
---|
| 845 | GetNextBits(s4.lpData, 5,sizeof(LocalBufr.Hour),&LocalBufr.Hour,false); |
---|
| 846 | GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false); |
---|
| 847 | if (NbBits>0) |
---|
| 848 | { |
---|
| 849 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 850 | { |
---|
| 851 | unsigned char temp; |
---|
| 852 | GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false); |
---|
| 853 | temp+=LocalBufr.Hour; |
---|
| 854 | specs[k].date+=temp/100.; |
---|
| 855 | } |
---|
| 856 | } |
---|
| 857 | else |
---|
| 858 | { |
---|
| 859 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 860 | specs[k].date+=LocalBufr.Hour/100.; |
---|
| 861 | } |
---|
| 862 | GetNextBits(s4.lpData, 6,sizeof(LocalBufr.Minute),&LocalBufr.Minute,false); |
---|
| 863 | GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false); |
---|
| 864 | if (NbBits>0) |
---|
| 865 | { |
---|
| 866 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 867 | { |
---|
| 868 | unsigned char temp; |
---|
| 869 | GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false); |
---|
| 870 | temp+=LocalBufr.Minute; |
---|
| 871 | specs[k].date+=temp/10000.; |
---|
| 872 | } |
---|
| 873 | } |
---|
| 874 | else |
---|
| 875 | { |
---|
| 876 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 877 | specs[k].date+=LocalBufr.Minute/10000.; |
---|
| 878 | } |
---|
| 879 | GetNextBits(s4.lpData,16,sizeof(LocalBufr.Second),&LocalBufr.Second,false); |
---|
| 880 | GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false); |
---|
| 881 | if (NbBits>0) |
---|
| 882 | { |
---|
| 883 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 884 | { |
---|
| 885 | unsigned short temp; |
---|
| 886 | GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false); |
---|
| 887 | temp+=LocalBufr.Second; |
---|
| 888 | specs[k].date+=temp/1e9; |
---|
| 889 | } |
---|
| 890 | } |
---|
| 891 | else |
---|
| 892 | { |
---|
| 893 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 894 | specs[k].date+=LocalBufr.Second/1e9; |
---|
| 895 | } |
---|
| 896 | |
---|
| 897 | GetNextBits(s4.lpData,25,sizeof(LocalBufr.Latitude),&LocalBufr.Latitude,false); |
---|
| 898 | GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false); |
---|
| 899 | if (NbBits>0) |
---|
| 900 | { |
---|
| 901 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 902 | { |
---|
| 903 | unsigned long temp; |
---|
| 904 | GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false); |
---|
| 905 | temp+=LocalBufr.Latitude; |
---|
| 906 | specs[k].Latitude=temp/1e5-90.; |
---|
| 907 | } |
---|
| 908 | } |
---|
| 909 | else |
---|
| 910 | { |
---|
| 911 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 912 | specs[k].Latitude=LocalBufr.Latitude/1e5-90.; |
---|
| 913 | } |
---|
| 914 | |
---|
| 915 | GetNextBits(s4.lpData,26,sizeof(LocalBufr.Longitude),&LocalBufr.Longitude,false); |
---|
| 916 | GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false); |
---|
| 917 | if (NbBits>0) |
---|
| 918 | { |
---|
| 919 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 920 | { |
---|
| 921 | unsigned long temp; |
---|
| 922 | GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false); |
---|
| 923 | temp+=LocalBufr.Longitude; |
---|
| 924 | specs[k].Longitude=temp/1e5-180.; |
---|
| 925 | } |
---|
| 926 | } |
---|
| 927 | else |
---|
| 928 | { |
---|
| 929 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 930 | specs[k].Longitude=LocalBufr.Longitude/1e5-180.; |
---|
| 931 | } |
---|
| 932 | |
---|
| 933 | GetNextBits(s4.lpData,15,sizeof(LocalBufr.Satellite_Zenith_Angle),&LocalBufr.Satellite_Zenith_Angle,false); |
---|
| 934 | GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false); |
---|
| 935 | if (NbBits>0) |
---|
| 936 | { |
---|
| 937 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 938 | { |
---|
| 939 | unsigned short temp; |
---|
| 940 | GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false); |
---|
| 941 | temp+=LocalBufr.Satellite_Zenith_Angle; |
---|
| 942 | specs[k].Satellite_Zenith_Angle=temp/100.-90.; |
---|
| 943 | } |
---|
| 944 | } |
---|
| 945 | else |
---|
| 946 | { |
---|
| 947 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 948 | specs[k].Satellite_Zenith_Angle=LocalBufr.Satellite_Zenith_Angle/100.-90.; |
---|
| 949 | } |
---|
| 950 | |
---|
| 951 | GetNextBits(s4.lpData,16,sizeof(LocalBufr.Azimuth),&LocalBufr.Azimuth,false); |
---|
| 952 | GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false); |
---|
| 953 | if (NbBits>0) |
---|
| 954 | { |
---|
| 955 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 956 | { |
---|
| 957 | unsigned short temp; |
---|
| 958 | GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false); |
---|
| 959 | temp+=LocalBufr.Azimuth; |
---|
| 960 | specs[k].Azimuth=temp/100.; |
---|
| 961 | } |
---|
| 962 | } |
---|
| 963 | else |
---|
| 964 | { |
---|
| 965 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 966 | specs[k].Azimuth=LocalBufr.Azimuth/100.; |
---|
| 967 | } |
---|
| 968 | |
---|
| 969 | GetNextBits(s4.lpData,15,sizeof(LocalBufr.Solar_Zenith_Angle),&LocalBufr.Solar_Zenith_Angle,false); |
---|
| 970 | GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false); |
---|
| 971 | if (NbBits>0) |
---|
| 972 | { |
---|
| 973 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 974 | { |
---|
| 975 | unsigned short temp; |
---|
| 976 | GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false); |
---|
| 977 | temp+=LocalBufr.Solar_Zenith_Angle; |
---|
| 978 | specs[k].Solar_Zenith_Angle=temp/100.-90.; |
---|
| 979 | } |
---|
| 980 | } |
---|
| 981 | else |
---|
| 982 | { |
---|
| 983 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 984 | specs[k].Solar_Zenith_Angle=LocalBufr.Solar_Zenith_Angle/100.-90.; |
---|
| 985 | } |
---|
| 986 | |
---|
| 987 | GetNextBits(s4.lpData,16,sizeof(LocalBufr.Solar_Azimuth),&LocalBufr.Solar_Azimuth,false); |
---|
| 988 | GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false); |
---|
| 989 | if (NbBits>0) |
---|
| 990 | { |
---|
| 991 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 992 | { |
---|
| 993 | unsigned short temp; |
---|
| 994 | GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false); |
---|
| 995 | temp+=LocalBufr.Solar_Azimuth; |
---|
| 996 | specs[k].Solar_Azimuth=temp/100.; |
---|
| 997 | } |
---|
| 998 | } |
---|
| 999 | else |
---|
| 1000 | { |
---|
| 1001 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 1002 | specs[k].Solar_Azimuth=LocalBufr.Solar_Azimuth/100.; |
---|
| 1003 | } |
---|
| 1004 | |
---|
| 1005 | GetNextBits(s4.lpData, 8,sizeof(LocalBufr.FOV_Number),&LocalBufr.FOV_Number,false); |
---|
| 1006 | GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false); |
---|
| 1007 | if (NbBits>0) |
---|
| 1008 | { |
---|
| 1009 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 1010 | { |
---|
| 1011 | unsigned char temp; |
---|
| 1012 | GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false); |
---|
| 1013 | temp+=LocalBufr.FOV_Number; |
---|
| 1014 | } |
---|
| 1015 | } |
---|
| 1016 | else |
---|
| 1017 | { |
---|
| 1018 | } |
---|
| 1019 | |
---|
| 1020 | GetNextBits(s4.lpData,24,sizeof(LocalBufr.Orbit_Number),&LocalBufr.Orbit_Number,false); |
---|
| 1021 | GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false); |
---|
| 1022 | if (NbBits>0) |
---|
| 1023 | { |
---|
| 1024 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 1025 | { |
---|
| 1026 | unsigned long temp; |
---|
| 1027 | GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false); |
---|
| 1028 | temp+=LocalBufr.Orbit_Number; |
---|
| 1029 | specs[k].Orbit_Number=temp; |
---|
| 1030 | } |
---|
| 1031 | } |
---|
| 1032 | else |
---|
| 1033 | { |
---|
| 1034 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 1035 | specs[k].Orbit_Number=LocalBufr.Orbit_Number; |
---|
| 1036 | } |
---|
| 1037 | |
---|
| 1038 | GetNextBits(s4.lpData,13,sizeof(LocalBufr.Scan_Line_Number),&LocalBufr.Scan_Line_Number,false); |
---|
| 1039 | GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false); |
---|
| 1040 | if (NbBits>0) |
---|
| 1041 | { |
---|
| 1042 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 1043 | { |
---|
| 1044 | unsigned short temp; |
---|
| 1045 | GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false); |
---|
| 1046 | temp+=LocalBufr.Scan_Line_Number; |
---|
| 1047 | } |
---|
| 1048 | } |
---|
| 1049 | else |
---|
| 1050 | { |
---|
| 1051 | } |
---|
| 1052 | |
---|
| 1053 | GetNextBits(s4.lpData,8,sizeof(LocalBufr.Major_Frame_Count),&LocalBufr.Major_Frame_Count,false); |
---|
| 1054 | GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false); |
---|
| 1055 | if (NbBits>0) |
---|
| 1056 | { |
---|
| 1057 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 1058 | { |
---|
| 1059 | unsigned char temp; |
---|
| 1060 | GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false); |
---|
| 1061 | temp+=LocalBufr.Major_Frame_Count; |
---|
| 1062 | } |
---|
| 1063 | } |
---|
| 1064 | else |
---|
| 1065 | { |
---|
| 1066 | } |
---|
| 1067 | |
---|
| 1068 | GetNextBits(s4.lpData,15,sizeof(LocalBufr.Height_of_Station),&LocalBufr.Height_of_Station,false); |
---|
| 1069 | GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false); |
---|
| 1070 | if (NbBits>0) |
---|
| 1071 | { |
---|
| 1072 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 1073 | { |
---|
| 1074 | unsigned short temp; |
---|
| 1075 | GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false); |
---|
| 1076 | temp+=LocalBufr.Height_of_Station; |
---|
| 1077 | specs[k].Height_of_Station=temp/10.-4.; |
---|
| 1078 | } |
---|
| 1079 | } |
---|
| 1080 | else |
---|
| 1081 | { |
---|
| 1082 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 1083 | specs[k].Height_of_Station=LocalBufr.Height_of_Station/10.-4.; |
---|
| 1084 | } |
---|
| 1085 | |
---|
| 1086 | GetNextBits(s4.lpData, 2,sizeof(LocalBufr.GQisFlagQual),&LocalBufr.GQisFlagQual,false); |
---|
| 1087 | GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false); |
---|
| 1088 | if (NbBits>0) |
---|
| 1089 | { |
---|
| 1090 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 1091 | { |
---|
| 1092 | unsigned char temp; |
---|
| 1093 | GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false); |
---|
| 1094 | temp+=LocalBufr.GQisFlagQual; |
---|
| 1095 | specs[k].QualFlag=temp; |
---|
| 1096 | } |
---|
| 1097 | } |
---|
| 1098 | else |
---|
| 1099 | { |
---|
| 1100 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 1101 | specs[k].QualFlag=LocalBufr.GQisFlagQual; |
---|
| 1102 | } |
---|
| 1103 | |
---|
| 1104 | GetNextBits(s4.lpData, 7,sizeof(LocalBufr.QGisQualIndex),&LocalBufr.QGisQualIndex,false); |
---|
| 1105 | GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false); |
---|
| 1106 | if (NbBits>0) |
---|
| 1107 | { |
---|
| 1108 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 1109 | { |
---|
| 1110 | unsigned char temp; |
---|
| 1111 | GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false); |
---|
| 1112 | temp+=LocalBufr.QGisQualIndex; |
---|
| 1113 | } |
---|
| 1114 | } |
---|
| 1115 | else |
---|
| 1116 | { |
---|
| 1117 | } |
---|
| 1118 | |
---|
| 1119 | GetNextBits(s4.lpData, 7,sizeof(LocalBufr.QGisQualIndexLoc),&LocalBufr.QGisQualIndexLoc,false); |
---|
| 1120 | GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false); |
---|
| 1121 | if (NbBits>0) |
---|
| 1122 | { |
---|
| 1123 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 1124 | { |
---|
| 1125 | unsigned char temp; |
---|
| 1126 | GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false); |
---|
| 1127 | temp+=LocalBufr.QGisQualIndexLoc; |
---|
| 1128 | } |
---|
| 1129 | } |
---|
| 1130 | else |
---|
| 1131 | { |
---|
| 1132 | } |
---|
| 1133 | |
---|
| 1134 | GetNextBits(s4.lpData, 7,sizeof(LocalBufr.QGisQualIndexRad),&LocalBufr.QGisQualIndexRad,false); |
---|
| 1135 | GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false); |
---|
| 1136 | if (NbBits>0) |
---|
| 1137 | { |
---|
| 1138 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 1139 | { |
---|
| 1140 | unsigned char temp; |
---|
| 1141 | GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false); |
---|
| 1142 | temp+=LocalBufr.QGisQualIndexRad; |
---|
| 1143 | } |
---|
| 1144 | } |
---|
| 1145 | else |
---|
| 1146 | { |
---|
| 1147 | } |
---|
| 1148 | GetNextBits(s4.lpData, 7,sizeof(LocalBufr.QGisQualIndexSpect),&LocalBufr.QGisQualIndexSpect,false); |
---|
| 1149 | GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false); |
---|
| 1150 | if (NbBits>0) |
---|
| 1151 | { |
---|
| 1152 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 1153 | { |
---|
| 1154 | unsigned char temp; |
---|
| 1155 | GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false); |
---|
| 1156 | temp+=LocalBufr.QGisQualIndexSpect; |
---|
| 1157 | } |
---|
| 1158 | } |
---|
| 1159 | else |
---|
| 1160 | { |
---|
| 1161 | } |
---|
| 1162 | GetNextBits(s4.lpData,24,sizeof(LocalBufr.GQisQualIndexTexSondQual),&LocalBufr.GQisQualIndexTexSondQual,false); |
---|
| 1163 | GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false); |
---|
| 1164 | if (NbBits>0) |
---|
| 1165 | { |
---|
| 1166 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 1167 | { |
---|
| 1168 | unsigned long temp; |
---|
| 1169 | GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false); |
---|
| 1170 | temp+=LocalBufr.GQisQualIndexTexSondQual; |
---|
| 1171 | } |
---|
| 1172 | } |
---|
| 1173 | else |
---|
| 1174 | { |
---|
| 1175 | } |
---|
| 1176 | |
---|
| 1177 | for (int i=0;i<10;++i) |
---|
| 1178 | { |
---|
| 1179 | GetNextBits(s4.lpData,14,sizeof(LocalBufr.Band_Description[i].Start_Channel),&LocalBufr.Band_Description[i].Start_Channel,false); |
---|
| 1180 | GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false); |
---|
| 1181 | if (NbBits>0) |
---|
| 1182 | { |
---|
| 1183 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 1184 | { |
---|
| 1185 | unsigned short temp; |
---|
| 1186 | GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false); |
---|
| 1187 | temp+=LocalBufr.Band_Description[i].Start_Channel; |
---|
| 1188 | LocalChannel[k*10+i].Start_Channel=temp; |
---|
| 1189 | } |
---|
| 1190 | } |
---|
| 1191 | else |
---|
| 1192 | { |
---|
| 1193 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 1194 | LocalChannel[k*10+i].Start_Channel=LocalBufr.Band_Description[i].Start_Channel; |
---|
| 1195 | } |
---|
| 1196 | |
---|
| 1197 | GetNextBits(s4.lpData,14,sizeof(LocalBufr.Band_Description[i].End_Channel),&LocalBufr.Band_Description[i].End_Channel,false); |
---|
| 1198 | GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false); |
---|
| 1199 | if (NbBits>0) |
---|
| 1200 | { |
---|
| 1201 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 1202 | { |
---|
| 1203 | unsigned short temp; |
---|
| 1204 | GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false); |
---|
| 1205 | temp+=LocalBufr.Band_Description[i].End_Channel; |
---|
| 1206 | LocalChannel[k*10+i].End_Channel=temp; |
---|
| 1207 | } |
---|
| 1208 | } |
---|
| 1209 | else |
---|
| 1210 | { |
---|
| 1211 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 1212 | LocalChannel[k*10+i].End_Channel=LocalBufr.Band_Description[i].End_Channel; |
---|
| 1213 | } |
---|
| 1214 | |
---|
| 1215 | GetNextBits(s4.lpData, 6,sizeof(LocalBufr.Band_Description[i].Channel_Scale_Factor),&LocalBufr.Band_Description[i].Channel_Scale_Factor,false); |
---|
| 1216 | GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false); |
---|
| 1217 | if (NbBits>0) |
---|
| 1218 | { |
---|
| 1219 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 1220 | { |
---|
| 1221 | unsigned char temp; |
---|
| 1222 | GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false); |
---|
| 1223 | temp+=LocalBufr.Band_Description[i].Channel_Scale_Factor; |
---|
| 1224 | LocalChannel[k*10+i].Channel_Scale_Factor=temp; |
---|
| 1225 | } |
---|
| 1226 | } |
---|
| 1227 | else |
---|
| 1228 | { |
---|
| 1229 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 1230 | LocalChannel[k*10+i].Channel_Scale_Factor=LocalBufr.Band_Description[i].Channel_Scale_Factor; |
---|
| 1231 | } |
---|
| 1232 | } |
---|
| 1233 | |
---|
| 1234 | for (int i=0;i<87;++i) |
---|
| 1235 | { |
---|
| 1236 | for (int j=0;j<100;++j) |
---|
| 1237 | { |
---|
| 1238 | GetNextBits(s4.lpData,14,sizeof(LocalBufr.Channels_Sequence[i].Channel_Number[j]),&LocalBufr.Channels_Sequence[i].Channel_Number[j],false); |
---|
| 1239 | GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false); |
---|
| 1240 | if (NbBits>0) |
---|
| 1241 | { |
---|
| 1242 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 1243 | { |
---|
| 1244 | unsigned short temp; |
---|
| 1245 | GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false); |
---|
| 1246 | temp+=LocalBufr.Channels_Sequence[i].Channel_Number[j]; |
---|
| 1247 | } |
---|
| 1248 | } |
---|
| 1249 | else |
---|
| 1250 | { |
---|
| 1251 | } |
---|
| 1252 | GetNextBits(s4.lpData,16,sizeof(LocalBufr.Channels_Sequence[i].Scaled_Iasi_Radiance[j]),&LocalBufr.Channels_Sequence[i].Scaled_Iasi_Radiance[j],false); |
---|
| 1253 | GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false); |
---|
| 1254 | if (NbBits>0) |
---|
| 1255 | { |
---|
| 1256 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 1257 | { |
---|
| 1258 | unsigned short temp; |
---|
| 1259 | GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false); |
---|
| 1260 | temp+=LocalBufr.Channels_Sequence[i].Scaled_Iasi_Radiance[j]; |
---|
| 1261 | specs[k].Radiance[i*100+j]=temp-5000.; |
---|
| 1262 | } |
---|
| 1263 | } |
---|
| 1264 | else |
---|
| 1265 | { |
---|
| 1266 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 1267 | specs[k].Radiance[i*100+j]=LocalBufr.Channels_Sequence[i].Scaled_Iasi_Radiance[j]-5000.; |
---|
| 1268 | } |
---|
| 1269 | } |
---|
| 1270 | } |
---|
| 1271 | |
---|
| 1272 | |
---|
| 1273 | // Scale radiances... |
---|
| 1274 | for (long i=0;i<10;++i) |
---|
| 1275 | { |
---|
| 1276 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 1277 | { |
---|
| 1278 | if (LocalChannel[k*10+i].Start_Channel<=8700) |
---|
| 1279 | { |
---|
| 1280 | for (long j=LocalChannel[k*10+i].Start_Channel-1;j<LocalChannel[k*10+i].End_Channel;++j) |
---|
| 1281 | { |
---|
| 1282 | specs[k].Radiance[j]*=pow(10.,-LocalChannel[k*10+i].Channel_Scale_Factor); |
---|
| 1283 | } |
---|
| 1284 | } |
---|
| 1285 | } |
---|
| 1286 | } |
---|
| 1287 | |
---|
| 1288 | GetNextBits(s4.lpData,11,sizeof(LocalBufr.Satellite_Instruments_2),&LocalBufr.Satellite_Instruments_2,false); |
---|
| 1289 | GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false); |
---|
| 1290 | if (NbBits>0) |
---|
| 1291 | { |
---|
| 1292 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 1293 | { |
---|
| 1294 | unsigned short temp; |
---|
| 1295 | GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false); |
---|
| 1296 | temp+=LocalBufr.Satellite_Instruments_2; |
---|
| 1297 | } |
---|
| 1298 | } |
---|
| 1299 | else |
---|
| 1300 | { |
---|
| 1301 | } |
---|
| 1302 | |
---|
| 1303 | GetNextBits(s4.lpData, 7,sizeof(LocalBufr.AVHRR_channel_combination),&LocalBufr.AVHRR_channel_combination,false); |
---|
| 1304 | // 1 bit per channel at most 6, 127 (0x7F) if absent. |
---|
| 1305 | GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false); |
---|
| 1306 | if (NbBits>0) |
---|
| 1307 | { |
---|
| 1308 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 1309 | { |
---|
| 1310 | unsigned char temp; |
---|
| 1311 | GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false); |
---|
| 1312 | temp+=LocalBufr.AVHRR_channel_combination; |
---|
| 1313 | } |
---|
| 1314 | } |
---|
| 1315 | else |
---|
| 1316 | { |
---|
| 1317 | } |
---|
| 1318 | |
---|
| 1319 | //Reset AVHRR Scenes |
---|
| 1320 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 1321 | { |
---|
| 1322 | for (int i=0;i<6;++i) // Pixels AVHRR |
---|
| 1323 | { |
---|
| 1324 | specs[k].Cloud_Free_Fraction[i]=-1.; |
---|
| 1325 | for (int j=0;j<7;++j) |
---|
| 1326 | { |
---|
| 1327 | specs[k].AVHRR_Mean[i][j]=-1.; |
---|
| 1328 | specs[k].AVHRR_Std[i][j]=-1.; |
---|
| 1329 | } |
---|
| 1330 | } |
---|
| 1331 | } |
---|
| 1332 | |
---|
| 1333 | /* |
---|
| 1334 | Now we have 7 AVHRR Scenes |
---|
| 1335 | Each of them contains |
---|
| 1336 | - Y angular position 24 bits -8000000 *10^6 16777215 FFFFFF |
---|
| 1337 | - Z angular position 24 bits -8000000 *10^6 16777215 FFFFFF |
---|
| 1338 | - Fraction HIRS clear pixel 7 bits 127 7F |
---|
| 1339 | - 6 Channels |
---|
| 1340 | with - Channel Number 6 bits 63 3F |
---|
| 1341 | - Scale Factor 6 bits 63 3F |
---|
| 1342 | - Mean Radiance 31 bits 2147483647 7FFFFFFF |
---|
| 1343 | - Scale Factor 6 bits 63 3F |
---|
| 1344 | - StDev Radiance 31 bits 2147483647 7FFFFFFF |
---|
| 1345 | */ |
---|
| 1346 | |
---|
| 1347 | for (int i=0;i<7;++i) // AVHRR Scenes |
---|
| 1348 | { |
---|
| 1349 | GetNextBits(s4.lpData,24,sizeof(LocalBufr.AVHRR_Scene_Sequence[i].Y_angular_position),&LocalBufr.AVHRR_Scene_Sequence[i].Y_angular_position,false); |
---|
| 1350 | GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false); |
---|
| 1351 | if (NbBits>24) |
---|
| 1352 | { |
---|
| 1353 | return FALSE; |
---|
| 1354 | } |
---|
| 1355 | if (NbBits>0) |
---|
| 1356 | { |
---|
| 1357 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 1358 | { |
---|
| 1359 | unsigned long temp; |
---|
| 1360 | GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false); |
---|
| 1361 | temp+=LocalBufr.AVHRR_Scene_Sequence[i].Y_angular_position; |
---|
| 1362 | } |
---|
| 1363 | } |
---|
| 1364 | else |
---|
| 1365 | { |
---|
| 1366 | } |
---|
| 1367 | |
---|
| 1368 | GetNextBits(s4.lpData,24,sizeof(LocalBufr.AVHRR_Scene_Sequence[i].Z_angular_position),&LocalBufr.AVHRR_Scene_Sequence[i].Z_angular_position,false); |
---|
| 1369 | GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false); |
---|
| 1370 | if (NbBits>24) |
---|
| 1371 | { |
---|
| 1372 | return FALSE; |
---|
| 1373 | } |
---|
| 1374 | if (NbBits>0) |
---|
| 1375 | { |
---|
| 1376 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 1377 | { |
---|
| 1378 | unsigned long temp; |
---|
| 1379 | GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false); |
---|
| 1380 | temp+=LocalBufr.AVHRR_Scene_Sequence[i].Z_angular_position; |
---|
| 1381 | } |
---|
| 1382 | } |
---|
| 1383 | else |
---|
| 1384 | { |
---|
| 1385 | } |
---|
| 1386 | |
---|
| 1387 | GetNextBits(s4.lpData, 7,sizeof(LocalBufr.AVHRR_Scene_Sequence[i].Fraction_clear_pixels_HIRS),&LocalBufr.AVHRR_Scene_Sequence[i].Fraction_clear_pixels_HIRS,false); |
---|
| 1388 | GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false); |
---|
| 1389 | if (NbBits>7) |
---|
| 1390 | { |
---|
| 1391 | return FALSE; |
---|
| 1392 | } |
---|
| 1393 | if (NbBits>0) |
---|
| 1394 | { |
---|
| 1395 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 1396 | { |
---|
| 1397 | unsigned char temp; |
---|
| 1398 | GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false); |
---|
| 1399 | temp+=LocalBufr.AVHRR_Scene_Sequence[i].Fraction_clear_pixels_HIRS; |
---|
| 1400 | specs[k].Cloud_Free_Fraction [i]=(double)temp; |
---|
| 1401 | } |
---|
| 1402 | } |
---|
| 1403 | else |
---|
| 1404 | { |
---|
| 1405 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 1406 | { |
---|
| 1407 | specs[k].Cloud_Free_Fraction[i]=(double)LocalBufr.AVHRR_Scene_Sequence[i].Fraction_clear_pixels_HIRS; |
---|
| 1408 | } |
---|
| 1409 | } |
---|
| 1410 | |
---|
| 1411 | for (int j=0;j<6;++j) // Channels |
---|
| 1412 | { |
---|
| 1413 | GetNextBits(s4.lpData, 6,sizeof(LocalBufr.AVHRR_Scene_Sequence[i].Channel_Number[j]),&LocalBufr.AVHRR_Scene_Sequence[i].Channel_Number[j],false); |
---|
| 1414 | GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false); |
---|
| 1415 | if (NbBits>6) |
---|
| 1416 | { |
---|
| 1417 | return FALSE; |
---|
| 1418 | } |
---|
| 1419 | if (NbBits>0) |
---|
| 1420 | { |
---|
| 1421 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 1422 | { |
---|
| 1423 | unsigned char temp; |
---|
| 1424 | GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false); |
---|
| 1425 | temp+=LocalBufr.AVHRR_Scene_Sequence[i].Channel_Number[j]; |
---|
| 1426 | } |
---|
| 1427 | } |
---|
| 1428 | else |
---|
| 1429 | { |
---|
| 1430 | } |
---|
| 1431 | |
---|
| 1432 | GetNextBits(s4.lpData, 6,sizeof(LocalBufr.AVHRR_Scene_Sequence[i].Channel_Scale_Factor_1[j]),&LocalBufr.AVHRR_Scene_Sequence[i].Channel_Scale_Factor_1[j],false); |
---|
| 1433 | GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false); |
---|
| 1434 | if (NbBits>6) |
---|
| 1435 | { |
---|
| 1436 | return FALSE; |
---|
| 1437 | } |
---|
| 1438 | if (NbBits>0) |
---|
| 1439 | { |
---|
| 1440 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 1441 | { |
---|
| 1442 | unsigned char temp; |
---|
| 1443 | GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false); |
---|
| 1444 | temp+=LocalBufr.AVHRR_Scene_Sequence[i].Channel_Scale_Factor_1[j]; |
---|
| 1445 | specs[k].AVHRR_Mean[j][i]=pow(10.,-temp); |
---|
| 1446 | } |
---|
| 1447 | } |
---|
| 1448 | else |
---|
| 1449 | { |
---|
| 1450 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 1451 | { |
---|
| 1452 | specs[k].AVHRR_Mean[j][i]=pow(10.,-LocalBufr.AVHRR_Scene_Sequence[i].Channel_Scale_Factor_1[j]); |
---|
| 1453 | } |
---|
| 1454 | } |
---|
| 1455 | |
---|
| 1456 | GetNextBits(s4.lpData,31,sizeof(LocalBufr.AVHRR_Scene_Sequence[i].Scaled_Mean_AVHRR_Rad[j]),&LocalBufr.AVHRR_Scene_Sequence[i].Scaled_Mean_AVHRR_Rad[j],false); |
---|
| 1457 | GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false); |
---|
| 1458 | if (NbBits>31) |
---|
| 1459 | { |
---|
| 1460 | return FALSE; |
---|
| 1461 | } |
---|
| 1462 | if (NbBits>0) |
---|
| 1463 | { |
---|
| 1464 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 1465 | { |
---|
| 1466 | unsigned long temp; |
---|
| 1467 | GetNextBits(s4.lpData,NbBits,4,&temp,false); |
---|
| 1468 | temp+=LocalBufr.AVHRR_Scene_Sequence[i].Scaled_Mean_AVHRR_Rad[j]; |
---|
| 1469 | specs[k].AVHRR_Mean[j][i]=specs[k].AVHRR_Mean[j][i]*(double)temp; |
---|
| 1470 | } |
---|
| 1471 | } |
---|
| 1472 | else |
---|
| 1473 | { |
---|
| 1474 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 1475 | { |
---|
| 1476 | specs[k].AVHRR_Mean[j][i]*=LocalBufr.AVHRR_Scene_Sequence[i].Scaled_Mean_AVHRR_Rad[j]; |
---|
| 1477 | } |
---|
| 1478 | } |
---|
| 1479 | |
---|
| 1480 | GetNextBits(s4.lpData, 6,sizeof(LocalBufr.AVHRR_Scene_Sequence[i].Channel_Scale_Factor_2[j]),&LocalBufr.AVHRR_Scene_Sequence[i].Channel_Scale_Factor_2[j],false); |
---|
| 1481 | GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false); |
---|
| 1482 | if (NbBits>6) |
---|
| 1483 | { |
---|
| 1484 | return FALSE; |
---|
| 1485 | } |
---|
| 1486 | if (NbBits>0) |
---|
| 1487 | { |
---|
| 1488 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 1489 | { |
---|
| 1490 | unsigned char temp; |
---|
| 1491 | GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false); |
---|
| 1492 | temp+=LocalBufr.AVHRR_Scene_Sequence[i].Channel_Scale_Factor_2[j]; |
---|
| 1493 | specs[k].AVHRR_Std[j][i]=pow(10.,-temp); |
---|
| 1494 | } |
---|
| 1495 | } |
---|
| 1496 | else |
---|
| 1497 | { |
---|
| 1498 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 1499 | specs[k].AVHRR_Std[j][i]=pow(10.,-LocalBufr.AVHRR_Scene_Sequence[i].Channel_Scale_Factor_2[j]); |
---|
| 1500 | } |
---|
| 1501 | |
---|
| 1502 | GetNextBits(s4.lpData,31,sizeof(LocalBufr.AVHRR_Scene_Sequence[i].Scaled_Std_AVHRR_Rad[j]),&LocalBufr.AVHRR_Scene_Sequence[i].Scaled_Std_AVHRR_Rad[j],false); |
---|
| 1503 | GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false); |
---|
| 1504 | if (NbBits>31) |
---|
| 1505 | { |
---|
| 1506 | return FALSE; |
---|
| 1507 | } |
---|
| 1508 | if (NbBits>0) |
---|
| 1509 | { |
---|
| 1510 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 1511 | { |
---|
| 1512 | unsigned long temp; |
---|
| 1513 | GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false); |
---|
| 1514 | temp+=LocalBufr.AVHRR_Scene_Sequence[i].Scaled_Std_AVHRR_Rad[j]; |
---|
| 1515 | specs[k].AVHRR_Std[j][i]*=temp; |
---|
| 1516 | } |
---|
| 1517 | } |
---|
| 1518 | else |
---|
| 1519 | { |
---|
| 1520 | for (long k=0;k<s3.Number_Subsets;++k) |
---|
| 1521 | specs[k].AVHRR_Std[j][i]*=LocalBufr.AVHRR_Scene_Sequence[i].Scaled_Std_AVHRR_Rad[j]; |
---|
| 1522 | } |
---|
| 1523 | |
---|
| 1524 | } |
---|
| 1525 | } |
---|
| 1526 | return TRUE; |
---|
| 1527 | } |
---|