xwpick.c

seismic software,very useful

				/* if new box has zero width or height */
				} else {
			
					/* calculate new box parameters */
					zoomBox(x,y,width,height,
						xb,yb,wb,hb,
						x2begb,x2endb,
						x1begb,x1endb,
						&x2begb,&x2endb,
						&x1begb,&x1endb);
				}

				/* clear background */
                        	if(savebg) XSetWindowBackground(dpy,win,0L);

				/* clear area and force an expose event */
				XClearArea(dpy,win,0,0,0,0,True);
			
				/* note that image is out of date */
				imageOutOfDate = 1;
			
			/* else if 2nd button down: display mouse coords */
			} else if (event.xbutton.button==Button2) {

				showloc = 1;
				xMouseLoc(dpy,win,event,style,showloc,
					  x,y,width,height,x1begb,x1endb,
					  x2begb,x2endb,p2beg,p2end);

			/* else if 3rd button down: track and pick */
                        } else if (event.xbutton.button==Button3) {
				pkey = 0;
				xMousePicks(dpy,win,event,style,
					 mpcolor,
                               	         mpicksfp, x,y,width,height,
                               	         x1begb,x1endb,x2begb,x2endb,
                                       	 pcard,ppos,porder,x1picks,x2picks,
                                         x1pscale,x2pscale,&npicks,gci,pkey,
                                         &savebg,p2beg,p2end);

			} else {
				continue;
			}

		/* else if pointer has moved */
		} else if (event.type==MotionNotify) {
			
			/* if button2 down, show mouse location */
			if (showloc)
				xMouseLoc(dpy,win,event,style,True,
					x,y,width,height,x1begb,x1endb,
					x2begb,x2endb,p2beg,p2end);

		/* else if button2 released, stop tracking */
		} else if (event.type==ButtonRelease &&
			   event.xbutton.button==Button2) {
			showloc = 0;
		}

	} /* end of event loop */

	/* close connection to X server */
	XCloseDisplay(dpy);
	return EXIT_SUCCESS;
}
			
/* update parameters associated with zoom box */
static void zoomBox (int x, int y, int w, int h, 
	int xb, int yb, int wb, int hb,
	float x1, float x2,
	float y1, float y2,
	float *x1b, float *x2b,
	float *y1b, float *y2b)
{
	/* if width and/or height of box are zero, just copy values */
	if (wb==0 || hb==0) {
		*x1b = x1; *x2b = x2;
		*y1b = y1; *y2b = y2;
		return;		
	} 
	
	/* clip box */
	if (xb<x) {
		wb -= x-xb;
		xb = x;
	}
	if (yb<y) {
		hb -= y-yb;
		yb = y;
	}
	if (xb+wb>x+w) wb = x-xb+w;
	if (yb+hb>y+h) hb = y-yb+h;	
	
	/* determine box limits */
	*x1b = x1+(xb-x)*(x2-x1)/w;
	*x2b = x1+(xb+wb-x)*(x2-x1)/w;
	*y1b = y1+(yb-y)*(y2-y1)/h;
	*y2b = y1+(yb+hb-y)*(y2-y1)/h;
}

/* return pointer to new image bitmap of rasterized wiggles */
static XImage *newBitmap (Display *dpy, int width, int height,
	int n1, float d1, float f1, int n2, float *x2, float *z,
	float x1beg, float x1end, float x2beg, float x2end,
	float xcur, float clip, int wt, int va,
	float *p2begp, float *p2endp)
{
	int widthpad,nbpr,i1beg,i1end,if1r,n1r,b1fz,b1lz,i2,i,n2in;
	float x2min,x2max,p2beg,p2end,bscale,boffset,bxcur,bx2;
	unsigned char *bits;
	int scr=DefaultScreen(dpy);
        

	/* determine bitmap dimensions and allocate space for bitmap */
	widthpad = (1+(width-1)/(BitmapPad(dpy)/8))*BitmapPad(dpy)/8;
	nbpr = 1+(widthpad-1)/8;
	bits = ealloc1(nbpr*height,sizeof(unsigned char));
	for (i=0; i<nbpr*height; ++i) bits[i] = 0;

	/* determine number of traces that fall within axis 2 bounds */
	x2min = MIN(x2beg,x2end);
	x2max = MAX(x2beg,x2end);
	for (i2=0,n2in=0; i2<n2; i2++)
		if (x2[i2]>=x2min && x2[i2]<=x2max) n2in++;

	/* determine pads for wiggle excursion along axis 2 */
	xcur = fabs(xcur);
	if (n2in>1) xcur *= (x2max-x2min)/(n2in-1);
	p2beg = (x2end>x2beg)?-xcur:xcur;
	p2end = (x2end>x2beg)?xcur:-xcur;

	/* determine scale and offset to map x2 units to bitmap units */
	bscale = (width-1)/(x2end+p2end-x2beg-p2beg);
	boffset = -(x2beg+p2beg)*bscale;
	bxcur = xcur*bscale;

	/* adjust x1beg and x1end to fall on sampled values */
	i1beg = NINT((x1beg-f1)/d1);
	i1beg = MAX(0,MIN(n1-1,i1beg));
	x1beg = f1+i1beg*d1;
	i1end = NINT((x1end-f1)/d1);
	i1end = MAX(0,MIN(n1-1,i1end));
	x1end = f1+i1end*d1;

	/* determine first sample and number of samples to rasterize */
	if1r = MIN(i1beg,i1end);
	n1r = MAX(i1beg,i1end)-if1r+1;

	/* determine bits corresponding to first and last samples */
	b1fz = (x1end>x1beg)?0:height-1;
	b1lz = (x1end>x1beg)?height-1:0;

	/* rasterize traces */
	for (i2=0; i2<n2; i2++,z+=n1) {

		/* skip traces not in bounds */
		if (x2[i2]<x2min || x2[i2]>x2max) continue;

		/* determine bitmap coordinate of trace */
		bx2 = boffset+x2[i2]*bscale;

		/* rasterize one trace */
		rfwtva(n1r,&z[if1r],-clip,clip,va?0:clip,
			(int)(bx2-bxcur),(int)(bx2+bxcur),b1fz,b1lz,
			wt,nbpr,bits);
	}

/* !!! inserted by Z. Li to fix problem of SUN's display colormap different 
       from rs-6000's colormap !!! */ 
	for (i=0; i<nbpr*height; ++i) bits[i] = 255 - bits[i];
	
	/* return axis 2 pads */
	*p2begp = p2beg;  *p2endp = p2end;
	
	/* return pointer to image */
	return XCreateImage(dpy,DefaultVisual(dpy,scr),
		1,XYBitmap,0,bits,widthpad,height,BitmapPad(dpy),nbpr);
}	

void xMouseLoc(Display *dpy, Window win, XEvent event, int style, Bool show,
	int x, int y, int width, int height,
	float x1begb, float x1endb, float x2begb, float x2endb,
	float p2beg, float p2end)
{
	XGCValues values;
	static XFontStruct *fs=NULL;
	static XCharStruct overall;
	static GC gc;
	int dummy,xoffset=10,yoffset=10;
	float x1,x2;
	char string[256];

	/* if first time, get font attributes and make gc */
	if (fs==NULL) {
		fs = XLoadQueryFont(dpy,"fixed");
		gc = XCreateGC(dpy,win,0,&values);
		XSetFont(dpy,gc,fs->fid);
		overall.width = 1;
		overall.ascent = 1;
		overall.descent = 1;
	}

	/* erase previous string */
	XClearArea(dpy,win,xoffset,yoffset,
		overall.width,overall.ascent+overall.descent,False);

	/* if not showing, then return */
	if (!show) return;

	/* convert mouse location to (x1,x2) coordinates */
	if (style==NORMAL) {
		x1 = x1begb+(x1endb-x1begb)*(event.xmotion.x-x)/width;
		x2 = p2end+x2endb+(p2beg+x2begb-x2endb-p2end)*
			(event.xmotion.y-y)/height;
	} else {
		x1 = x1begb+(x1endb-x1begb)*(event.xmotion.y-y)/height;
		x2 = p2beg+x2begb+(p2end+x2endb-x2begb-p2beg)*
			(event.xmotion.x-x)/width;
	}

	/* draw string indicating mouse location */
	sprintf(string,"(%0.3g,%0.3g)",x1,x2);
	XTextExtents(fs,string,strlen(string),&dummy,&dummy,&dummy,&overall);
	XDrawImageString(dpy,win,gc,xoffset,yoffset+overall.ascent,
		string,strlen(string));
}

void xMousePrint(Display *dpy, Window win, XEvent event, int style,
        FILE *mpicksfp, int x, int y, int width, int height,
        float x1begb, float x1endb, float x2begb, float x2endb,
        char *pcard, int ppos, int porder, float *x1picks, float *x2picks,
        float x1pscale, float x2pscale, int npicks, int fex)
{
        int ic,ip,np;
        int p1,p2;
	static int first=1;

        /* output picks */
	if(first==1 && fex==0) {
		first = 999;
        	fprintf(mpicksfp,
"1---5---10---15---20---25---30---35---40---45---50---55---60---65---70\n");
        	fprintf(mpicksfp,
"pcard      ppos       px1  py1  px2  py2  px3  py3  px4  py4  px5  py5\n");
        	fprintf(mpicksfp,"\n");
	}
        for (ic=0;ic<(npicks+4)/5;ic++) {
           if( (ic+1)*5 < npicks ) {
              np = 5; 
           }
           else {
              np = npicks - ic*5;
           }
           fprintf(mpicksfp, "%-5s%10d     ",pcard,ppos);
           for(ip=0;ip<np;ip++) {
              if(porder==0) {
                 p1 = x1picks[ic*5+ip]*x1pscale;
                 p2 = x2picks[ic*5+ip]*x2pscale;
              } else {
                 p1 = x2picks[ic*5+ip]*x2pscale;
                 p2 = x1picks[ic*5+ip]*x1pscale;
              }
              fprintf(mpicksfp,"%5d%5d",p1,p2);
           }
           fprintf(mpicksfp,"\n");
        }

        fflush(mpicksfp);
}


void xMousePicks(Display *dpy, Window win, XEvent event, int style,
	char *mpcolor,
        FILE *mpicksfp, int x, int y, int width, int height,
        float x1begb, float x1endb, float x2begb, float x2endb,
        char *pcard, int ppos, int porder, float *x1picks, float *x2picks,
        float x1pscale, float x2pscale, int *npicks, GC gc, int pkey, 
	int *savebg, float p2beg, float p2end)
{
        float x1,x2;
        int ipicks;
        int xx1,yy1,xx2,yy2,temp,ip;
        int dismin,dis;
        int ipmin, ipins;
        static int fs=1;
	GC gcp;
        XGCValues *values;
        XColor scolor,ecolor;
        XWindowAttributes wa;
        Colormap cmap;
        int scr;


        /* save bitmap of window to background for retrival */
        if(*savebg) {
                fg2bg(dpy,win);
	        *savebg = 0;
        }

        /* convert mouse location to (x1,x2) coordinates */
	if (style==NORMAL) {
		x1 = x1begb+(x1endb-x1begb)*(event.xmotion.x-x)/width;
		x2 = p2end+x2endb+(p2beg+x2begb-x2endb-p2end)*
			(event.xmotion.y-y)/height;
	} else {
		x1 = x1begb+(x1endb-x1begb)*(event.xmotion.y-y)/height;
		x2 = p2beg+x2begb+(p2end+x2endb-x2begb-p2beg)*
			(event.xmotion.x-x)/width;
	}

        /* save to x1picks and x2picks */
        if( pkey == 0 ) {
                ipicks = *npicks;
                x1picks[ipicks] = x1;
                x2picks[ipicks] = x2;
                *npicks = *npicks + 1;
        /* delete nearest picks from x1picks and x2picks*/
        } else if ( pkey==1 && *npicks > 0 ) {
                ipicks = *npicks;
		dismin=(x1-x1picks[0])*(x1-x1picks[0])+
                       (x2-x2picks[0])*(x2-x2picks[0]);
                ipmin = 0;
                for(ip=1;ip<ipicks;ip++) {
                        dis=(x1-x1picks[ip])*(x1-x1picks[ip])+
                                (x2-x2picks[ip])*(x2-x2picks[ip]);
                        if(dis<dismin) {
                                dismin = dis;
                                ipmin = ip;
                        }
                }
                ipicks = ipicks - 1;
                for(ip=ipmin;ip<ipicks;ip++) {
                        x1picks[ip] = x1picks[ip+1];
                        x2picks[ip] = x2picks[ip+1];
                }
                *npicks = ipicks;
        /* insert the pick into x1picks and x2picks */
        } else if ( pkey==2 ) {
                ipicks = *npicks;
                if (porder==0) {
                        dismin=(x1-x1picks[0])*(x1-x1picks[0]);
			ipmin = 0;
                        for(ip=1;ip<ipicks;ip++) {
                                dis=(x1-x1picks[ip])*(x1-x1picks[ip]);
                                if(dis<dismin) {
                                        dismin = dis;
                                        ipmin = ip;
                                }
                        }
                        if(x1>x1picks[ipmin]) {
                                ipins = ipmin+1;
                                ipicks +=1;
                                for(ip=ipicks;ip>ipins;ip--) {
                                        x1picks[ip] = x1picks[ip-1];
                                        x2picks[ip] = x2picks[ip-1];
                                }
                                x1picks[ipins] = x1;
                                x2picks[ipins] = x2;
                        } else if(x1<x1picks[ipmin]) {
                                ipins = ipmin;
                                ipicks +=1;
                                for(ip=ipicks;ip>ipins;ip--) {
                                        x1picks[ip] = x1picks[ip-1];
					x2picks[ip] = x2picks[ip-1];
                                }
                                x1picks[ipins] = x1;
                                x2picks[ipins] = x2;
                        }
                } else {
                        dismin=(x2-x2picks[0])*(x2-x2picks[0]);
                        ipmin = 0;
                        for(ip=1;ip<ipicks;ip++) {
                                dis=(x2-x2picks[ip])*(x2-x2picks[ip]);
                                if(dis<dismin) {
                                        dismin = dis;
                                        ipmin = ip;
                                }
                        }
                        if(x2>x2picks[ipmin]) {
                                ipins = ipmin+1;
				ipicks +=1;
                                for(ip=ipicks;ip>ipins;ip--) {
                                        x1picks[ip] = x1picks[ip-1];
                                        x2picks[ip] = x2picks[ip-1];
                                }
                                x1picks[ipins] = x1;
                                x2picks[ipins] = x2;
                        } else if(x2<x2picks[ipmin]) {
                                ipins = ipmin;
                                ipicks +=1;
                                for(ip=ipicks;ip>ipins;ip--) {
                                        x1picks[ip] = x1picks[ip-1];
                                        x2picks[ip] = x2picks[ip-1];
                                }
                                x1picks[ipins] = x1;
                                x2picks[ipins] = x2;
                        }
                }
                *npicks = ipicks;
        }
	/* delete all previous picks */
	if (pkey == 5) {
		ipicks = *npicks;
		for(ip=0;ip<ipicks;ip++) {
			x1picks[ip] = 0.;
			x2picks[ip] = 0.;
		}
		ipicks = 0;
		*npicks = 0;
	}
	ipicks = *npicks;
        /* draw lines between picks */
	if(ipicks>1) {
        	XClearWindow(dpy, win);
		/* get screen */
                scr = DefaultScreen(dpy);
                /* determine window's current colormap */
                XGetWindowAttributes(dpy,win,&wa);
                cmap = wa.colormap;
		gcp = XCreateGC(dpy,win,0,values);
                if (XAllocNamedColor(dpy,cmap,mpcolor,&scolor,&ecolor))
                        XSetForeground(dpy,gcp,ecolor.pixel);
                else
                        XSetForeground(dpy,gcp,1L);
                XSetLineAttributes(dpy,gcp,2,LineSolid,CapButt,JoinMiter);

                for(ip=1;ip<ipicks;ip++) {
                        if (style==NORMAL) {
                        xx1=(x1picks[ip-1]-x1begb)/(x1endb-x1begb)*width+x;
                        yy1=(x2picks[ip-1]-x2endb-p2end)/
			    (x2begb+p2beg-x2endb-p2end)*height+y;
                        xx2=(x1picks[ip]-x1begb)/(x1endb-x1begb)*width+x;
                        yy2=(x2picks[ip]-x2endb-p2end)/
			    (x2begb+p2beg-x2endb-p2end)*height+y;
                        } else {
                        yy1=(x1picks[ip-1]-x1begb)/(x1endb-x1begb)*height+y;
                        xx1=(x2picks[ip-1]-x2begb-p2end)/
		  	    (x2endb+p2end-x2begb-p2beg)*width+x;
                        yy2=(x1picks[ip]-x1begb)/(x1endb-x1begb)*height+y;
                        xx2=(x2picks[ip]-x2begb-p2beg)/
			    (x2endb+p2end-x2begb-p2beg)*width+x;
                        }
                        XDrawLine(dpy,win,gcp,xx1,yy1,xx2,yy2);
                }
		/* free resources before returning */
                XFreeGC(dpy,gcp);
        }
}