Return to zcoord.c CVS log

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

Annotation of researchv8dc/cmd/map/libmap/zcoord.c, revision 1.1

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

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