![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to map.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / map|
Return to map.c CVS log | Up to [Research Unix] / researchv10no / cmd / map |
1.1 root 1: #include "map.h"
2:
3: #define NVERT 20 /* max number of vertices in a -v polygon */
4: #define HALFWIDTH 8192 /* output scaled to fit in -HALFWIDTH,HALFWIDTH */
5: #define LONGLINES (HALFWIDTH*4) /* permissible segment lengths */
6: #define SHORTLINES (HALFWIDTH/8)
7: #define SCALERATIO 10 /* of abs to rel data (see map(5)) */
8: #define RESOL 2. /* coarsest resolution for tracing grid (degrees) */
9: #define TWO_THRD 0.66666666666666667
10:
11: int normproj(double, double, double *, double *);
12: int posproj(double, double, double *, double *);
13: int picut(struct place *, struct place *, double *);
14: double reduce(double);
15: short getshort(FILE *);
16: char *mapindex(char *);
17: proj projection;
18:
19:
20: static char *mapdir = "/usr/dict"; /* default map directory */
21: struct file {
22: char *name;
23: char *color;
24: char *style;
25: };
26: static struct file dfltfile = {
27: "world", BLACK, SOLID /* default map */
28: };
29: static struct file *file = &dfltfile; /* list of map files */
30: static int nfile = 1; /* length of list */
31: static char *currcolor = BLACK; /* current color */
32: static char *gridcolor = BLACK;
33: static char *bordcolor = BLACK;
34:
35: extern struct index index[];
36: int halfwidth = HALFWIDTH;
37:
38: static int (*cut)(struct place *, struct place *, double *);
39: static int (*limb)(double*, double*, double);
40: static void dolimb(void);
41: static int onlimb;
42: static int poles;
43: static double orientation[3] = { 90., 0., 0. }; /* -o option */
44: static oriented; /* nonzero if -o option occurred */
45: static upright; /* 1 if orientation[0]==90, -1 if -90, else 0*/
46: static int delta = 1; /* -d setting */
47: static double limits[4] = { /* -l parameters */
48: -90., 90., -180., 180.
49: };
50: static double klimits[4] = { /* -k parameters */
51: -90., 90., -180., 180.
52: };
53: static int limcase;
54: static double rlimits[4]; /* limits expressed in radians */
55: static double lolat, hilat, lolon, hilon;
56: static double window[4] = { /* option -w */
57: -90., 90., -180., 180.
58: };
59: static windowed; /* nozero if option -w */
60: static struct vert { double x, y; } v[NVERT+2]; /*clipping polygon*/
61: static struct edge { double a, b, c; } e[NVERT]; /* coeffs for linear inequality */
62: static int nvert; /* number of vertices in clipping polygon */
63:
64: static double rwindow[4]; /* window, expressed in radians */
65: static double params[2]; /* projection params */
66: /* bounds on output values before scaling; found by coarse survey */
67: static double xmin = 100.;
68: static double xmax = -100.;
69: static double ymin = 100.;
70: static double ymax = -100.;
71: static double xcent, ycent;
72: static double xoff, yoff;
73: double xrange, yrange;
74: static int left = -HALFWIDTH;
75: static int right = HALFWIDTH;
76: static int bottom = -HALFWIDTH;
77: static int top = HALFWIDTH;
78: static int longlines = SHORTLINES; /* drop longer segments */
79: static int shortlines = SHORTLINES;
80: static int bflag = 1; /* 0 for option -b */
81: static int s1flag = 0; /* 1 for option -s1 */
82: static int s2flag = 0; /* 1 for option -s2 */
83: static int rflag = 0; /* 1 for option -r */
84: static int kflag = 0; /* 1 if option -k occurred */
85: static int xflag = 0; /* 1 if option -x occurred */
86: int vflag = 1; /* -1 if option -v occurred */
87: static double position[3]; /* option -p */
88: static double center[3] = {0., 0., 0.}; /* option -c */
89: static struct coord crot; /* option -c */
90: static double grid[3] = { 10., 10., RESOL }; /* option -g */
91: static double dlat, dlon; /* resolution for tracing grid in lat and lon */
92: static double scaling; /* to compute final integer output */
93: static struct file *track; /* options -t and -u */
94: static int ntrack; /* number of tracks present */
95: static char *symbolfile; /* option -y */
96:
97: void clamp(double *px, double v);
98: void clipinit(void);
99: double diddle(struct place *, double, double);
100: double diddle(struct place *, double, double);
101: void dobounds(double, double, double, double, int);
102: void dogrid(double, double, double, double);
103: int duple(struct place *, double);
104: double fmax(double, double);
105: double fmin(double, double);
106: void getdata(char *);
107: int gridpt(double, double, int);
108: int inpoly(double, double);
109: int inwindow(struct place *);
110: void pathnames(void);
111: int pnorm(double);
112: void radbds(double *w, double *rw);
113: void revlon(struct place *, double);
114: void satellite(struct file *);
115: int seeable(double, double);
116: void windlim(void);
117: void realcut(void);
118:
119: int
120: option(char *s)
121: {
122:
123: if(s[0]=='-' && (s[1]<'0'||s[1]>'9'))
124: return(s[1]!='.'&&s[1]!=0);
125: else
126: return(0);
127: }
128:
129: void
130: conv(int k, struct coord *g)
131: {
132: g->l = (0.0001/SCALERATIO)*k;
133: sincos(g);
134: }
135:
136: int
137: main(int argc, char *argv[])
138: {
139: int i,k;
140: char *s, *t, *style;
141: double x, y;
142: double lat, lon;
143: double *wlim;
144: double dd;
145: if(sizeof(short)!=2)
146: abort(); /* getshort() won't work */
147: s = getenv("MAP");
148: if(s)
149: file[0].name = s;
150: s = getenv("MAPDIR");
151: if(s)
152: mapdir = s;
153: if(argc<=1)
154: error("usage: map projection params options");
155: for(k=0;index[k].name;k++) {
156: s = index[k].name;
157: t = argv[1];
158: while(*s == *t){
159: if(*s==0) goto found;
160: s++;
161: t++;
162: }
163: }
164: fprintf(stderr,"projections:\n");
165: for(i=0;index[i].name;i++) {
166: fprintf(stderr,"%s",index[i].name);
167: for(k=0; k<index[i].npar; k++)
168: fprintf(stderr," p%d", k);
169: fprintf(stderr,"\n");
170: }
171: exit(1);
172: found:
173: argv += 2;
174: argc -= 2;
175: cut = index[k].cut;
176: limb = index[k].limb;
177: poles = index[k].poles;
178: for(i=0;i<index[k].npar;i++) {
179: if(i>=argc||option(argv[i])) {
180: fprintf(stderr,"%s needs %d params\n",index[k].name,index[k].npar);
181: exit(1);
182: }
183: params[i] = atof(argv[i]);
184: }
185: argv += i;
186: argc -= i;
187: while(argc>0&&option(argv[0])) {
188: argc--;
189: argv++;
190: switch(argv[-1][1]) {
191: case 'm':
192: if(file == &dfltfile) {
193: file = 0;
194: nfile = 0;
195: }
196: while(argc && !option(*argv)) {
197: file = realloc(file,(nfile+1)*sizeof(*file));
198: file[nfile].name = *argv;
199: file[nfile].color = currcolor;
200: file[nfile].style = SOLID;
201: nfile++;
202: argv++;
203: argc--;
204: }
205: break;
206: case 'b':
207: bflag = 0;
208: for(nvert=0;nvert<NVERT&&argc>=2;nvert++) {
209: if(option(*argv))
210: break;
211: v[nvert].x = atof(*argv++);
212: argc--;
213: if(option(*argv))
214: break;
215: v[nvert].y = atof(*argv++);
216: argc--;
217: }
218: if(nvert>=NVERT)
219: error("too many clipping vertices");
220: break;
221: case 'g':
222: gridcolor = currcolor;
223: for(i=0;i<3&&argc>i&&!option(argv[i]);i++)
224: grid[i] = atof(argv[i]);
225: switch(i) {
226: case 0:
227: grid[0] = grid[1] = 0.;
228: break;
229: case 1:
230: grid[1] = grid[0];
231: }
232: argc -= i;
233: argv += i;
234: break;
235: case 't':
236: style = SOLID;
237: goto casetu;
238: case 'u':
239: style = DOTDASH;
240: casetu:
241: while(argc && !option(*argv)) {
242: track = realloc(track,(ntrack+1)*sizeof(*track));
243: track[ntrack].name = *argv;
244: track[ntrack].color = currcolor;
245: track[ntrack].style = style;
246: ntrack++;
247: argv++;
248: argc--;
249: }
250: break;
251: case 'r':
252: rflag++;
253: break;
254: case 's':
255: switch(argv[-1][2]) {
256: case '1':
257: s1flag++;
258: break;
259: case 0: /* compatibility */
260: case '2':
261: s2flag++;
262: }
263: break;
264: case 'o':
265: for(i=0;i<3&&i<argc&&!option(argv[i]);i++)
266: orientation[i] = atof(argv[i]);
267: oriented++;
268: argv += i;
269: argc -= i;
270: break;
271: case 'l':
272: bordcolor = currcolor;
273: for(i=0;i<argc&&i<4&&!option(argv[i]);i++)
274: limits[i] = atof(argv[i]);
275: argv += i;
276: argc -= i;
277: break;
278: case 'k':
279: kflag++;
280: for(i=0;i<argc&&i<4&&!option(argv[i]);i++)
281: klimits[i] = atof(argv[i]);
282: argv += i;
283: argc -= i;
284: break;
285: case 'd':
286: if(argc>0&&!option(argv[0])) {
287: delta = atoi(argv[0]);
288: argv++;
289: argc--;
290: }
291: break;
292: case 'w':
293: bordcolor = currcolor;
294: windowed++;
295: for(i=0;i<argc&&i<4&&!option(argv[i]);i++)
296: window[i] = atof(argv[i]);
297: argv += i;
298: argc -= i;
299: break;
300: case 'c':
301: for(i=0;i<3&&argc>i&&!option(argv[i]);i++)
302: center[i] = atof(argv[i]);
303: argc -= i;
304: argv += i;
305: break;
306: case 'p':
307: for(i=0;i<3&&argc>i&&!option(argv[i]);i++)
308: position[i] = atof(argv[i]);
309: argc -= i;
310: argv += i;
311: if(i!=3||position[2]<=0)
312: error("incomplete positioning");
313: break;
314: case 'y':
315: if(argc>0&&!option(argv[0])) {
316: symbolfile = argv[0];
317: argc--;
318: argv++;
319: }
320: break;
321: case 'v':
322: if(index[k].limb == 0)
323: error("-v does not apply here");
324: vflag = -1;
325: break;
326: case 'x':
327: xflag = 1;
328: break;
329: case 'C':
330: if(argc && !option(*argv)) {
331: currcolor = *argv;
332: argc--;
333: argv++;
334: }
335: break;
336: }
337: }
338: if(argc>0)
339: error("error in arguments");
340: pathnames();
341: clamp(&limits[0],-90.);
342: clamp(&limits[1],90.);
343: clamp(&klimits[0],-90.);
344: clamp(&klimits[1],90.);
345: clamp(&window[0],-90.);
346: clamp(&window[1],90.);
347: radbds(limits,rlimits);
348: limcase = limits[2]<-180.?0:
349: limits[3]>180.?2:
350: 1;
351: if(
352: window[0]>=window[1]||
353: window[2]>=window[3]||
354: window[0]>90.||
355: window[1]<-90.||
356: window[2]>180.||
357: window[3]<-180.)
358: error("unreasonable window");
359: windlim();
360: radbds(window,rwindow);
361: upright = orientation[0]==90? 1: orientation[0]==-90? -1: 0;
362: if(index[k].spheroid && !upright)
363: error("can't tilt the spheroid");
364: if(limits[2]>limits[3])
365: limits[3] += 360;
366: if(!oriented)
367: orientation[2] = (limits[2]+limits[3])/2;
368: orient(orientation[0],orientation[1],orientation[2]);
369: projection = (*index[k].prog)(params[0],params[1]);
370: if(projection == 0)
371: error("unreasonable projection parameters");
372: clipinit();
373: grid[0] = fabs(grid[0]);
374: grid[1] = fabs(grid[1]);
375: if(!kflag)
376: for(i=0;i<4;i++)
377: klimits[i] = limits[i];
378: if(klimits[2]>klimits[3])
379: klimits[3] += 360;
380: lolat = limits[0];
381: hilat = limits[1];
382: lolon = limits[2];
383: hilon = limits[3];
384: if(lolon>=hilon||lolat>=hilat||lolat<-90.||hilat>90.)
385: error("unreasonable limits");
386: wlim = kflag? klimits: window;
387: dlat = fmin(hilat-lolat,wlim[1]-wlim[0])/16;
388: dlon = fmin(hilon-lolon,wlim[3]-wlim[2])/32;
389: dd = fmax(dlat,dlon);
390: while(grid[2]>fmin(dlat,dlon)/2)
391: grid[2] /= 2;
392: realcut();
393: if(nvert<=0) {
394: for(lat=klimits[0];lat<klimits[1]+dd-FUZZ;lat+=dd) {
395: if(lat>klimits[1])
396: lat = klimits[1];
397: for(lon=klimits[2];lon<klimits[3]+dd-FUZZ;lon+=dd) {
398: i = (kflag?posproj:normproj)
399: (lat,lon+(lon<klimits[3]?FUZZ:-FUZZ),
400: &x,&y);
401: if(i*vflag <= 0)
402: continue;
403: if(x<xmin) xmin = x;
404: if(x>xmax) xmax = x;
405: if(y<ymin) ymin = y;
406: if(y>ymax) ymax = y;
407: }
408: }
409: } else {
410: for(i=0; i<nvert; i++) {
411: x = v[i].x;
412: y = v[i].y;
413: if(x<xmin) xmin = x;
414: if(x>xmax) xmax = x;
415: if(y<ymin) ymin = y;
416: if(y>ymax) ymax = y;
417: }
418: }
419: xrange = xmax - xmin;
420: yrange = ymax - ymin;
421: if(xrange<=0||yrange<=0)
422: error("map seems to be empty");
423: scaling = 2; /*plotting area from -1 to 1*/
424: if(position[2]!=0) {
425: if(posproj(position[0]-.5,position[1],&xcent,&ycent)==0||
426: posproj(position[0]+.5,position[1],&x,&y)==0)
427: error("unreasonable position");
428: scaling /= (position[2]*hypot(x-xcent,y-ycent));
429: if(posproj(position[0],position[1],&xcent,&ycent)==0)
430: error("unreasonable position");
431: } else {
432: scaling /= (xrange>yrange?xrange:yrange);
433: xcent = (xmin+xmax)/2;
434: ycent = (ymin+ymax)/2;
435: }
436: xoff = center[0]/scaling;
437: yoff = center[1]/scaling;
438: crot.l = center[2]*RAD;
439: sincos(&crot);
440: scaling *= HALFWIDTH*0.9;
441: if(symbolfile)
442: getsyms(symbolfile);
443: if(!s2flag) {
444: openpl();
445: erase();
446: }
447: range(left,bottom,right,top);
448: color(gridcolor);
449: pen(DOTTED);
450: if(grid[0]>0.)
451: for(lat=ceil(lolat/grid[0])*grid[0];
452: lat<=hilat;lat+=grid[0])
453: dogrid(lat,lat,lolon,hilon);
454: if(grid[1]>0.)
455: for(lon=ceil(lolon/grid[1])*grid[1];
456: lon<=hilon;lon+=grid[1])
457: dogrid(lolat,hilat,lon,lon);
458: color(bordcolor);
459: pen(SOLID);
460: if(bflag) {
461: dolimb();
462: dobounds(lolat,hilat,lolon,hilon,0);
463: dobounds(window[0],window[1],window[2],window[3],1);
464: }
465: lolat = floor(limits[0]/10)*10;
466: hilat = ceil(limits[1]/10)*10;
467: lolon = floor(limits[2]/10)*10;
468: hilon = ceil(limits[3]/10)*10;
469: if(lolon>hilon)
470: hilon += 360.;
471: /*do tracks first so as not to lose the standard input*/
472: for(i=0;i<ntrack;i++) {
473: longlines = LONGLINES;
474: satellite(&track[i]);
475: longlines = shortlines;
476: }
477: for(i=0;i<nfile;i++) {
478: pen(file[i].style);
479: color(file[i].color);
480: getdata(file[i].name);
481: }
482: move(right,bottom);
483: if(!s1flag)
484: closepl();
485: return 0;
486: }
487:
488: /* Out of perverseness (really to recover from a dubious,
489: but documented, convention) the returns from projection
490: functions (-1 unplottable, 0 wrong sheet, 1 good) are
491: recoded into -1 wrong sheet, 0 unplottable, 1 good. */
492:
493: int
494: fixproj(struct place *g, double *x, double *y)
495: {
496: int i = (*projection)(g,x,y);
497: return i<0? 0: i==0? -1: 1;
498: }
499:
500: int
501: normproj(double lat, double lon, double *x, double *y)
502: {
503: int i;
504: struct place geog;
505: latlon(lat,lon,&geog);
506: /*
507: printp(&geog);
508: */
509: normalize(&geog);
510: if(!inwindow(&geog))
511: return(-1);
512: i = fixproj(&geog,x,y);
513: if(rflag)
514: *x = -*x;
515: /*
516: printp(&geog);
517: fprintf(stderr,"%d %.3f %.3f\n",i,*x,*y);
518: */
519: return(i);
520: }
521:
522: int
523: posproj(double lat, double lon, double *x, double *y)
524: {
525: int i;
526: struct place geog;
527: latlon(lat,lon,&geog);
528: normalize(&geog);
529: i = fixproj(&geog,x,y);
530: if(rflag)
531: *x = -*x;
532: return(i);
533: }
534:
535: int
536: inwindow(struct place *geog)
537: {
538: if(geog->nlat.l<rwindow[0]-FUZZ||
539: geog->nlat.l>rwindow[1]+FUZZ||
540: geog->wlon.l<rwindow[2]-FUZZ||
541: geog->wlon.l>rwindow[3]+FUZZ)
542: return(0);
543: else return(1);
544: }
545:
546: int
547: inlimits(struct place *g)
548: {
549: if(rlimits[0]-FUZZ>g->nlat.l||
550: rlimits[1]+FUZZ<g->nlat.l)
551: return(0);
552: switch(limcase) {
553: case 0:
554: if(rlimits[2]+TWOPI-FUZZ>g->wlon.l&&
555: rlimits[3]+FUZZ<g->wlon.l)
556: return(0);
557: break;
558: case 1:
559: if(rlimits[2]-FUZZ>g->wlon.l||
560: rlimits[3]+FUZZ<g->wlon.l)
561: return(0);
562: break;
563: case 2:
564: if(rlimits[2]>g->wlon.l&&
565: rlimits[3]-TWOPI+FUZZ<g->wlon.l)
566: return(0);
567: break;
568: }
569: return(1);
570: }
571:
572:
573: long patch[18][36];
574:
575: void
576: getdata(char *mapfile)
577: {
578: char *indexfile;
579: int kx,ky,c;
580: int k;
581: long b;
582: long *p;
583: int ip, jp;
584: int n;
585: struct place g;
586: int i, j;
587: double lat, lon;
588: int conn;
589: FILE *ifile, *xfile;
590:
591: indexfile = mapindex(mapfile);
592: xfile = fopen(indexfile,"r");
593: if(xfile==NULL)
594: filerror("can't find map index", indexfile);
595: free(indexfile);
596: for(i=0,p=patch[0];i<18*36;i++,p++)
597: *p = 1;
598: while(!feof(xfile) && fscanf(xfile,"%d%d%ld",&i,&j,&b)==3)
599: patch[i+9][j+18] = b;
600: fclose(xfile);
601: ifile = fopen(mapfile,"r");
602: if(ifile==NULL)
603: filerror("can't find map data", mapfile);
604: for(lat=lolat;lat<hilat;lat+=10.)
605: for(lon=lolon;lon<hilon;lon+=10.) {
606: if(!seeable(lat,lon))
607: continue;
608: i = pnorm(lat);
609: j = pnorm(lon);
610: if((b=patch[i+9][j+18])&1)
611: continue;
612: fseek(ifile,b,0);
613: while((ip=getc(ifile))>=0&&(jp=getc(ifile))>=0){
614: if(ip!=(i&0377)||jp!=(j&0377))
615: break;
616: n = getshort(ifile);
617: conn = 0;
618: if(n > 0) { /* absolute coordinates */
619: for(k=0;k<n;k++){
620: kx = SCALERATIO*getshort(ifile);
621: ky = SCALERATIO*getshort(ifile);
622: if (((k%delta) != 0) && (k != (n-1)))
623: continue;
624: conv(kx,&g.nlat);
625: conv(ky,&g.wlon);
626: conn = plotpt(&g,conn);
627: }
628: } else { /* differential, scaled by SCALERATI0 */
629: n = -n;
630: kx = SCALERATIO*getshort(ifile);
631: ky = SCALERATIO*getshort(ifile);
632: for(k=0; k<n; k++) {
633: c = getc(ifile);
634: if(c&0200) c|= ~0177;
635: kx += c;
636: c = getc(ifile);
637: if(c&0200) c|= ~0177;
638: ky += c;
639: if(k%delta!=0&&k!=n-1)
640: continue;
641: conv(kx,&g.nlat);
642: conv(ky,&g.wlon);
643: conn = plotpt(&g,conn);
644: }
645: }
646: if(k==1) {
647: conv(kx,&g.nlat);
648: conv(ky,&g.wlon);
649: conn = plotpt(&g,conn);
650: }
651: }
652: }
653: fclose(ifile);
654: }
655:
656: int
657: seeable(double lat0, double lon0)
658: {
659: double x, y;
660: double lat, lon;
661: for(lat=lat0;lat<=lat0+10;lat+=2*grid[2])
662: for(lon=lon0;lon<=lon0+10;lon+=2*grid[2])
663: if(normproj(lat,lon,&x,&y)*vflag>0)
664: return(1);
665: return(0);
666: }
667:
668: void
669: satellite(struct file *t)
670: {
671: char sym[50];
672: char lbl[50];
673: double scale;
674: register conn;
675: double lat,lon;
676: struct place place;
677: static FILE *ifile = stdin;
678: if(t->name[0]!='-'||t->name[1]!=0) {
679: fclose(ifile);
680: if((ifile=fopen(t->name,"r"))==NULL)
681: filerror("can't find track", t->name);
682: }
683: color(t->color);
684: pen(t->style);
685: for(;;) {
686: conn = 0;
687: while(!feof(ifile) && fscanf(ifile,"%lf%lf",&lat,&lon)==2){
688: latlon(lat,lon,&place);
689: if(fscanf(ifile,"%1s",lbl) == 1) {
690: if(strchr("+-.0123456789",*lbl)==0)
691: break;
692: ungetc(*lbl,ifile);
693: }
694: conn = plotpt(&place,conn);
695: }
696: if(feof(ifile))
697: return;
698: fscanf(ifile,"%[^\n]",lbl+1);
699: switch(*lbl) {
700: case '"':
701: if(plotpt(&place,conn))
702: text(lbl+1);
703: break;
704: case ':':
705: case '!':
706: if(sscanf(lbl+1,"%s %lf",sym,&scale) <= 1)
707: scale = 1;
708: if(plotpt(&place,conn?conn:-1)) {
709: int r = *lbl=='!'?0:rflag?-1:1;
710: if(putsym(&place,sym,scale,r) == 0)
711: text(lbl);
712: }
713: break;
714: default:
715: if(plotpt(&place,conn))
716: text(lbl);
717: break;
718: }
719: }
720: }
721:
722: int
723: pnorm(double x)
724: {
725: int i;
726: i = x/10.;
727: i %= 36;
728: if(i>=18) return(i-36);
729: if(i<-18) return(i+36);
730: return(i);
731: }
732:
733: void
734: error(char *s)
735: {
736: fprintf(stderr,"map: \r\n%s\n",s);
737: exit(1);
738: }
739:
740: void
741: filerror(char *s, char *f)
742: {
743: fprintf(stderr,"\r\n%s %s\n",s,f);
744: exit(1);
745: }
746:
747: char *
748: mapindex(char *s)
749: {
750: char *t = malloc(strlen(s)+3);
751: strcpy(t,s);
752: strcat(t,".x");
753: return t;
754: }
755:
756: #define NOPT 32767
757: static ox = NOPT, oy = NOPT;
758:
759: int
760: cpoint(int xi, int yi, int conn)
761: {
762: int dx = abs(ox-xi);
763: int dy = abs(oy-yi);
764: if(!xflag && (xi<left||xi>=right || yi<bottom||yi>=top)) {
765: ox = oy = NOPT;
766: return 0;
767: }
768: if(conn == -1) /* isolated plotting symbol */
769: ;
770: else if(!conn)
771: move(xi,yi);
772: else {
773: if(dx+dy>longlines) {
774: ox = oy = NOPT; /* don't leap across cuts */
775: return 0;
776: }
777: if(dx || dy)
778: vec(xi,yi);
779: }
780: ox = xi, oy = yi;
781: return dx+dy<=2? 2: 1; /* 2=very near; see dogrid */
782: }
783:
784:
785: struct place oldg;
786:
787: int
788: plotpt(struct place *g, int conn)
789: {
790: int kx,ky;
791: int ret;
792: double cutlon;
793: if(!inlimits(g)) {
794: return(0);
795: }
796: normalize(g);
797: if(!inwindow(g)) {
798: return(0);
799: }
800: switch((*cut)(g,&oldg,&cutlon)) {
801: case 2:
802: if(conn) {
803: ret = duple(g,cutlon)|duple(g,cutlon);
804: oldg = *g;
805: return(ret);
806: }
807: case 0:
808: conn = 0;
809: default: /* prevent diags about bad return value */
810: case 1:
811: oldg = *g;
812: ret = doproj(g,&kx,&ky);
813: if(ret==0 || !onlimb && ret*vflag<=0)
814: return(0);
815: ret = cpoint(kx,ky,conn);
816: return ret;
817: }
818: }
819:
820: int
821: doproj(struct place *g, int *kx, int *ky)
822: {
823: int i;
824: double x,y,x1,y1;
825: /*fprintf(stderr,"dopr1 %f %f \n",g->nlat.l,g->wlon.l);*/
826: i = fixproj(g,&x,&y);
827: if(i == 0)
828: return(0);
829: if(rflag)
830: x = -x;
831: /*fprintf(stderr,"dopr2 %f %f\n",x,y);*/
832: if(!inpoly(x,y)) {
833: return 0;
834: }
835: x1 = x - xcent;
836: y1 = y - ycent;
837: x = (x1*crot.c - y1*crot.s + xoff)*scaling;
838: y = (x1*crot.s + y1*crot.c + yoff)*scaling;
839: *kx = x + (x>0?.5:-.5);
840: *ky = y + (y>0?.5:-.5);
841: return(i);
842: }
843:
844: int
845: duple(struct place *g, double cutlon)
846: {
847: int kx,ky;
848: int okx,oky;
849: struct place ig;
850: revlon(g,cutlon);
851: revlon(&oldg,cutlon);
852: ig = *g;
853: invert(&ig);
854: if(!inlimits(&ig))
855: return(0);
856: if(doproj(g,&kx,&ky)*vflag<=0 ||
857: doproj(&oldg,&okx,&oky)*vflag<=0)
858: return(0);
859: cpoint(okx,oky,0);
860: cpoint(kx,ky,1);
861: return(1);
862: }
863:
864: void
865: revlon(struct place *g, double cutlon)
866: {
867: g->wlon.l = reduce(cutlon-reduce(g->wlon.l-cutlon));
868: sincos(&g->wlon);
869: }
870:
871:
872: /* recognize problems of cuts
873: * move a point across cut to side of its predecessor
874: * if its very close to the cut
875: * return(0) if cut interrupts the line
876: * return(1) if line is to be drawn normally
877: * return(2) if line is so close to cut as to
878: * be properly drawn on both sheets
879: */
880:
881: int
882: picut(struct place *g, struct place *og, double *cutlon)
883: {
884: *cutlon = PI;
885: return(ckcut(g,og,PI));
886: }
887:
888: int
889: nocut(struct place *g, struct place *og, double *cutlon)
890: {
891: #pragma ref g
892: #pragma ref og
893: #pragma ref cutlon
894: return(1);
895: }
896:
897: int
898: ckcut(struct place *g1, struct place *g2, double lon)
899: {
900: double d1, d2;
901: double f1, f2;
902: int kx,ky;
903: d1 = reduce(g1->wlon.l -lon);
904: d2 = reduce(g2->wlon.l -lon);
905: if((f1=fabs(d1))<FUZZ)
906: d1 = diddle(g1,lon,d2);
907: if((f2=fabs(d2))<FUZZ) {
908: d2 = diddle(g2,lon,d1);
909: if(doproj(g2,&kx,&ky)*vflag>0)
910: cpoint(kx,ky,0);
911: }
912: if(f1<FUZZ&&f2<FUZZ)
913: return(2);
914: if(f1>PI*TWO_THRD||f2>PI*TWO_THRD)
915: return(1);
916: return(d1*d2>=0);
917: }
918:
919: double
920: diddle(struct place *g, double lon, double d)
921: {
922: double d1;
923: d1 = FUZZ/2;
924: if(d<0)
925: d1 = -d1;
926: g->wlon.l = reduce(lon+d1);
927: sincos(&g->wlon);
928: return(d1);
929: }
930:
931: double
932: reduce(double lon)
933: {
934: if(lon>PI)
935: lon -= 2*PI;
936: else if(lon<-PI)
937: lon += 2*PI;
938: return(lon);
939: }
940:
941:
942: double tetrapt = 35.26438968; /* atan(1/sqrt(2)) */
943:
944: void
945: dogrid(double lat0, double lat1, double lon0, double lon1)
946: {
947: double slat,slon,tlat,tlon;
948: register int conn, oconn;
949: slat = tlat = slon = tlon = 0;
950: if(lat1>lat0)
951: slat = tlat = fmin(grid[2],dlat);
952: else
953: slon = tlon = fmin(grid[2],dlon);;
954: conn = oconn = 0;
955: while(lat0<=lat1&&lon0<=lon1) {
956: conn = gridpt(lat0,lon0,conn);
957: if(projection==Xguyou&&slat>0) {
958: if(lat0<-45&&lat0+slat>-45)
959: conn = gridpt(-45.,lon0,conn);
960: else if(lat0<45&&lat0+slat>45)
961: conn = gridpt(45.,lon0,conn);
962: } else if(projection==Xtetra&&slat>0) {
963: if(lat0<-tetrapt&&lat0+slat>-tetrapt) {
964: gridpt(-tetrapt-.001,lon0,conn);
965: conn = gridpt(-tetrapt+.001,lon0,0);
966: }
967: else if(lat0<tetrapt&&lat0+slat>tetrapt) {
968: gridpt(tetrapt-.001,lon0,conn);
969: conn = gridpt(tetrapt+.001,lon0,0);
970: }
971: }
972: if(conn==0 && oconn!=0) {
973: if(slat+slon>.05) {
974: lat0 -= slat; /* steps too big */
975: lon0 -= slon; /* or near bdry */
976: slat /= 2;
977: slon /= 2;
978: conn = oconn = gridpt(lat0,lon0,conn);
979: } else
980: oconn = 0;
981: } else {
982: if(conn==2) {
983: slat = tlat;
984: slon = tlon;
985: conn = 1;
986: }
987: oconn = conn;
988: }
989: lat0 += slat;
990: lon0 += slon;
991: }
992: gridpt(lat1,lon1,conn);
993: }
994:
995: static gridinv; /* nonzero when doing window bounds */
996:
997: int
998: gridpt(double lat, double lon, int conn)
999: {
1000: struct place g;
1001: /*fprintf(stderr,"%f %f\n",lat,lon);*/
1002: latlon(lat,lon,&g);
1003: if(gridinv)
1004: invert(&g);
1005: return(plotpt(&g,conn));
1006: }
1007:
1008: /* win=0 ordinary grid lines, win=1 window lines */
1009:
1010: void
1011: dobounds(double lolat, double hilat, double lolon, double hilon, int win)
1012: {
1013: gridinv = win;
1014: if(lolat>-90 || win && (poles&1)!=0)
1015: dogrid(lolat+FUZZ,lolat+FUZZ,lolon,hilon);
1016: if(hilat<90 || win && (poles&2)!=0)
1017: dogrid(hilat-FUZZ,hilat-FUZZ,lolon,hilon);
1018: if(hilon-lolon<360 || win && cut==picut) {
1019: dogrid(lolat,hilat,lolon+FUZZ,lolon+FUZZ);
1020: dogrid(lolat,hilat,hilon-FUZZ,hilon-FUZZ);
1021: }
1022: gridinv = 0;
1023: }
1024:
1025: static void
1026: dolimb(void)
1027: {
1028: double lat, lon;
1029: double res = fmin(dlat, dlon)/4;
1030: int conn = 0;
1031: int newconn;
1032: if(limb == 0)
1033: return;
1034: onlimb = gridinv = 1;
1035: for(;;) {
1036: newconn = (*limb)(&lat, &lon, res);
1037: if(newconn == -1)
1038: break;
1039: conn = gridpt(lat, lon, conn*newconn);
1040: }
1041: onlimb = gridinv = 0;
1042: }
1043:
1044:
1045: void
1046: radbds(double *w, double *rw)
1047: {
1048: int i;
1049: for(i=0;i<4;i++)
1050: rw[i] = w[i]*RAD;
1051: rw[0] -= FUZZ;
1052: rw[1] += FUZZ;
1053: rw[2] -= FUZZ;
1054: rw[3] += FUZZ;
1055: }
1056:
1057: void
1058: windlim(void)
1059: {
1060: double center = orientation[0];
1061: double colat;
1062: if(center>90)
1063: center = 180 - center;
1064: if(center<-90)
1065: center = -180 - center;
1066: if(fabs(center)>90)
1067: error("unreasonable orientation");
1068: colat = 90 - window[0];
1069: if(center-colat>limits[0])
1070: limits[0] = center - colat;
1071: if(center+colat<limits[1])
1072: limits[1] = center + colat;
1073: }
1074:
1075:
1076: short
1077: getshort(FILE *f)
1078: {
1079: int c, r;
1080: c = getc(f);
1081: r = (c | getc(f)<<8);
1082: if (r&0x8000)
1083: r |= ~0xFFFF; /* in case short > 16 bits */
1084: return r;
1085: }
1086:
1087: double
1088: fmin(double x, double y)
1089: {
1090: return(x<y?x:y);
1091: }
1092:
1093: double
1094: fmax(double x, double y)
1095: {
1096: return(x>y?x:y);
1097: }
1098:
1099: void
1100: clamp(double *px, double v)
1101: {
1102: *px = (v<0?fmax:fmin)(*px,v);
1103: }
1104:
1105: void
1106: pathnames(void)
1107: {
1108: int i;
1109: char *t, *indexfile, *name;
1110: FILE *f, *fx;
1111: for(i=0; i<nfile; i++) {
1112: name = file[i].name;
1113: if(*name=='/')
1114: continue;
1115: indexfile = mapindex(name);
1116: /* ansi equiv of unix access() call */
1117: f = fopen(name, "r");
1118: fx = fopen(indexfile, "r");
1119: if(f) fclose(f);
1120: if(fx) fclose(fx);
1121: free(indexfile);
1122: if(f && fx)
1123: continue;
1124: t = malloc(strlen(name)+strlen(mapdir)+2);
1125: strcpy(t,mapdir);
1126: strcat(t,"/");
1127: strcat(t,name);
1128: file[i].name = t;
1129: }
1130: }
1131:
1132: void
1133: clipinit(void)
1134: {
1135: register i;
1136: double s,t;
1137: if(nvert<=0)
1138: return;
1139: for(i=0; i<nvert; i++) { /*convert latlon to xy*/
1140: if(normproj(v[i].x,v[i].y,&v[i].x,&v[i].y)==0)
1141: error("invisible clipping vertex");
1142: }
1143: if(nvert==2) { /*rectangle with diag specified*/
1144: nvert = 4;
1145: v[2] = v[1];
1146: v[1].x=v[0].x, v[1].y=v[2].y, v[3].x=v[2].x, v[3].y=v[0].y;
1147: }
1148: v[nvert] = v[0];
1149: v[nvert+1] = v[1];
1150: s = 0;
1151: for(i=1; i<=nvert; i++) { /*test for convexity*/
1152: t = (v[i-1].x-v[i].x)*(v[i+1].y-v[i].y) -
1153: (v[i-1].y-v[i].y)*(v[i+1].x-v[i].x);
1154: if(t<-FUZZ && s>=0) s = 1;
1155: if(t>FUZZ && s<=0) s = -1;
1156: if(-FUZZ<=t&&t<=FUZZ || t*s>0) {
1157: s = 0;
1158: break;
1159: }
1160: }
1161: if(s==0)
1162: error("improper clipping polygon");
1163: for(i=0; i<nvert; i++) { /*edge equation ax+by=c*/
1164: e[i].a = s*(v[i+1].y - v[i].y);
1165: e[i].b = s*(v[i].x - v[i+1].x);
1166: e[i].c = s*(v[i].x*v[i+1].y - v[i].y*v[i+1].x);
1167: }
1168: }
1169:
1170: int
1171: inpoly(double x, double y)
1172: {
1173: register i;
1174: for(i=0; i<nvert; i++) {
1175: register struct edge *ei = &e[i];
1176: double val = x*ei->a + y*ei->b - ei->c;
1177: if(val>10*FUZZ)
1178: return(0);
1179: }
1180: return 1;
1181: }
1182:
1183: void
1184: realcut()
1185: {
1186: struct place g;
1187: double lat;
1188:
1189: if(cut != picut) /* punt on unusual cuts */
1190: return;
1191: for(lat=window[0]; lat<=window[1]; lat+=grid[2]) {
1192: g.wlon.l = PI;
1193: sincos(&g.wlon);
1194: g.nlat.l = lat*RAD;
1195: sincos(&g.nlat);
1196: if(!inwindow(&g)) {
1197: break;
1198: }
1199: invert(&g);
1200: if(inlimits(&g)) {
1201: return;
1202: }
1203: }
1204: longlines = shortlines = LONGLINES;
1205: cut = nocut; /* not necessary; small eff. gain */
1206: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.