OB.DAAC Logo
NASA Logo
Ocean Color Science Software

ocssw V2022
som.c
Go to the documentation of this file.
1 /*******************************************************************************
2 Name: SPACE OBLIQUE MERCATOR (SOM)
3 
4 Purpose: Provides the transformations between Easting/Northing and longitude/
5  latitude for the SOM projection. The Easting and Northing are in meters.
6  The longitude and latitude values are in radians.
7 
8 Notes:
9 1. The X axis is in the direction of satellite motion. For most other
10  projections, that is roughly the negative Y axis. Therefore, the false
11  northing is applied to the X coordinate and the false easting is applied to
12  the Y coordinate.
13 
14 
15 Algorithm References:
16 
17 1. Snyder, John P., "Map Projections--A Working Manual", U.S. Geological
18  Survey Professional Paper 1395 (Supersedes USGS Bulletin 1532), United
19  State Government Printing Office, Washington D.C., 1987.
20 
21 2. "Software Documentation for GCTP General Cartographic Transformation
22  Package", U.S. Geological Survey National Mapping Division, May 1982.
23 *******************************************************************************/
24 #include <stdlib.h>
25 #include <math.h>
26 #include "oli_cproj.h"
27 #include "gctp.h"
28 #include "oli_local.h"
29 
30 #define LANDSAT_RATIO 0.5201613
31 
32 /* structure to hold the setup data relevant to this projection */
33 struct som_proj
34 {
35  double lon_center;
36  double a;
37  double b;
38  double a2;
39  double a4;
40  double c1;
41  double c3;
42  double q;
43  double t;
44  double u;
45  double w;
46  double xj;
47  double p21;
48  double sa;
49  double ca;
50  double es;
51  double false_easting;
53  int is_somb;
54  int path;
55  int satnum;
56  double inclination_angle; /* inclination angle in radians */
57  int start;
58 };
59 
60 /*****************************************************************************
61 Name: som_series
62 
63 Purpose: Series to calculate a,b,c coefficients to convert from transform
64  latitude,longitude to Space Oblique Mercator (SOM) rectangular coordinates
65  Mathematical analysis by John Snyder 6/82
66 
67 Returns:
68  nothing
69 
70 *****************************************************************************/
71 static void som_series
72 (
73  struct som_proj *proj, /* I/O: projection information */
74  double *fb, /* O */
75  double *fa2, /* O */
76  double *fa4, /* O */
77  double *fc1, /* O */
78  double *fc3, /* O */
79  double dlam /* I */
80 )
81 {
82  double sd,sdsq,h,sq,fc;
83  double s;
84  double q_term;
85  double w_term;
86 
87  dlam = dlam * 0.0174532925; /* Convert dlam to radians */
88  sd = sin(dlam);
89  sdsq = sd * sd;
90  q_term = 1.0 + proj->q * sdsq;
91  w_term = 1.0 + proj->w * sdsq;
92  s = proj->p21 * proj->sa * cos(dlam) * sqrt((1.0 + proj->t * sdsq)
93  / (w_term * q_term));
94  h = sqrt(q_term / w_term) * ((w_term / (q_term * q_term))
95  - proj->p21 * proj->ca);
96  sq = sqrt(proj->xj * proj->xj + s * s);
97  *fb = (h * proj->xj - s * s) / sq;
98  *fa2 = *fb * cos(2.0 * dlam);
99  *fa4 = *fb * cos(4.0 * dlam);
100  fc = s * (h + proj->xj) / sq;
101  *fc1 = fc * cos(dlam);
102  *fc3 = fc * cos(3.0 * dlam);
103 }
104 
105 /*****************************************************************************
106 Name: print_info
107 
108 Purpose: Prints a summary of information about this projection.
109 
110 Returns:
111  nothing
112 
113 *****************************************************************************/
114 static void print_info
115 (
116  const TRANSFORMATION *trans
117 )
118 {
119  struct som_proj *cache_ptr = (struct som_proj *)trans->cache;
120 
121  gctp_print_title("SPACE OBLIQUE MERCATOR");
122  gctp_print_radius2(cache_ptr->a, cache_ptr->b);
123  if (cache_ptr->is_somb)
124  {
125  gctp_print_genrpt_long(cache_ptr->path, "Path Number: ");
126  gctp_print_genrpt_long(cache_ptr->satnum, "Satellite Number: ");
127  }
129  "Inclination of Orbit: ");
130  gctp_print_genrpt(cache_ptr->lon_center * R2D,
131  "Longitude of Ascending Orbit: ");
132  gctp_print_offsetp(cache_ptr->false_easting, cache_ptr->false_northing);
133 }
134 
135 /*******************************************************************************
136 Name: common_init
137 
138 Purpose: Initialization routine for initializing the projection information
139  that is common to both the forward and inverse transformations.
140 
141 Returns:
142  GCTP_SUCCESS or GCTP_ERROR
143 
144 *******************************************************************************/
145 static int common_init
146 (
147  TRANSFORMATION *trans /* I/O: transformation to initialize */
148 )
149 {
150 
151  double r_major; /* major axis */
152  double r_minor; /* minor axis */
153  double radius; /* radius */
154  int satnum; /* Landsat satellite number (1,2,3,4,5) */
155  int path; /* Landsat path number */
156  double lon_center;
157  double false_easting; /* x offset in meters */
158  double false_northing; /* y offset in meters */
159  double time;
160  int start1;
161  int is_somb;
162  const GCTP_PROJECTION *proj = &trans->proj;
163  struct som_proj *cache = NULL;
164  int spheroid = proj->spheroid;
165  int i;
166  double inclination_angle;
167  double e2c,e2s,one_es;
168  double dlam,fb,fa2,fa4,fc1,fc3,suma2,suma4,sumc1,sumc3,sumb;
169  double p21;
170 
171  /* Get the projection parameters */
172  gctp_get_spheroid(spheroid, proj->parameters, &r_major, &r_minor, &radius);
173  false_easting = proj->parameters[6];
174  false_northing = proj->parameters[7];
175  start1 = (int)proj->parameters[10];
176  is_somb = (int)proj->parameters[12];
177 
178  if (!is_somb)
179  {
180  satnum = 0;
181  path = 0;
182 
183  if (gctp_dms2degrees(proj->parameters[3], &inclination_angle)
184  != GCTP_SUCCESS)
185  {
186  GCTP_PRINT_ERROR("Error converting inclination angle parameter "
187  "from DMS to degrees: %f", proj->parameters[3]);
188  return GCTP_ERROR;
189  }
190  inclination_angle *= 3600 * S2R;
191 
192  if (gctp_dms2degrees(proj->parameters[4], &lon_center)
193  != GCTP_SUCCESS)
194  {
195  GCTP_PRINT_ERROR("Error converting longitude of ascending orbit "
196  "at equator parameter from DMS to degrees: %f",
197  proj->parameters[4]);
198  return GCTP_ERROR;
199  }
200  lon_center *= 3600 * S2R;
201 
202  time = proj->parameters[8];
203 
204  p21 = time / 1440.0;
205  }
206  else
207  {
208  satnum = (int)proj->parameters[2];
209  path = (int)proj->parameters[3];
210 
211  if (satnum < 4)
212  {
213  inclination_angle = 99.092 * D2R;
214  p21 = 103.2669323 / 1440.0;
215  lon_center = (128.87 - (360.0 / 251.0 * path)) * D2R;
216  }
217  else
218  {
219  inclination_angle = 98.2 * D2R;
220  p21 = 98.8841202 / 1440.0;
221  lon_center = (129.30 - (360.0 / 233.0 * path)) * D2R;
222  }
223  }
224 
225 
226  /* Allocate a structure for the cached info */
227  cache = malloc(sizeof(*cache));
228  if (!cache)
229  {
230  GCTP_PRINT_ERROR("Error allocating memory for cache buffer");
231  return GCTP_ERROR;
232  }
233  trans->cache = cache;
234 
235  /* Save the information to the cache */
236  cache->lon_center = lon_center;
237  cache->false_easting = false_easting;
238  cache->false_northing = false_northing;
239  cache->is_somb = is_somb;
240  cache->path = path;
241  cache->satnum = satnum;
242  cache->inclination_angle = inclination_angle;
243  cache->start = start1;
244  cache->p21 = p21;
245 
246  /* Place parameters in static storage for common use */
247  cache->a = r_major;
248  cache->b = r_minor;
249  cache->es = 1.0 - SQUARE(r_minor / r_major);
250 
251  cache->ca = cos(inclination_angle);
252  if (fabs(cache->ca) < 1.e-9)
253  cache->ca = 1.e-9;
254  cache->sa = sin(inclination_angle);
255  e2c = cache->es * cache->ca * cache->ca;
256  e2s = cache->es * cache->sa * cache->sa;
257  cache->w = (1.0 - e2c) / (1.0 - cache->es);
258  cache->w = cache->w * cache->w-1.0;
259  one_es = 1.0 - cache->es;
260  cache->q = e2s / one_es;
261  cache->t = (e2s * (2.0 - cache->es)) / (one_es * one_es);
262  cache->u = e2c / one_es;
263  cache->xj = one_es * one_es * one_es;
264  dlam = 0.0;
265  som_series(cache, &fb,&fa2,&fa4,&fc1,&fc3, dlam);
266  suma2 = fa2;
267  suma4 = fa4;
268  sumb = fb;
269  sumc1 = fc1;
270  sumc3 = fc3;
271  for (i = 9; i <= 81; i += 18)
272  {
273  dlam = i;
274  som_series(cache, &fb,&fa2,&fa4,&fc1,&fc3, dlam);
275  suma2 = suma2 + 4.0 * fa2;
276  suma4 = suma4 + 4.0 * fa4;
277  sumb = sumb + 4.0 * fb;
278  sumc1 = sumc1 + 4.0 * fc1;
279  sumc3 = sumc3 + 4.0 * fc3;
280  }
281  for (i = 18; i <= 72; i += 18)
282  {
283  dlam = i;
284  som_series(cache, &fb,&fa2,&fa4,&fc1,&fc3, dlam);
285  suma2 = suma2 + 2.0 * fa2;
286  suma4 = suma4 + 2.0 * fa4;
287  sumb = sumb + 2.0 * fb;
288  sumc1 = sumc1 + 2.0 * fc1;
289  sumc3 = sumc3 + 2.0 * fc3;
290  }
291 
292  dlam = 90.0;
293  som_series(cache, &fb,&fa2,&fa4,&fc1,&fc3, dlam);
294  suma2 = suma2 + fa2;
295  suma4 = suma4 + fa4;
296  sumb = sumb + fb;
297  sumc1 = sumc1 + fc1;
298  sumc3 = sumc3 + fc3;
299  cache->a2 = suma2 / 30.0;
300  cache->a4 = suma4 / 60.0;
301  cache->b = sumb / 30.0;
302  cache->c1 = sumc1 / 15.0;
303  cache->c3 = sumc3 / 45.0;
304 
305  trans->print_info = print_info;
306 
307  return GCTP_SUCCESS;
308 }
309 
310 /*****************************************************************************
311 Name: inverse_transform
312 
313 Purpose: Transforms SOM X,Y to lat,long
314 
315 Returns:
316  GCTP_SUCCESS or GCTP_ERROR
317 
318 *****************************************************************************/
319 static int inverse_transform
320 (
321  const TRANSFORMATION *trans, /* I: transformation information */
322  double x, /* I: X projection coordinate */
323  double y, /* I: Y projection coordinate */
324  double *lon, /* O: Longitude */
325  double *lat /* O: Latitude */
326 )
327 {
328  struct som_proj *cache = (struct som_proj *)trans->cache;
329  double tlon,conv,sav,sd,sdsq,blon,dif;
330  double st,defac,actan,tlat,dd,bigk,bigk2,xlamt;
331  double sl = 0.0;
332  double scl = 0.0;
333  double dlat = 0.0;
334  double dlon;
335  double s;
336  int inumb;
337 
338  /* Apply false easting/northing. Note that the axes of the SOM projection
339  are defined differently than most projections. The X axis is in the
340  direction of satellite motion which is the inverse of the normal Y
341  axis. So, the false northing is applied to the X axis. */
342  y -= cache->false_easting;
343  x -= cache->false_northing;
344 
345  /* Inverse equations. Begin inverse computation with approximation for
346  tlon. Solve for transformed long. */
347  tlon = x / (cache->a * cache->b);
348  conv = 1.e-9;
349  for (inumb = 0; inumb < 50; inumb++)
350  {
351  sav = tlon;
352  sd = sin(tlon);
353  sdsq = sd * sd;
354  s = cache->p21 * cache->sa * cos(tlon) * sqrt((1.0 + cache->t * sdsq)
355  / ((1.0 + cache->w * sdsq) * (1.0 + cache->q * sdsq)));
356  blon = (x / cache->a) + (y / cache->a) * s / cache->xj-cache->a2
357  * sin(2.0 * tlon) - cache->a4 * sin(4.0 * tlon) - (s / cache->xj)
358  * (cache->c1 * sin(tlon) + cache->c3 * sin(3.0 * tlon));
359  tlon = blon / cache->b;
360  dif = tlon - sav;
361  if (fabs(dif) < conv)
362  break;
363  }
364  if (inumb >= 50)
365  {
366  GCTP_PRINT_ERROR("Max iterations reached without converging");
367  return GCTP_ERROR;
368  }
369 
370  /* Compute transformed lat */
371  st = sin(tlon);
372  defac = exp(sqrt(1.0 + s * s / cache->xj / cache->xj) * (y
373  / cache->a - cache->c1 * st - cache->c3 * sin(3.0 * tlon)));
374  actan = atan(defac);
375  tlat = 2.0 * (actan - (PI / 4.0));
376 
377  /* Compute geodetic longitude */
378  dd = st * st;
379  if (fabs(cos(tlon)) < 1.e-7)
380  tlon = tlon - 1.e-7;
381  bigk = sin(tlat);
382  bigk2 = bigk * bigk;
383  xlamt = atan(((1.0 - bigk2 / (1.0 - cache->es)) * tan(tlon)
384  * cache->ca - bigk * cache->sa * sqrt((1.0 + cache->q * dd)
385  * (1.0 - bigk2) - bigk2 * cache->u) / cos(tlon)) / (1.0 - bigk2
386  * (1.0 + cache->u)));
387 
388  /* Correct inverse quadrant */
389  if (xlamt >= 0.0)
390  sl = 1.0;
391  if (xlamt < 0.0)
392  sl = -1.0;
393  if (cos(tlon) >= 0.0)
394  scl = 1.0;
395  if (cos(tlon) < 0.0)
396  scl = -1.0;
397  xlamt = xlamt - ((PI / 2.0) * (1.0 - scl) * sl);
398  dlon = xlamt - cache->p21 * tlon;
399 
400  /* Compute geodetic latitude */
401  if (fabs(cache->sa) < 1.e-7)
402  {
403  dlat = asin(bigk / sqrt((1.0 - cache->es) * (1.0 - cache->es)
404  + cache->es * bigk2));
405  }
406  if (fabs(cache->sa) >= 1.e-7)
407  {
408  dlat = atan((tan(tlon) * cos(xlamt) - cache->ca * sin(xlamt))
409  / ((1.0 - cache->es) * cache->sa));
410  }
411  *lon = adjust_lon(dlon + cache->lon_center);
412  *lat = dlat;
413 
414  return GCTP_SUCCESS;
415 }
416 
417 /*****************************************************************************
418 Name: forward_transform
419 
420 Purpose: Transforms lat,long to SOM X,Y
421 
422 Returns:
423  GCTP_SUCCESS or GCTP_ERROR
424 
425 *****************************************************************************/
426 static int forward_transform
427 (
428  const TRANSFORMATION *trans, /* I: transformation information */
429  double lon, /* I: Longitude */
430  double lat, /* I: Latitude */
431  double *x, /* O: X projection coordinate */
432  double *y /* O: Y projection coordinate */
433 )
434 {
435  struct som_proj *cache = (struct som_proj *)trans->cache;
436  int n,l;
437  double delta_lon;
438  double rlm,tabs,tlam,xlam,c,xlamt,ab2,ab1,xlamp,sav;
439  double d,sdsq,sd,tanlg,xtan,tphi,dp,rlm2;
440  double scl = 0.0;
441  double tlamp = 0.0;
442  double conv,delta_lat,radlt,radln;
443  double s;
444  int done = 0;
445 
446  /* Forward equations */
447  conv = 1.e-7;
448  delta_lat = lat;
449  delta_lon = lon-cache->lon_center;
450 
451  /* Test for latitude and longitude approaching 90 degrees */
452  if (delta_lat>1.570796)
453  delta_lat = 1.570796;
454  if (delta_lat < -1.570796)
455  delta_lat = -1.570796;
456  radlt = delta_lat;
457  radln = delta_lon;
458  if (delta_lat >= 0.0)
459  tlamp = PI / 2.0;
460  if (cache->start == 1)
461  tlamp = 2.5 * PI; /* Force to END */
462  else if (cache->start == 0)
463  tlamp = HALF_PI; /* Force to START */
464  if (delta_lat < 0.0)
465  tlamp = 1.5 * PI;
466  n = 0;
467 
468  while (1)
469  {
470  sav = tlamp;
471  l = 0;
472  xlamp = radln + cache->p21 * tlamp;
473  ab1 = cos(xlamp);
474  if (fabs(ab1) < conv)
475  xlamp = xlamp - 1.e-7;
476  if (ab1 >= 0.0)
477  scl = 1.0;
478  if (ab1 < 0.0)
479  scl = -1.0;
480  ab2 = tlamp - (scl) * sin(tlamp) * HALF_PI;
481 
482  while (l <= 50)
483  {
484  xlamt = radln + cache->p21 * sav;
485  c = cos(xlamt);
486  if (fabs(c) < 1.e-7)
487  xlamt = xlamt - 1.e-7;
488  xlam = (((1.0 - cache->es) * tan(radlt) * cache->sa) + sin(xlamt)
489  * cache->ca) / c;
490  tlam = atan(xlam);
491  tlam = tlam + ab2;
492  tabs = fabs(sav) - fabs(tlam);
493  if (fabs(tabs) < conv)
494  {
495  /* Adjust for confusion at beginning and end of landsat
496  orbits */
497  rlm = PI * LANDSAT_RATIO;
498  rlm2 = rlm + 2.0 * PI;
499  n++;
500  if ((n >= 3) || (tlam > rlm && tlam < rlm2))
501  {
502  done = 1;
503  break;
504  }
505  if (tlam < rlm)
506  {
507  tlamp = 2.50 * PI;
508  if (cache->start == 0)
509  tlamp = HALF_PI;
510  }
511  if (tlam >= rlm2)
512  {
513  tlamp = HALF_PI;
514  if (cache->start == 1)
515  tlamp = 2.50 * PI;
516  }
517 
518  break;
519  }
520 
521  l = l + 1;
522 
523  sav = tlam;
524  }
525  if (done)
526  break;
527 
528  if (l > 50)
529  {
530  GCTP_PRINT_ERROR("Max iterations reached without converging");
531  return GCTP_ERROR;
532  }
533  }
534 
535  /* tlam computed - now compute tphi */
536  dp = sin(radlt);
537  tphi = asin(((1.0 - cache->es) * cache->ca * dp - cache->sa * cos(radlt)
538  * sin(xlamt)) / sqrt(1.0 - cache->es * dp * dp));
539 
540  /* compute x and y */
541  xtan = (PI / 4.0) + (tphi / 2.0);
542  tanlg = log(tan(xtan));
543  sd = sin(tlam);
544  sdsq = sd * sd;
545  s = cache->p21 * cache->sa * cos(tlam) * sqrt((1.0 + cache->t * sdsq)
546  / ((1.0 + cache->w * sdsq) * (1.0 + cache->q * sdsq)));
547  d = sqrt(cache->xj * cache->xj + s * s);
548  *x = cache->b * tlam + cache->a2 * sin(2.0 * tlam) + cache->a4
549  * sin(4.0 * tlam) - tanlg * s / d;
550  *x = cache->a * *x;
551  *y = cache->c1 * sd + cache->c3 * sin(3.0 * tlam) + tanlg * cache->xj / d;
552  *y = cache->a * *y;
553 
554  /* Apply false easting/northing. Note that the axes of the SOM projection
555  are defined differently than most projections. The X axis is in the
556  direction of satellite motion which is the inverse of the normal Y
557  axis. So, the false northing is applied to the X axis. */
558  *x += cache->false_northing;
559  *y += cache->false_easting;
560  return GCTP_SUCCESS;
561 }
562 
563 /*****************************************************************************
564 Name: gctp_som_inverse_init
565 
566 Purpose: Initializes the inverse SOM transformation
567 
568 Returns:
569  GCTP_SUCCESS or GCTP_ERROR
570 
571 *****************************************************************************/
573 (
574  TRANSFORMATION *trans
575 )
576 {
577  /* Call the common routine used for the forward and inverse init */
578  if (common_init(trans) != GCTP_SUCCESS)
579  {
580  GCTP_PRINT_ERROR("Error initializing SOM inverse projection");
581  return GCTP_ERROR;
582  }
583 
584  trans->transform = inverse_transform;
585 
586  return GCTP_SUCCESS;
587 }
588 
589 /*****************************************************************************
590 Name: gctp_som_forward_init
591 
592 Purpose: Initializes the forward SOM transformation
593 
594 Returns:
595  GCTP_SUCCESS or GCTP_ERROR
596 
597 *****************************************************************************/
599 (
600  TRANSFORMATION *trans
601 )
602 {
603  /* Call the common routine used for the forward and inverse init */
604  if (common_init(trans) != GCTP_SUCCESS)
605  {
606  GCTP_PRINT_ERROR("Error initializing SOM forward projection");
607  return GCTP_ERROR;
608  }
609 
610  trans->transform = forward_transform;
611 
612  return GCTP_SUCCESS;
613 }
#define SQUARE(x)
Definition: proj_define.h:99
Definition: som.c:33
double es
Definition: som.c:50
void gctp_print_title(const char *proj_name)
Definition: gctp_report.c:14
double t
Definition: som.c:43
double p21
Definition: som.c:47
#define GCTP_ERROR
Definition: gctp.h:81
double a2
Definition: som.c:38
double inclination_angle
Definition: som.c:56
#define NULL
Definition: decode_rs.h:63
double u
Definition: som.c:44
int gctp_som_forward_init(TRANSFORMATION *trans)
Definition: som.c:599
#define LANDSAT_RATIO
Definition: som.c:30
double w
Definition: som.c:45
double c1
Definition: som.c:40
double b
Definition: som.c:37
double a4
Definition: som.c:39
#define GCTP_PRINT_ERROR(format,...)
Definition: oli_local.h:81
void gctp_print_genrpt_long(long A, const char *S)
Definition: gctp_report.c:126
float h[MODELMAX]
Definition: atrem_corl1.h:131
float * lat
double lon_center
Definition: som.c:35
int start
Definition: som.c:57
character(len=1000) if
Definition: names.f90:13
double adjust_lon(double x)
Definition: proj_cproj.c:349
int gctp_som_inverse_init(TRANSFORMATION *trans)
Definition: som.c:573
#define PI
Definition: l3_get_org.c:6
double a
Definition: som.c:36
double c3
Definition: som.c:41
def cache(filename, recache=False)
Definition: utils.py:145
int satnum
Definition: som.c:55
string path
Definition: color_dtdb.py:221
#define HALF_PI
Definition: proj_define.h:84
double q
Definition: som.c:42
#define D2R
Definition: proj_define.h:91
double false_easting
Definition: som.c:51
void gctp_print_offsetp(double A, double B)
Definition: gctp_report.c:91
float dp[MODELMAX]
#define GCTP_SUCCESS
Definition: gctp.h:82
int gctp_dms2degrees(double angle, double *degrees)
void gctp_print_genrpt(double A, const char *S)
Definition: gctp_report.c:117
#define gctp_get_spheroid
Definition: oli_local.h:7
double ca
Definition: som.c:49
double xj
Definition: som.c:46
int path
Definition: som.c:54
void gctp_print_radius2(double radius1, double radius2)
Definition: gctp_report.c:30
this program makes no use of any feature of the SDP Toolkit that could generate such a then geolocation is calculated at that and then aggregated up to Resolved feature request Bug by adding three new int8 SDSs for each high resolution offsets between the high resolution geolocation and a bi linear interpolation extrapolation of the positions This can be used to reconstruct the high resolution geolocation Resolved Bug by delaying cumulation of gflags until after validation of derived products Resolved Bug by setting Latitude and Longitude to the correct fill resolving to support Near Real Time because they may be unnecessary if use of entrained ephemeris and attitude data is turned resolving bug report Corrected to filter out Aqua attitude records with missing status helping resolve bug MOD_PR03 will still correctly write scan and pixel data that does not depend upon the start time
Definition: HISTORY.txt:248
#define fabs(a)
Definition: misc.h:93
#define S2R
Definition: proj_define.h:92
#define R2D
Definition: proj_define.h:87
int is_somb
Definition: som.c:53
double sa
Definition: som.c:48
float * lon
data_t s[NROOTS]
Definition: decode_rs.h:75
no change in intended resolving MODur00064 Corrected handling of bad ephemeris attitude resolving resolving GSFcd00179 Corrected handling of fill values for[Sensor|Solar][Zenith|Azimuth] resolving MODxl01751 Changed to validate LUT version against a value retrieved from the resolving MODxl02056 Changed to calculate Solar Diffuser angles without adjustment for estimated post launch changes in the MODIS orientation relative to incidentally resolving defects MODxl01766 Also resolves MODxl01947 Changed to ignore fill values in SCI_ABNORM and SCI_STATE rather than treating them as resolving MODxl01780 Changed to use spacecraft ancillary data to recognise when the mirror encoder data is being set by side A or side B and to change calculations accordingly This removes the need for seperate LUTs for Side A and Side B data it makes the new LUTs incompatible with older versions of the and vice versa Also resolves MODxl01685 A more robust GRing algorithm is being which will create a non default GRing anytime there s even a single geolocated pixel in a granule Removed obsolete messages from seed as required for compatibility with version of the SDP toolkit Corrected test output file names to end in per delivery and then split off a new MYD_PR03 pcf file for Aqua Added AssociatedPlatformInstrumentSensor to the inventory metadata in MOD01 mcf and MOD03 mcf Created new versions named MYD01 mcf and MYD03 where AssociatedPlatformShortName is rather than Terra The program itself has been changed to read the Satellite Instrument validate it against the input L1A and LUT and to use it determine the correct files to retrieve the ephemeris and attitude data from Changed to produce a LocalGranuleID starting with MYD03 if run on Aqua data Added the Scan Type file attribute to the Geolocation copied from the L1A and attitude_angels to radians rather than degrees The accumulation of Cumulated gflags was moved from GEO_validate_earth_location c to GEO_locate_one_scan c
Definition: HISTORY.txt:464
void radius(double A)
Definition: proj_report.c:132
double false_northing
Definition: som.c:52
int i
Definition: decode_rs.h:71