plot_mat.c

Go to the documentation of this file.

 
 
#include "prototypes_new.h"
 
void plot_mat(Pixmap pixm,int h, int display_flag,int num)
 
{
 
extern struct pcp *spf;
extern int pcp_in_use[500];
extern int pcpn_time;
extern int rsmode;
extern int wfo_all;
extern int wfo_in_use[20];
extern struct map map[1500];
extern int tscale;
extern struct hrap_grid *hrap_grid;
extern Font font[10];
extern Display *display;
extern int npoint[2],zoom;
extern int tscale;
extern GC gc;
extern unsigned long mnmap[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;
 
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].tmaps_done[num-150] <=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].tlz[num-150];
          mz=map[ib].tmz[num-150];
          uz=map[ib].tuz[num-150];
          gz=map[ib].tgz[num-150];        
          
          if( map[ib].zones[1] !=1 && 
              map[ib].zones[2] !=1 &&
              map[ib].zones[3] !=1) {
              
              XSetClipMask(display,gc,None);  
              
              mapvalue=lz;
 
              for(k=0;k<15;k++) {
 
                     if(mapvalue >= delim[tscale][k] &&
                        mapvalue <  delim[tscale][k+1]) {
 
                                          color=mnmap[k];
                                          break;
 
                    }
                     
                  } 
 
          if(mapvalue > .01 || mapvalue < -.01) {
          
          
          if(k==15)
                          color=mnmap[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;
 
              for(k=0;k<15;k++) {
 
                     if(mapvalue >= delim[tscale][k] &&
                        mapvalue <  delim[tscale][k+1]) {
 
                                          color=mnmap[k];
                                          break;
 
                    }
                     
                  } 
 
              if(mapvalue <= -999)
                          continue;
 
              else if(k==15)
                          color=mnmap[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);
 
       XSetForeground(display,gc,qmap[15]);
 
       XDrawLines(display,pixm,gc,point,map[ib].basin_points,CoordModeOrigin);
 
       }
 
XSetClipMask(display,gc,None);   
 
}