plot_map_new.c

Go to the documentation of this file.

 
 
#include "prototypes_new.h"
 
void plot_map(Pixmap pixm,int h, int display_flag,int num)
 
{
extern int dmvalue;
extern int pcpn_time_step;
extern int rsmode;
extern int pcp_in_use[500];
extern struct pcp *spf;
extern struct pcp *pcp;
extern int wfo_all;
extern int wfo_in_use[20];
extern struct map map[1500];
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 unsigned long qmap[16];
extern Widget drawing_area;
extern float delim[][16];
extern struct display_set display_set[4];
int hh;
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;
int  nx[6],ny[6];
int minx,miny,ix,iy,maxx,maxy;
extern Region region;    
float uz,mz,lz,gz,fx,fy;
int i1;
int i,j;
char file[100];
 
strcpy(file,"pcp");
 
if(pcpn_time_step==0 && rsmode != 1) {
         
         i1=1;
     
     if(num==0)
             i1=0;          
 
     
                 if(pcp_in_use[num+200]!=-1 && pcp_in_use[num+200-i1]!=-1) {
         
                         read_file(file,num+200,spf);
             read_file(file,num+200-i1,pcp);
             
                         for(i=0;i<hrap_grid->maxi-1;i++) {
 
                         for(j=0;j<hrap_grid->maxj-1;j++) {
 
                         spf->value[i][j]=(spf->value[i][j] +
                               pcp->value[i][j])/2;
 
             
             
             }
             
             }
             
             
             }
             
              else if(pcp_in_use[num+200]==1) {
         
                         read_file(file,num+200,spf);
            
             
             }
             
             else if(pcp_in_use[num+200-i1]==1) {
         
                         read_file(file,num+200-i1,spf);
            
             
             }
             
                 
                   }
 
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;
 
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;
                                        
        if(wfo_all!=1) {
 
        for(hh=0;hh<20;hh++) {
 
             if(wfo_in_use[hh] == -1)
                                     break;
 
             if(map[ib].owner==wfo_in_use[hh])
                                     break;          
 
       }
 
       if(wfo_in_use[hh]==-1) 
                           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];        
          
          if( map[ib].zones[1] !=1 && 
              map[ib].zones[2] !=1 &&
              map[ib].zones[3] !=1 && rsmode==1) {
              
              XSetClipMask(display,gc,None);  
              
              mapvalue=lz;
 
              for(k=0;k<15;k++) {
 
                     if(mapvalue >= delim[kscale][k] &&
                        mapvalue <  delim[kscale][k+1]) {
 
                                          color=xmap[k];
                                          break;
 
                    }
                     
                  } 
 
          if(mapvalue > .01 || mapvalue < -.01) {
          
          
          if(k==15)
                          color=xmap[15];
        
          XSetForeground(display,gc,color);
          
          XFillPolygon(display,pixm,gc,point,map[ib].basin_points,Complex,CoordModeOrigin);
 
           }
        
          line_width=2;
          line_style=LineSolid;
          cap_style=CapButt;
          join_style=JoinMiter;
      
          XSetLineAttributes(display,gc,line_width,line_style,cap_style,
                             join_style);
 
          XSetForeground(display,gc,qmap[15]);
 
          XDrawLines(display,pixm,gc,point,map[ib].basin_points,CoordModeOrigin);
 
          continue;
               
          }
          
          region=XPolygonRegion(point,map[ib].basin_points,WindingRule);
 
          XSetRegion(display,gc,region); 
          XDestroyRegion(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) {
 
                 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;
 
 
              if(rsmode==1) {
          
 
              for(k=0;k<15;k++) {
 
                     if(mapvalue >= delim[kscale][k] &&
                        mapvalue <  delim[kscale][k+1]) {
 
                                          color=xmap[k];
                                          break;
 
                    }
                     
                  } 
 
              if(mapvalue <= 0.01 && mapvalue >= -0.01)
                          continue;
 
              else if(k==15)
                          color=xmap[15];
        
       }    
              
             else {
          
             for(k=0;k<4;k++) {
 
                     if(mapvalue >= delim[kscale][k] &&
                        mapvalue <  delim[kscale][k+1]) {
 
                                          color=xmap[k];
                                          break;
 
                    }
                     
                  } 
 
              if(mapvalue <= 0.01 && mapvalue >= -0.01)
                          continue;
 
              if(k==4)
                     color=xmap[4];
 
              if(mapvalue < -99.98)
                     color=xmap[7]; 
              
              if(color==0)
                        continue;
                    
          
          }
        
              if(rsmode != 1 && 
             (pcp_in_use[200+num] == 1 ||
         pcp_in_use[200+num-i1] == 1)) {
                            
                          if(spf->value[ix][iy] * 10 - dmvalue < 
                 hrap_grid->elev[ix][iy])
                                                      color=xmap[k+5];
                                                      
                           
                                                  
                           }                           
 
              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);
 
       XSetForeground(display,gc,qmap[15]);
 
       XDrawLines(display,pixm,gc,point,map[ib].basin_points,CoordModeOrigin);
 
       }
 
XSetClipMask(display,gc,None);   
 
}