plot_map.c

Go to the documentation of this file.

#include "/usr/include/X11/bitmaps/wide_weave"
#include "prototypes.h"
 
void plot_map(Pixmap pixm,int h, int display_flag,int num)
 
{
 
extern Font font[10];
extern struct map map[500];
extern int kscale;
extern struct hrap_grid *hrap_grid;
extern Font font[10];
extern Display *display;
extern int npoint[2],zoom;
extern int kscale;
extern GC gc;
extern unsigned long xmap[16];
extern Widget drawing_area;
extern float delim[5][16];
extern struct display_set display_set[4];
int k;
int x,y,ip,ib;
int color,MY=10;
float xrat,yrat,mult,dmult,cmult;
Dimension width,height;
Arg args[10];
unsigned long XSIZE,YSIZE;
signed long xmin,xmax,ymin,ymax,lint1,lint2;
signed long xcen,ycen;
int di[4],dj[4],dy,dx;
XPoint point[10000];
XPoint mpoint[6];
int l,line_width,line_style,cap_style,join_style;
double mapvalue;
signed long r,s;
signed long nx[6],ny[6];
int minx,miny,ix,iy,maxx,maxy;
extern Region region;    
float uz,mz,lz,gz,fx,fy;
 
XSetFont(display,gc,font[0]);
minx=hrap_grid->hrap_minx;
miny=hrap_grid->hrap_miny;
maxx=hrap_grid->maxi;
maxy=hrap_grid->maxj;
 
dx=1;dy=1;
 
di[0]=0;dj[0]=0;
di[1]=1;dj[1]=0; 
di[2]=1;dj[2]=1;
di[3]=0;dj[3]=1;
 
XSetFont(display,gc,font[0]);
  
dmult=display_set[display_flag].dmult[h];
xmin= display_set[display_flag].xmin[h];
xmax= display_set[display_flag].xmax[h];
ymin= display_set[display_flag].ymin[h];
ymax= display_set[display_flag].ymax[h];
xcen= display_set[display_flag].xcen[h];
ycen= display_set[display_flag].ycen[h];
 
XtSetArg(args[0],XtNwidth,&width);
XtSetArg(args[1],XtNheight,&height);
XtGetValues(drawing_area,args,2);
 
XSIZE=(long)width*10L;
YSIZE=(long)height*10L;
 
xrat=(float)XSIZE/(float)12800;
yrat=(float)YSIZE/(float)9600;
 
if(xrat < yrat)
             mult=xrat;
 
else
             mult=yrat;
 
cmult=dmult*mult;
lint1=(long)npoint[0]*(long)MY;
lint2=(long)npoint[1]*(long)MY;
XSetFillRule(display,gc,WindingRule);
 
for(ib=0;map[ib].hb5[0]!=0;ib++) {
 
        if(map[ib].maps_done[num] <=0)
                                        continue;
 
        for(l=0;l<map[ib].basin_points;l++) {
 
              r=map[ib].basin[l].x;
              s=map[ib].basin[l].y;
 
              if(zoom<=1) {
                           
                    point[l].x=(xmin+(float)r * cmult)/MY;
                    point[l].y=(ymin+(float)s * cmult)/MY;
 
                          }
              else     {
 
                    fx =((((xmin+(float)r*cmult)-lint1)*zoom+xcen)/MY);
                    fy=((((ymin+(float)s*cmult)-lint2)*zoom+ycen)/MY);
 
 
                    if(fx < 0)
                          fx=0;
                    if(fy < 0)
                          fy=0;
                    if(fx > width) 
                          fx=width;
                    if(fy>height)
                          fy=height; 
 
                    point[l].x=(short int)fx;
                    point[l].y=(short int)fy;
 
         }
 
         }
 
          lz=map[ib].lz[num];
          mz=map[ib].mz[num];
          uz=map[ib].uz[num];
          gz=map[ib].gz[num];
 
          region=XPolygonRegion(point,map[ib].basin_points,WindingRule);
          XSetRegion(display,gc,region); 
 
          for(l=0;l<map[ib].hrap_points;l++) {
 
              x=map[ib].hrap_data[l].x;
              y=map[ib].hrap_data[l].y;
 
              /* search for highest zone number is hrap block */
 
              ip=1;
 
              if(map[ib].hrap_data[l].zone[1] >= 0)
                          ip=2;
                                  
              if(map[ib].hrap_data[l].zone[2] >= 0)
                          ip=3;
                     
              if(map[ib].hrap_data[l].zone[3] >= 0)
                          ip=4;
 
              if(ip==4)
                     mapvalue=gz; 
 
              else if(ip==3)
                     mapvalue=uz;
                     
              else if(ip==2)
                     mapvalue=mz;
 
              else
                     mapvalue=lz;
                  
              ix=x-minx;
              iy=y-miny;
 
              if(ix < 0 || iy < 0 || ix > maxx-1 || iy > maxy-1) {
 
                 printf("coordinate error\n");
 
                 continue;
 
      }
 
             if(zoom <= 1) {
             
                for(k=0;k<4;k++) {               
 
                    nx[k]=xmin+(float)hrap_grid->coord[ix+di[k]][iy+dj[k]].x*
                          cmult;                
                    ny[k]=ymin+(float)hrap_grid->coord[ix+di[k]][iy+dj[k]].y*
                    cmult;
 
        }
        }
 
              else {
 
                for(k=0;k<4;k++) {               
 
                     nx[k]=xmin+((float)hrap_grid->coord[ix+di[k]][iy+dj[k]].x*
                           cmult-lint1)*zoom + xcen;
                     ny[k]=ymin+((float)hrap_grid->coord[ix+di[k]][iy+dj[k]].y*
                           cmult-lint2)*zoom + ycen;
                   
           
           }
 
          }
 
             for(k=0;k<4;k++) {
 
                        mpoint[k].x=(nx[k]+5)/MY;
                        mpoint[k].y=(ny[k]+5)/MY;
 
              }
          
              mpoint[4].x=mpoint[0].x;
              mpoint[4].y=mpoint[0].y;
 
              for(k=0;k<15;k++) {
 
                     if(mapvalue >= delim[kscale][k] &&
                        mapvalue <  delim[kscale][k+1]) {
 
                                          color=xmap[k];
                                          break;
 
                    }
                     
                  } 
 
              if(mapvalue <= 0)
                          color=0;
 
              else if(k==15)
                          color=xmap[15];
        
              XSetForeground(display,gc,color);
 
              XFillPolygon(display,pixm,gc,mpoint,5,Convex,CoordModeOrigin);
 
        }
 
       line_width=2;
       line_style=LineSolid;
       cap_style=CapButt;
       join_style=JoinMiter;
 
       XSetLineAttributes(display,gc,line_width,line_style,cap_style,
                         join_style);
 
       XSetFillStyle(display,gc,FillSolid);
       XSetForeground(display,gc,0);
       XSetClipMask(display,gc,None);
       XDrawLines(display,pixm,gc,point,map[ib].basin_points,CoordModeOrigin);
 
       }
 
XSetClipMask(display,gc,None);   
 
}