contour_maxmin.c

Go to the documentation of this file.

 
#include "prototypes_new.h"
 
void contour_maxmin(int isom,Pixmap pixm,int h, int display_flag,int type)
 
{
 
extern float delim[][16];
extern Font font[10];
extern Display *display;
extern int npoint[2],zoom;
extern GC gc;
extern unsigned long mnmap[16];
extern Widget drawing_area;
extern struct display_set display_set[4];
extern struct maxmin *maxmin;
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];
int maxtop,mintop;
extern int tscale;
float fm;
 
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=0;
line_style=LineSolid;
cap_style=CapButt; 
join_style=JoinMiter;
 
XSetLineAttributes(display,gc,line_width,line_style,cap_style,join_style);
 
for(i=0;i<maxmin->maxi-1;i++) {
 
for(j=0;j<maxmin->maxj-1;j++) {
 
             if(type==0) {
         
             value[0]=(float)(maxmin->maxvalue[isom][i][j])/10;
             value[1]=(float)(maxmin->maxvalue[isom][i+1][j])/10;
             value[2]=(float)(maxmin->maxvalue[isom][i+1][j+1])/10;
             value[3]=(float)(maxmin->maxvalue[isom][i][j+1])/10;
 
             }
 
             else if(type==1) {
         
             value[0]=(float)(maxmin->minvalue[isom][i][j])/10;
             value[1]=(float)(maxmin->minvalue[isom][i+1][j])/10;
             value[2]=(float)(maxmin->minvalue[isom][i+1][j+1])/10;
             value[3]=(float)(maxmin->minvalue[isom][i][j+1])/10;
 
             }
 
             maxtop=0;
             mintop=9999;
             for(mm=0;mm<4;mm++) {
 
                  if(value[mm] < mintop)
                          mintop=value[mm];
 
                  if(value[mm] > maxtop)
                          maxtop=value[mm];
 
        }
       
             value[4]=value[0];
 
             for(l=0;l<16;l++) {
 
                  if(mnmap[l]==0)
                             continue;
                 
  /*
                  if(telim < mintop || telim > maxtop)
                                  continue; */
                                  
                  pnum=0;
 
                  for(m=0;m<4;m++) {
 
                      if((delim[tscale][l] >= value[m] &&
                          delim[tscale][l] < value[m+1]) ||
                         (delim[tscale][l] < value[m] &&
                          delim[tscale][l] >= value[m+1])) {
 
                      if(value[m]==value[m+1])
                                 continue;
 
                      x[pnum]=(float)maxmin->coord[i+di[m+1]][j+dj[m+1]].x +
                                (float)(maxmin->coord[i+di[m]][j+dj[m]].x-
                                        maxmin->coord[i+di[m+1]][j+dj[m+1]].x)/
                                       (value[m]-value[m+1])*
                                       (delim[tscale][l]-value[m+1]);
   
                      y[pnum]=(float)maxmin->coord[i+di[m+1]][j+dj[m+1]].y +
                               (float)(maxmin->coord[i+di[m]][j+dj[m]].y-
                                       maxmin->coord[i+di[m+1]][j+dj[m+1]].y)/
                                      (value[m]-value[m+1])*
                                      (delim[tscale][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==maxmin->coord[i+di[mm]][j+dj[mm]].x/10 &&
                             yint/10==maxmin->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=mnmap[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[tscale][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;
 
}