Return to homing.c CVS log

Up to [Research Unix] / researchv10no / cmd / map / libmap

Annotation of researchv10no/cmd/map/libmap/homing.c, revision 1.1.1.1

1.1       root        1: #include "map.h"
                      2: 
                      3: static struct coord p0;                /* standard parallel */
                      4: 
                      5: int first;
                      6: 
                      7: static double
                      8: trigclamp(double x)
                      9: {
                     10:        return x>1? 1: x<-1? -1: x;
                     11: }
                     12: 
                     13: static struct coord az;                /* azimuth of p0 seen from place */
                     14: static struct coord rad;       /* angular dist from place to p0 */
                     15: 
                     16: static int
                     17: azimuth(struct place *place)
                     18: {
                     19:        if(place->nlat.c < FUZZ) {
                     20:                az.l = PI/2 + place->nlat.l - place->wlon.l;
                     21:                sincos(&az);
                     22:                rad.l = fabs(place->nlat.l - p0.l);
                     23:                if(rad.l > PI)
                     24:                        rad.l = 2*PI - rad.l;
                     25:                sincos(&rad);
                     26:                return 1;
                     27:        }
                     28:        rad.c = trigclamp(p0.s*place->nlat.s +  /* law of cosines */
                     29:                p0.c*place->nlat.c*place->wlon.c);
                     30:        rad.s = sqrt(1 - rad.c*rad.c);
                     31:        if(fabs(rad.s) < .001) {
                     32:                az.s = 0;
                     33:                az.c = 1;
                     34:        } else {
                     35:                az.s = trigclamp(p0.c*place->wlon.s/rad.s); /* sines */
                     36:                az.c = trigclamp((p0.s - rad.c*place->nlat.s)
                     37:                                /(rad.s*place->nlat.c));
                     38:        }
                     39:        rad.l = atan2(rad.s, rad.c);
                     40:        return 1;
                     41: }
                     42: 
                     43: static int
                     44: Xmecca(struct place *place, double *x, double *y)
                     45: {
                     46:        if(!azimuth(place))
                     47:                return 0;
                     48:        *x = -place->wlon.l;
                     49:        *y = fabs(az.s)<.02? -az.c*rad.s/p0.c: *x*az.c/az.s;
                     50:        return fabs(*y)>2? -1:
                     51:               rad.c<0? 0:
                     52:               1;
                     53: }
                     54: 
                     55: proj
                     56: mecca(double par)
                     57: {
                     58:        first = 1;
                     59:        if(fabs(par)>80.)
                     60:                return(0);
                     61:        deg2rad(par,&p0);
                     62:        return(Xmecca);
                     63: }
                     64: 
                     65: static int
                     66: Xhoming(struct place *place, double *x, double *y)
                     67: {
                     68:        if(!azimuth(place))
                     69:                return 0;
                     70:        *x = -rad.l*az.s;
                     71:        *y = -rad.l*az.c;
                     72:        return place->wlon.c<0? 0: 1;
                     73: }
                     74: 
                     75: proj
                     76: homing(double par)
                     77: {
                     78:        first = 1;
                     79:        if(fabs(par)>80.)
                     80:                return(0);
                     81:        deg2rad(par,&p0);
                     82:        return(Xhoming);
                     83: }
                     84: 
                     85: int
                     86: hlimb(double *lat, double *lon, double res)
                     87: {
                     88:        if(first) {
                     89:                *lon = -90;
                     90:                *lat = -90;
                     91:                first = 0;
                     92:                return 0;
                     93:        }
                     94:        *lat += res;
                     95:        if(*lat <= 90) 
                     96:                return 1;
                     97:        if(*lon == 90)
                     98:                return -1;
                     99:        *lon = 90;
                    100:        *lat = -90;
                    101:        return 0;
                    102: }
                    103: 
                    104: int
                    105: mlimb(double *lat, double *lon, double res)
                    106: {
                    107:        int ret = !first;
                    108:        if(fabs(p0.s) < .01)
                    109:                return -1;
                    110:        if(first) {
                    111:                *lon = -180;
                    112:                first = 0;
                    113:        } else
                    114:                *lon += res;
                    115:        if(*lon > 180)
                    116:                return -1;
                    117:        *lat = atan(-cos(*lon*RAD)/p0.s*p0.c)/RAD;
                    118:        return ret;
                    119: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.