contour_pcpn_new.c

Go to the documentation of this file.

 
#include "prototypes_new.h"
 
void contour_pcpn(Pixmap pixm,int h, int display_flag,char *file,int num)
 
{
 
extern int wfo_all;
extern int wfo_in_use[20];
extern int pcp_in_use[500];
extern struct pcp *pcp;
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[][16];
extern struct display_set display_set[4];
extern struct hrap_grid *hrap_grid;
int i,j,k,m,l;
int color,MY=10;
float xrat,yrat,mult,dmult,cmult;
long nx[4],ny[4];
Dimension width,height;
Arg args[10];
unsigned long XSIZE,YSIZE;
XPoint point[5];
long xmin,xmax,ymin,ymax,lint1,lint2;
signed long xcen,ycen;
int di[5],dj[5],dy,dx,pnum,kk,mm;
float value[5];
float x[5],y[5],xx[5],yy[5];
int line_style,cap_style,join_style;
unsigned line_width; 
int xint,yint,dup_flag[5];
 
if(pcp_in_use[num]==-1)
                           return;
 
read_file(file,num,pcp);
 
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;
di[4]=0;dj[4]=0;
 
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;
 
line_width=2;
line_style=LineSolid;
cap_style=CapButt; 
join_style=JoinMiter;
 
XSetLineAttributes(display,gc,line_width,line_style,cap_style,join_style);
 
for(i=0;i<hrap_grid->maxi-1;i++) {
 
for(j=0;j<hrap_grid->maxj-1;j++) {
 
          if(wfo_all != 1) {
 
             for(m=0;m<20;m++) {
 
                if(wfo_in_use[m] == -1)
                                     break;
 
                if(hrap_grid->owner[i][j]==    wfo_in_use[m] &&
                   hrap_grid->owner[i+1][j]==  wfo_in_use[m] &&
                   hrap_grid->owner[i+1][j+1]==wfo_in_use[m] &&
                   hrap_grid->owner[i][j+1]==  wfo_in_use[m])
                
                                     break;          
 
              }
 
             if(wfo_in_use[m]==-1)
                            continue;
 
             }
 
             
             value[0]=(float)pcp->value[i][j]/100;
             value[1]=(float)pcp->value[i+1][j]/100;
             value[2]=(float)pcp->value[i+1][j+1]/100;
             value[3]=(float)pcp->value[i][j+1]/100;
 
             if(value[0]<=0.001 && value[0]>=-0.001 &&
                value[1]<=0.001 && value[1]>=-0.001 &&
                value[2]<=0.001 && value[2]>=-0.001 &&
                value[3]<=0.001 && value[3]>=-0.001)
                          continue;
 
             value[4]=value[0];
 
             for(l=0;l<16;l++) {
                if(xmap[l]==0)
                             continue;
  
                  pnum=0;
 
                  for(m=0;m<4;m++) {
 
                      if((delim[kscale][l] >= value[m] &&
                          delim[kscale][l] < value[m+1]) ||
                         (delim[kscale][l] < value[m] &&
                          delim[kscale][l] >= value[m+1])) {
 
                      if(value[m]==value[m+1])
                                 continue;
 
                      x[pnum]=(float)hrap_grid->coord[i+di[m+1]][j+dj[m+1]].x +
                                (float)(hrap_grid->coord[i+di[m]][j+dj[m]].x-
                                       hrap_grid->coord[i+di[m+1]][j+dj[m+1]].x)/
                                       (value[m]-value[m+1])*
                                       (delim[kscale][l]-value[m+1]);
   
                      y[pnum]=(float)hrap_grid->coord[i+di[m+1]][j+dj[m+1]].y +
                               (float)(hrap_grid->coord[i+di[m]][j+dj[m]].y-
                                       hrap_grid->coord[i+di[m+1]][j+dj[m+1]].y)/
                                      (value[m]-value[m+1])*
                                      (delim[kscale][l]-value[m+1]);
 
                       for(h=0;h<pnum;h++){
 
                           if(x[h]==x[pnum] && y[h]==y[pnum])
                                                      goto hop;
 
                                            }  
 
                      if(pnum==2) { 
 
                       for(kk=0;kk<3;kk++) {
 
                          dup_flag[kk]=0;
               
                          for(mm=0;mm<4;mm++) {
  
                          xint=(int)x[kk];
                          yint=(int)y[kk];
 
                          if(xint/10==hrap_grid->coord[i+di[mm]][j+dj[mm]].x/10 &&
                             yint/10==hrap_grid->coord[i+di[mm]][j+dj[mm]].y/10)
                                   dup_flag[kk]=1;
                       
                      
            }
            } 
            }
                      pnum++;
                  
              hop:
 
                   pnum=pnum;
 
            }
 
            }
 
if(pnum==3) {
 
            mm=0;
            for(kk=0;kk<3;kk++){
 
                   if(dup_flag[kk]==0) {
                       xx[mm]=x[kk];
                       yy[mm++]=y[kk];
 
          
             }
 
         }
 
           
 
           for(kk=0;kk<2;kk++){
 
                             x[kk]=xx[kk];
                             y[kk]=yy[kk];
 
               }
          pnum=mm;
 
          }
 
if(pnum != 2 && pnum != 4)
                    continue;
 
            color=xmap[l];
              XSetForeground(display,gc,color);
 
              if(zoom <= 1) {
 
              for(k=0;k<pnum;k++) {               
 
                  nx[k]=xmin+x[k]*cmult;                
                  ny[k]=ymin+y[k]*cmult;
 
        }
        }
 
              else {
 
                 for(k=0;k<pnum;k++) {               
 
                     nx[k]=(xmin+(x[k]*cmult-lint1))*zoom + xcen;
                     ny[k]=(ymin+(y[k]*cmult-lint2))*zoom + ycen;
                   
           }
 
}          
              for(k=0;k<pnum;k++) {
 
                        point[k].x=(nx[k]+5)/MY;
                        point[k].y=(ny[k]+5)/MY;
 
 
              }
 
       
 
       if(pnum==2)
         XDrawLine(display,pixm,gc,point[0].x,point[0].y,point[1].x,point[1].y);
  
       else      {
 
              if(delim[kscale][l] < value[1]) {
 
          XDrawLine(display,pixm,gc,point[1].x,point[1].y,point[2].x,point[2].y);
          XDrawLine(display,pixm,gc,point[3].x,point[3].y,point[0].x,point[0].y);
  
    }
 
            else {
 
          XDrawLine(display,pixm,gc,point[0].x,point[0].y,point[1].x,point[1].y);
          XDrawLine(display,pixm,gc,point[2].x,point[2].y,point[3].x,point[3].y);
  
    }
 
         }                               
        }
 
       }
}
        
 
line_width=0;
line_style=LineSolid;
cap_style=CapButt;
join_style=JoinMiter;
 
XSetLineAttributes(display,gc,line_width,line_style,cap_style,join_style);
    
 
return;
 
}