OB.DAAC Logo
NASA Logo
Ocean Color Science Software

ocssw V2022
swl0_utils.c
Go to the documentation of this file.
1 /* ============================================================== */
2 /* Module: swl0_utils.c */
3 /* Purpose: Utilities for manipulating seawifs L0 data. */
4 /* Author: B.A. Franz, General Scences Corp., 9/97 */
5 /* ============================================================== */
6 
7 #include <stdio.h>
8 #include <sys/types.h>
9 #include <sys/stat.h>
10 #include <time.h>
11 #include <math.h>
12 #include "swl0_proto.h"
13 
14 #define TIMELEN 25
15 
16 /* -------------------------------------------------------------- */
17 /* scid2mnftype() - decoms the spacecraft ID to minor frame type */
18 
19 /* -------------------------------------------------------------- */
20 INT16 scid2mnftype(INT16 scid[]) {
21  return (scid[1] & 0x000F);
22 }
23 
24 
25 /* -------------------------------------------------------------- */
26 /* scid2mnftype() - decoms the spacecraft ID to minor frame numb */
27 
28 /* -------------------------------------------------------------- */
29 INT16 scid2mnfnum(INT16 scid[]) {
30  return ( (scid[0] & 0x0180) >> 7);
31 }
32 
33 
34 /* -------------------------------------------------------------- */
35 /* ttag2unix() - converts seawifs timetags to secs since 1/1/70 */
36 
37 /* -------------------------------------------------------------- */
38 FLOAT64 ttag2unix(INT16 ttag[]) {
39  FLOAT64 sec = 7.2688320e8; /* secs from 1/1/70 to 1/13/93 */
40  INT32 day = 0;
41  INT32 msec = 0;
42 
43  day = ttag[0] << 3 | ttag[1] >> 7;
44  msec = (ttag[1] & 0x7F) << 20 | (ttag[2] << 10) | ttag[3];
45  sec += ((double) day) * 86400.0 + ((double) msec) / 1000.0;
46 
47  return sec;
48 }
49 
50 
51 /* -------------------------------------------------------------- */
52 /* unix2timeStr() - converts secs since 1/1/70 to timedate string */
53 
54 /* -------------------------------------------------------------- */
55 char *unix2timeStr(FLOAT64 usec) {
56  struct tm *trec;
57  time_t utime = (time_t) usec;
58  static char timeStr[TIMELEN];
59 
60  trec = gmtime(&utime);
61  strftime(timeStr, TIMELEN, "%b %d %Y %H:%M:%S:000", trec);
62 
63  return (timeStr);
64 }
65 
66 
67 /* -------------------------------------------------------------- */
68 /* ttag2ydmsec() - converts seawifs timetags to year, day, msec */
69 
70 /* -------------------------------------------------------------- */
71 void ttag2ydmsec(INT16 ttag[], INT16 *year, INT16 *day, INT32 *msec) {
72  INT32 jday; /* julian day number */
73  INT32 rday; /* reference day number */
74 
75  *msec = (ttag[1] & 0x7F) << 20 | (ttag[2] << 10) | ttag[3];
76  jday = (ttag[0] << 3 | ttag[1] >> 7) + 2449001;
77 
78  /* The following was taken from jdate.f of F. S. Patt */
79  rday = jday - 2415020; /* Days since January 0, 1900 */
80  *year = 4 * rday / 1461; /* Years since 1900 */
81 
82  *day = rday - 1461 * (*year - 1) / 4 - 365;
83  *year += 1900;
84 
85  return;
86 }
87 
88 
89 /* -------------------------------------------------------------- */
90 /* filesize() - returns file length in bytes */
91 
92 /* -------------------------------------------------------------- */
93 INT32 filesize(const char *filename) {
94  struct stat buf;
95  INT32 ret;
96 
97  ret = stat(filename, &buf);
98  if (ret < 0)
99  return (ret);
100  else
101  return (buf.st_size);
102 }
103 
104 
105 /* -------------------------------------------------------------- */
106 /* timeError() - returns > 0 if any time error flag is set. */
107 
108 /* -------------------------------------------------------------- */
109 BYTE timeError(swl0indx *indx, INT32 irec) {
110  return ( indx->rec[irec].tRanError ||
111  indx->rec[irec].tSeqError ||
112  indx->rec[irec].tDifError);
113 }
114 
115 
116 /* -------------------------------------------------------------- */
117 /* timeSeqError() - returns > 0 if timetags not increasing. Only */
118 /* identifies single-frame sequence errors. */
119 
120 /* -------------------------------------------------------------- */
121 BYTE timeSeqError(swl0indx *indx, INT32 irec) {
122  INT32 i1 = MAX(irec - 1, 0);
123  INT32 i2 = irec;
124  INT32 i3 = MIN(irec + 1, indx->nrecs - 1);
125 
126  if (irec < 0 || irec >= indx->nrecs)
127  return (0);
128 
129  /* Use times that were previously unflagged, if possible. */
130  while (i1 > 0 && timeError(indx, i1)) i1--;
131  while (i3 < indx->nrecs - 1 && timeError(indx, i3)) i3++;
132 
133  /* Don't attempt test if frames are already flagged */
134  if (timeError(indx, i1) || timeError(indx, i2) || timeError(indx, i3))
135  return (0);
136 
137  /* Frame type must be consistent for this test. */
138  if (indx->type != HRPT &&
139  (indx->rec[i2].mnftype != indx->rec[i1].mnftype ||
140  indx->rec[i2].mnftype != indx->rec[i3].mnftype)) {
141  return (0);
142  }
143 
144  /* Check for large deviations at start and end frames */
145  if ((irec == 0) &&
146  (indx->rec[i3].time - indx->rec[i2].time > DELSCENEGAC))
147  return (1);
148  if ((irec == indx->nrecs - 1) &&
149  (indx->rec[i2].time - indx->rec[i1].time > DELSCENEGAC))
150  return (1);
151  if ((irec == 0) &&
152  (indx->rec[i3].time - indx->rec[i2].time <= 0))
153  return (1);
154  if ((irec == indx->nrecs - 1) &&
155  (indx->rec[i2].time - indx->rec[i1].time <= 0))
156  return (1);
157 
158  /* Bounding times must be sequential for test to be valid. We don't */
159  /* to flag the wrong frame. */
160  if (indx->rec[i3].time < indx->rec[i1].time)
161  return (0);
162 
163  /* General case */
164  if ((indx->rec[i2].time < indx->rec[i1].time) ||
165  (indx->rec[i2].time > indx->rec[i3].time) ||
166  ((i1 != i2) && (indx->rec[i2].time == indx->rec[i1].time)))
167 
168  return (1);
169 
170  return (0);
171 }
172 
173 
174 /* -------------------------------------------------------------- */
175 /* timeContiguous() - returns 1 if timetags are contiguous */
176 
177 /* -------------------------------------------------------------- */
178 BYTE timeContiguous(swl0indx *indx, INT32 irec) {
179  INT32 i1;
180  INT32 i2;
181  INT32 i3;
182  FLOAT64 DelTime;
183  FLOAT64 tdiff1;
184  FLOAT64 tdiff2;
185 
186  if (irec < 0 || irec >= indx->nrecs)
187  return (0);
188 
189  /* Determine appropriate center and bounding indices */
190  if (irec == 0) {
191  i1 = 0;
192  i2 = MIN(1, indx->nrecs - 1);
193  i3 = MIN(2, indx->nrecs - 1);
194  } else if (irec == indx->nrecs - 1) {
195  i3 = indx->nrecs - 1;
196  i2 = MAX(i3 - 1, 0);
197  i1 = MAX(i3 - 2, 0);
198  } else {
199  i1 = MAX(irec - 1, 0);
200  i2 = irec;
201  i3 = MIN(irec + 1, indx->nrecs - 1);
202  }
203 
204  /* Frame must be (thus far) free of timing errors */
205  if (timeError(indx, i1) || timeError(indx, i2) || timeError(indx, i3)) {
206  printf("Previous timing error(s) at frame %d\n", irec);
207  return (0);
208  }
209 
210  /* Frame SCID field must be valid */
211  if (indx->rec[i1].scidError ||
212  indx->rec[i2].scidError ||
213  indx->rec[i3].scidError) {
214  printf("Previous SCID error(s) at frame %d\n", irec);
215  return (0);
216  }
217 
218  /* Frame type must be consistent as well. */
219  if (indx->rec[i2].mnftype != indx->rec[i1].mnftype ||
220  indx->rec[i2].mnftype != indx->rec[i3].mnftype) {
221  printf("Inconsistent frame types at frame %d\n", irec);
222  return (0);
223  }
224 
225  /* Determine expected time difference between frames */
226  if (indx->rec[i2].mnftype == GACTYPE)
227  DelTime = DTGAC;
228  else
229  DelTime = DTLAC;
230 
231  /* Compute actual differences */
232  tdiff1 = indx->rec[i2].time - indx->rec[i1].time;
233  tdiff2 = indx->rec[i3].time - indx->rec[i2].time;
234 
235  /* Check center time relative to bounding frames */
236  if (tdiff1 > DelTime - CLOCKVAR &&
237  tdiff1 < DelTime + CLOCKVAR &&
238  tdiff2 > DelTime - CLOCKVAR &&
239  tdiff2 < DelTime + CLOCKVAR)
240  return (1);
241  else {
242  printf("%d %lf %lf\n", irec, tdiff1, tdiff2);
243  return (0);
244  }
245 }
246 
247 
248 /* -------------------------------------------------------------- */
249 /* timeConsistent() - returns 0 if timetag differences are not */
250 /* multiples of expected frame rate */
251 /* Note that this will not detect shifts, as it looks for timetag */
252 /* which is inconsistent with the preceeding and following times */
253 
254 /* -------------------------------------------------------------- */
255 BYTE timeConsistent(swl0indx *indx, INT32 irec) {
256  INT32 i1;
257  INT32 i2;
258  INT32 i3;
259  FLOAT64 DelTime;
260  FLOAT64 DelScene;
261  FLOAT64 tdiff1;
262  FLOAT64 tdiff2;
263  FLOAT64 terror1;
264  FLOAT64 terror2;
265 
266  if (irec < 0 || irec >= indx->nrecs)
267  return (1);
268 
269  /* Determine appropriate center and bounding indices */
270  if (irec == 0) {
271  i1 = 0;
272  i2 = MIN(1, indx->nrecs - 1);
273  i3 = MIN(2, indx->nrecs - 1);
274  } else if (irec == indx->nrecs - 1) {
275  i3 = indx->nrecs - 1;
276  i2 = MAX(i3 - 1, 0);
277  i1 = MAX(i3 - 2, 0);
278  } else {
279  i1 = MAX(irec - 1, 0);
280  i2 = irec;
281  i3 = MIN(irec + 1, indx->nrecs - 1);
282  }
283 
284  /* Avoid time difference test across frame type changes. */
285  if (indx->rec[i2].mnftype == GACTYPE &&
286  (indx->rec[i3].mnftype != indx->rec[i1].mnftype)) {
287  return (1);
288  }
289 
290  /* Determine expected time difference between frames */
291  if (indx->rec[i2].mnftype == GACTYPE) {
292  DelTime = DTGAC;
293  DelScene = DELSCENEGAC;
294  } else {
295  DelTime = DTLAC;
296  DelScene = DELSCENELAC;
297  }
298 
299  /* Compute actual differences */
300  tdiff1 = indx->rec[i2].time - indx->rec[i1].time;
301  tdiff2 = indx->rec[i3].time - indx->rec[i2].time;
302 
303  /* Avoid consistency check across scene breaks, GAC/LAC files only */
304  if (indx->type == GAC && (tdiff1 > DelScene || tdiff2 > DelScene))
305  return (1);
306 
307  /* Compute residual error */
308  terror1 = fmod(tdiff1, DelTime);
309  terror2 = fmod(tdiff2, DelTime);
310  terror1 = ABS(terror1);
311  terror2 = ABS(terror2);
312  if (terror1 > DelTime / 2) terror1 = ABS(terror1 - DelTime);
313  if (terror2 > DelTime / 2) terror2 = ABS(terror2 - DelTime);
314 
315  /* Check error relative to allowed clock variance. We require time */
316  /* error on both sides of the center frame, as we want to avoid */
317  /* flagging both frames across a time shift. */
318 
319  if (tdiff1 == 0.0 || (terror1 > CLOCKVAR && terror2 > CLOCKVAR)) {
320  printf("Time Difference Error at Frame %d: %lf %lf %lf\n",
321  irec, tdiff1, terror1, terror2);
322  return (0);
323  } else {
324  return (1);
325  }
326 }
327 
328 
329 /* -------------------------------------------------------------- */
330 /* timeShifted() - returns 0 if timetag differences are not */
331 /* multiples of expected frame rate */
332 
333 /* -------------------------------------------------------------- */
334 BYTE timeShifted(swl0indx *indx, INT32 irec, FLOAT64 *shiftval) {
335  INT32 i1;
336  INT32 i2;
337  INT32 i3;
338  FLOAT64 DelTime;
339  FLOAT64 DelScene;
340  FLOAT64 tdiff1;
341  FLOAT64 tdiff2;
342  FLOAT64 terror1;
343  FLOAT64 terror2;
344 
345  *shiftval = 0.0;
346 
347  if (irec < 0 || irec >= indx->nrecs)
348  return (1);
349 
350  /* Determine appropriate center and bounding indices */
351  if (irec == 0) {
352  i1 = 0;
353  i2 = MIN(1, indx->nrecs - 1);
354  i3 = MIN(2, indx->nrecs - 1);
355  } else if (irec == indx->nrecs - 1) {
356  i3 = indx->nrecs - 1;
357  i2 = MAX(i3 - 1, 0);
358  i1 = MAX(i3 - 2, 0);
359  } else {
360  i1 = MAX(irec - 1, 0);
361  i2 = irec;
362  i3 = MIN(irec + 1, indx->nrecs - 1);
363  }
364 
365  /* Avoid time difference test across frame type changes. */
366  if (indx->rec[i2].mnftype == GACTYPE &&
367  (indx->rec[i3].mnftype != indx->rec[i1].mnftype)) {
368  return (0);
369  }
370 
371  /* Determine expected time difference between frames */
372  if (indx->rec[i2].mnftype == GACTYPE) {
373  DelTime = DTGAC;
374  DelScene = DELSCENEGAC;
375  } else {
376  DelTime = DTLAC;
377  DelScene = DELSCENELAC;
378  }
379 
380  /* Compute actual differences */
381  tdiff1 = indx->rec[i2].time - indx->rec[i1].time;
382  tdiff2 = indx->rec[i3].time - indx->rec[i2].time;
383 
384  /* Avoid check across scene breaks, GAC/LAC files only */
385  if (indx->type == GAC && (tdiff1 > DelScene || tdiff2 > DelScene))
386  return (0);
387 
388  /* Compute residual error */
389  terror1 = fmod(tdiff1, DelTime);
390  if (tdiff1 < DelTime)
391  terror1 -= DelTime;
392 
393  terror2 = fmod(tdiff2, DelTime);
394  if (tdiff2 < DelTime)
395  terror2 -= DelTime;
396 
397 
398  /* Check error relative to allowed clock variance. We require time */
399  /* shift preceeding center frame, and no timeshift following. */
400 
401  if (fabs(terror1) > CLOCKVAR && fabs(terror2) <= CLOCKVAR) {
402  *shiftval = terror1;
403  printf("Time Shift at Frame %d: %lf of %lf secs\n",
404  irec, tdiff1, *shiftval);
405  return (1);
406  } else {
407  return (0);
408  }
409 }
410 
411 
412 /* -------------------------------------------------------------- */
413 /* sohHdrError() - returns > 0 if bytes do not match SOH header */
414 
415 /* -------------------------------------------------------------- */
416 BYTE sohHdrError(BYTE hdr[]) {
417  BYTE status = 0;
418  BYTE msghdr[6] = {225, 1, 193, 28, 0, 3};
419  int i;
420 
421  for (i = 0; i < 6; i++)
422  if (hdr[i + 2] != msghdr[i])
423  status = 1;
424 
425  /*
426  if (status)
427  printf("Bad SOH header: %3d %3d %3d %3d %3d %3d \n",
428  hdr[2],hdr[3],hdr[4],hdr[5],hdr[6],hdr[7]);
429  */
430 
431  return (status);
432 }
433 
434 
435 /* -------------------------------------------------------------- */
436 /* bitError() - computes bit errors based on image data */
437 /* */
438 /* Returns 1 if any errors found. */
439 
440 /* -------------------------------------------------------------- */
441 BYTE bitError(BYTE mnf[], INT32 *totbits, INT32 *toterrs) {
442  INT32 numbits;
443  INT32 numerrs;
444 
445  startBitError(mnf, &numbits, &numerrs);
446  *totbits = numbits;
447  *toterrs = numerrs;
448 
449  stopBitError(mnf, &numbits, &numerrs);
450  *totbits += numbits;
451  *toterrs += numerrs;
452 
453  if (*toterrs > 0)
454  return (1);
455  else
456  return (0);
457 }
458 
459 
460 /* -------------------------------------------------------------- */
461 /* startBitError() - computes bit errors based on image data */
462 /* */
463 /* Uses the known pattern of the start-pixel field to compute the */
464 /* number of bits which deviate from expectation. There is one */
465 /* start-pixel in LAC and 5 in GAC, so the test is more */
466 /* comprehensive for GAC frames. Returns 1 if any errors found. */
467 
468 /* -------------------------------------------------------------- */
469 BYTE startBitError(BYTE mnf[], INT32 *numbits, INT32 *numerrs) {
470  INT16 scid[2];
471  INT16 mnftype;
472  BYTE mask[] = {3, 255, 0, 0, 3, 255, 0, 0, 3, 255, 0, 0, 3, 255};
473  BYTE npix;
474  INT16 offset = 0; /* byte offset to first start-pixel */
475  BYTE m, x, z;
476  int i, j;
477 
478  memcpy(scid, &mnf[O_SCID], sizeof (scid));
479  if (endianess() == 1)
480  swapc_bytes((char *) scid, 2, 2);
481  mnftype = scid2mnftype(scid);
482 
483  if (mnftype == GACTYPE) {
484  npix = 5;
485  *numbits = 350;
486  offset = 806;
487  } else if (mnftype == LACTYPE) {
488  npix = 1;
489  *numbits = 70;
490  offset = 894;
491  } else {
492  npix = 0;
493  *numbits = 0;
494  }
495  *numerrs = 0;
496 
497  for (i = 0; i < npix; i++) {
498  for (j = 0; j < 14; j++) {
499  x = mnf[offset + (4032 * i) + j];
500  m = mask[j];
501  if (x != m) {
502  z = x ^ m;
503  while (z) {
504  if (z & 0x1)
505  (*numerrs)++;
506  z = z >> 1;
507  }
508  }
509  }
510  }
511 
512  if (*numerrs > 0)
513  return (1);
514  else
515  return (0);
516 }
517 
518 
519 /* -------------------------------------------------------------- */
520 /* stopBitError() - computes bit errors based on image data */
521 /* */
522 /* Uses the known pattern of the stop-pixel field to compute the */
523 /* number of bits which deviate from expectation. There is one */
524 /* start-pixel in LAC and 5 in GAC, so the test is more */
525 /* comprehensive for GAC frames. Returns 1 if any errors found. */
526 
527 /* -------------------------------------------------------------- */
528 BYTE stopBitError(BYTE mnf[], INT32 *numbits, INT32 *numerrs) {
529  INT16 scid[2];
530  INT16 mnftype;
531  BYTE mask[] = {3, 255, 3, 255, 0, 0, 0, 0, 3, 255, 3, 255, 0, 0};
532  BYTE npix;
533  INT16 offset = 0; /* byte offset to first start-pixel */
534  BYTE m, x, z;
535  int i, j;
536 
537  memcpy(scid, &mnf[O_SCID], sizeof (scid));
538  if (endianess() == 1)
539  swapc_bytes((char *) scid, 2, 2);
540  mnftype = scid2mnftype(scid);
541 
542  if (mnftype == GACTYPE) {
543  npix = 5;
544  *numbits = 350;
545  offset = 806 + 2000 * 2;
546  } else if (mnftype == LACTYPE) {
547  npix = 1;
548  *numbits = 70;
549  offset = 894 + 10296 * 2;
550  } else {
551  npix = 0;
552  *numbits = 0;
553  }
554  *numerrs = 0;
555 
556  for (i = 0; i < npix; i++) {
557  for (j = 0; j < 14; j++) {
558  x = mnf[offset + (4032 * i) + j];
559  m = mask[j];
560  if (x != m) {
561  z = x ^ m;
562  while (z) {
563  if (z & 0x1)
564  (*numerrs)++;
565  z = z >> 1;
566  }
567  }
568  }
569  }
570 
571  if (*numerrs > 0)
572  return (1);
573  else
574  return (0);
575 }
576 
577 /* -------------------------------------------------------------- */
578 /* pixVariance() - computes pixel-to-pixel change */
579 /* */
580 
581 /* -------------------------------------------------------------- */
582 INT32 pixVariance(BYTE mnf[]) {
583  INT16 scid[2];
584  INT16 mnftype;
585  INT16 npix;
586  INT16 offset;
587  INT16 i, j;
588  INT16 *data;
589  INT32 var = 0;
590  INT16 x, lastx = 0, dx;
591 
592  memcpy(scid, &mnf[O_SCID], sizeof (scid));
593  if (endianess() == 1)
594  swapc_bytes((char *) scid, 2, 2);
595  mnftype = scid2mnftype(scid);
596 
597  if (mnftype == GACTYPE) {
598  return (var);
599  } else if (mnftype == LACTYPE) {
600  npix = 1285;
601  offset = 926;
602  data = (INT16 *) & mnf[offset];
603  } else {
604  return (var);
605  }
606 
607  for (j = 0; j < NBANDS; j++) {
608  for (i = 0; i < npix; i++) {
609  x = data[i * NBANDS + j];
610  if (endianess() == 1)
611  swapc_bytes((char *) &x, 2, 1);
612  if (i > 0) {
613  dx = x - lastx;
614  var = var + (INT32) abs(dx);
615  }
616  lastx = x;
617  }
618  }
619 
620  return (var);
621 }
622 
623 
624 
625 
626 
627 
628 
629 
630 
timeError
BYTE timeError(swl0indx *indx, INT32 irec)
Definition: swl0_utils.c:109
MAX
#define MAX(A, B)
Definition: swl0_utils.h:26
MIN
#define MIN(x, y)
Definition: rice.h:169
DTLAC
#define DTLAC
Definition: swl0_parms.h:47
FLOAT64
double FLOAT64
Definition: elements.h:8
j
int j
Definition: decode_rs.h:73
day
int32_t day
Definition: atrem_corl1v2.h:308
status
int status
Definition: l1_czcs_hdf.c:32
INT32
#define INT32
Definition: l1_imgscale.c:3
startBitError
BYTE startBitError(BYTE mnf[], INT32 *numbits, INT32 *numerrs)
Definition: swl0_utils.c:469
stopBitError
BYTE stopBitError(BYTE mnf[], INT32 *numbits, INT32 *numerrs)
Definition: swl0_utils.c:528
ttag2ydmsec
void ttag2ydmsec(INT16 ttag[], INT16 *year, INT16 *day, INT32 *msec)
Definition: swl0_utils.c:71
INT32
int32_t INT32
Definition: elements.h:6
DELSCENEGAC
#define DELSCENEGAC
Definition: swl0_parms.h:51
msec
int32 * msec
Definition: l1_czcs_hdf.c:31
tm
float tm[MODELMAX]
Definition: atrem_corl1v2.h:248
LACTYPE
#define LACTYPE
Definition: swl0_parms.h:20
scid2mnftype
INT16 scid2mnftype(INT16 scid[])
Definition: swl0_utils.c:20
timeContiguous
BYTE timeContiguous(swl0indx *indx, INT32 irec)
Definition: swl0_utils.c:178
jday
int32_t jday(int16_t i, int16_t j, int16_t k)
Definition: jday.c:4
GAC
#define GAC
Definition: l1stat.h:33
timeSeqError
BYTE timeSeqError(swl0indx *indx, INT32 irec)
Definition: swl0_utils.c:121
spacetrack_tles.year
year
Definition: spacetrack_tles.py:170
endianess
int endianess(void)
determine endianess
Definition: endianess.c:10
swapc_bytes
int swapc_bytes(char *in, int nbyte, int ntime)
Definition: swapc_bytes.c:4
DELSCENELAC
#define DELSCENELAC
Definition: swl0_parms.h:50
pixVariance
INT32 pixVariance(BYTE mnf[])
Definition: swl0_utils.c:582
BYTE
unsigned char BYTE
Definition: elements.h:4
INT16
short int INT16
Definition: elements.h:5
ABS
#define ABS(A)
Definition: swl0_utils.h:33
DTGAC
#define DTGAC
Definition: swl0_parms.h:46
hico.value_locate.x
list x
Definition: value_locate.py:64
HRPT
#define HRPT
Definition: l1stat.h:35
swl0_proto.h
scid2mnfnum
INT16 scid2mnfnum(INT16 scid[])
Definition: swl0_utils.c:29
sohHdrError
BYTE sohHdrError(BYTE hdr[])
Definition: swl0_utils.c:416
mask
a context in which it is NOT documented to do so subscript which cannot be easily calculated when extracting TONS attitude data from the Terra L0 files Corrected several defects in extraction of entrained ephemeris and and as HDF file for both the L1A and Geolocation enabling retrieval of South Polar DEM data Resolved Bug by changing to opent the geolocation file only after a successful read of the L1A and also by checking for fatal errors from not restoring C5 and to report how many of those high resolution values were water in the new WaterPresent SDS Added valid_range attribute to Land SeaMask Changed to bilinearly interpolate the geoid_height to remove artifacts at one degree lines Made corrections to const qualification of pointers allowed by new version of M API library Removed casts that are no longer for same not the geoid Corrected off by one error in calculation of high resolution offsets Corrected parsing of maneuver list configuration parameter Corrected to set Height SDS to fill values when geolocation when for elevation and land water mask
Definition: HISTORY.txt:114
filename
char filename[FILENAME_MAX]
Definition: atrem_corl1.h:122
generalauxtype::double
integer, parameter double
Definition: GeneralAuxType.f90:27
data
no change in intended resolving MODur00064 Corrected handling of bad ephemeris attitude data
Definition: HISTORY.txt:356
GACTYPE
#define GACTYPE
Definition: swl0_parms.h:19
timeShifted
BYTE timeShifted(swl0indx *indx, INT32 irec, FLOAT64 *shiftval)
Definition: swl0_utils.c:334
timeConsistent
BYTE timeConsistent(swl0indx *indx, INT32 irec)
Definition: swl0_utils.c:255
fabs
#define fabs(a)
Definition: misc.h:93
bitError
BYTE bitError(BYTE mnf[], INT32 *totbits, INT32 *toterrs)
Definition: swl0_utils.c:441
TIMELEN
#define TIMELEN
Definition: swl0_utils.c:14
offset
l2prod offset
Definition: HOWTO_Add_a_product.txt:70
O_SCID
#define O_SCID
Definition: swl0_parms.h:32
filesize
INT32 filesize(const char *filename)
Definition: swl0_utils.c:93
abs
#define abs(a)
Definition: misc.h:90
i
int i
Definition: decode_rs.h:71
CLOCKVAR
#define CLOCKVAR
Definition: swl0_parms.h:48
NBANDS
@ NBANDS
Definition: make_L3_v1.1.c:53
npix
int npix
Definition: get_cmp.c:27
unix2timeStr
char * unix2timeStr(FLOAT64 usec)
Definition: swl0_utils.c:55
ttag2unix
FLOAT64 ttag2unix(INT16 ttag[])
Definition: swl0_utils.c:38


ABOUT

Our Team

Contact Us

DATA

Get Started

Find Data

Use Data

TOOLS

SeaBASS

SeaDAS

Giovanni Data Visualizer

Worldview Mapping Interface

Level 3 Time Series Plotter

Request a SeaHawk Image

Mission Quality Monitor

HELP

Level 1 & 2 Browser Help

Level 3 & 4 Browser Help

File Search Help

Search & Download Help

Earthdata Forum

Join Mailing List

How to Cite Data

CONNECT WITH US
COMPLIANCE

Web Privacy Policy

Data & Information Policy

Communications Policy

Accessibility Policy

Freedom of Information Act

USA.gov

Responsible NASA Official: Sean Bailey
Curator: OceanColor Webmaster