Return to perspective.c CVS log

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

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

1.1       root        1: #include "map.h"
                      2: 
                      3: #define ORTHRAD 1000
                      4: static double viewpt;
                      5: 
                      6: static int
                      7: Xperspective(struct place *place, double *x, double *y)
                      8: {
                      9:        double r;
                     10:        if(viewpt<=1+FUZZ && fabs(place->nlat.s<=viewpt+.01))
                     11:                return(-1);
                     12:        r = place->nlat.c*(viewpt - 1.)/(viewpt - place->nlat.s);
                     13:        *x = - r*place->wlon.s;
                     14:        *y = - r*place->wlon.c;
                     15:        if(r>4.)
                     16:                return(-1);
                     17:        if(fabs(viewpt)>1 && place->nlat.s<1/viewpt ||
                     18:           fabs(viewpt)<=1 && place->nlat.s<viewpt)
                     19:                        return 0;
                     20:        return(1);
                     21: }
                     22: 
                     23: proj
                     24: perspective(double radius)
                     25: {
                     26:        viewpt = radius;
                     27:        if(viewpt >= ORTHRAD)
                     28:                return(Xorthographic);
                     29:        if(fabs(viewpt-1.)<.0001)
                     30:                return(0);
                     31:        return(Xperspective);
                     32: }
                     33: 
                     34:        /* called from various conformal projections,
                     35:            but not from stereographic itself */
                     36: int
                     37: Xstereographic(struct place *place, double *x, double *y)
                     38: {
                     39:        double v = viewpt;
                     40:        int retval;
                     41:        viewpt = -1;
                     42:        retval = Xperspective(place, x, y);
                     43:        viewpt = v;
                     44:        return retval;
                     45: }
                     46: 
                     47: proj
                     48: stereographic(void)
                     49: {
                     50:        viewpt = -1.;
                     51:        return(Xperspective);
                     52: }
                     53: 
                     54: proj
                     55: gnomonic(void)
                     56: {
                     57:        viewpt = 0.;
                     58:        return(Xperspective);
                     59: }
                     60: 
                     61: int
                     62: plimb(double *lat, double *lon, double res)
                     63: {
                     64:        static first = 1;
                     65:        if(viewpt >= ORTHRAD)
                     66:                return olimb(lat, lon, res);
                     67:        if(first) {
                     68:                first = 0;
                     69:                *lon = -180;
                     70:                if(fabs(viewpt) < .01)
                     71:                        *lat = 0;
                     72:                else if(fabs(viewpt)<=1)
                     73:                        *lat = asin(viewpt)/RAD;
                     74:                else
                     75:                        *lat = asin(1/viewpt)/RAD;
                     76:        } else
                     77:                *lon += res;
                     78:        if(*lon <= 180)
                     79:                return 1;
                     80:        first = 1;
                     81:        return -1;
                     82: }

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