Return to zcoord.c CVS log

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

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

1.1       root        1: #include "map.h"
                      2: 
                      3: static double cirmod(double);
                      4: 
                      5: static struct place pole;      /* map pole is tilted to here */
                      6: static struct coord twist;     /* then twisted this much */
                      7: static struct place ipole;     /* inverse transfrom */
                      8: static struct coord itwist;
                      9: 
                     10: void
                     11: orient(double lat, double lon, double theta)
                     12: {
                     13:        lat = cirmod(lat);
                     14:        if(lat>90.) {
                     15:                lat = 180. - lat;
                     16:                lon -= 180.;
                     17:                theta -= 180.;
                     18:        } else if(lat < -90.) {
                     19:                lat = -180. - lat;
                     20:                lon -= 180.;
                     21:                theta -= 180.;
                     22:        }
                     23:        latlon(lat,lon,&pole);
                     24:        deg2rad(theta, &twist);
                     25:        latlon(lat,180.-theta,&ipole);
                     26:        deg2rad(180.-lon, &itwist);
                     27: }
                     28: 
                     29: void
                     30: latlon(double lat, double lon, struct place *p)
                     31: {
                     32:        lat = cirmod(lat);
                     33:        if(lat>90.) {
                     34:                lat = 180. - lat;
                     35:                lon -= 180.;
                     36:        } else if(lat < -90.) {
                     37:                lat = -180. - lat;
                     38:                lon -= 180.;
                     39:        }
                     40:        deg2rad(lat,&p->nlat);
                     41:        deg2rad(lon,&p->wlon);
                     42: }
                     43: 
                     44: void
                     45: deg2rad(double theta, struct coord *coord)
                     46: {
                     47:        theta = cirmod(theta);
                     48:        coord->l = theta*RAD;
                     49:        if(theta==90) {
                     50:                coord->s = 1;
                     51:                coord->c = 0;
                     52:        } else if(theta== -90) {
                     53:                coord->s = -1;
                     54:                coord->c = 0;
                     55:        } else
                     56:                sincos(coord);
                     57: }
                     58: 
                     59: static double
                     60: cirmod(double theta)
                     61: {
                     62:        while(theta >= 180.)
                     63:                theta -= 360;
                     64:        while(theta<-180.)
                     65:                theta += 360.;
                     66:        return(theta);
                     67: }
                     68: 
                     69: void
                     70: sincos(struct coord *coord)
                     71: {
                     72:        coord->s = sin(coord->l);
                     73:        coord->c = cos(coord->l);
                     74: }
                     75: 
                     76: void
                     77: normalize(struct place *gg)
                     78: {
                     79:        norm(gg,&pole,&twist);
                     80: }
                     81: 
                     82: void
                     83: invert(struct place *g)
                     84: {
                     85:        norm(g,&ipole,&itwist);
                     86: }
                     87: 
                     88: void
                     89: norm(struct place *gg, struct place *pp, struct coord *tw)
                     90: {
                     91:        register struct place *g;       /*geographic coords */
                     92:        register struct place *p;       /* new pole in old coords*/
                     93:        struct place m;                 /* standard map coords*/
                     94:        g = gg;
                     95:        p = pp;
                     96:        if(p->nlat.s == 1.) {
                     97:                if(p->wlon.l+tw->l == 0.)
                     98:                        return;
                     99:                g->wlon.l -= p->wlon.l+tw->l;
                    100:        } else {
                    101:                if(p->wlon.l != 0) {
                    102:                        g->wlon.l -= p->wlon.l;
                    103:                        sincos(&g->wlon);
                    104:                }
                    105:                m.nlat.s = p->nlat.s * g->nlat.s
                    106:                        + p->nlat.c * g->nlat.c * g->wlon.c;
                    107:                m.nlat.c = sqrt(1. - m.nlat.s * m.nlat.s);
                    108:                m.nlat.l = atan2(m.nlat.s, m.nlat.c);
                    109:                m.wlon.s = g->nlat.c * g->wlon.s;
                    110:                m.wlon.c = p->nlat.c * g->nlat.s
                    111:                        - p->nlat.s * g->nlat.c * g->wlon.c;
                    112:                m.wlon.l = atan2(m.wlon.s, - m.wlon.c)
                    113:                        - tw->l;
                    114:                *g = m;
                    115:        }
                    116:        sincos(&g->wlon);
                    117:        if(g->wlon.l>PI)
                    118:                g->wlon.l -= 2*PI;
                    119:        else if(g->wlon.l<-PI)
                    120:                g->wlon.l += 2*PI;
                    121: }
                    122: 
                    123: void
                    124: printp(struct place *g)
                    125: {
                    126: printf("%.3f %.3f %.3f %.3f %.3f %.3f\n",
                    127: g->nlat.l,g->nlat.s,g->nlat.c,g->wlon.l,g->wlon.s,g->wlon.c);
                    128: }
                    129: 
                    130: void
                    131: copyplace(struct place *g1, struct place *g2)
                    132: {
                    133:        *g2 = *g1;
                    134: }

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