vdisplay.c

seismic software,very useful

    getparfloat("o1", &o1);
    getparfloat("o2", &o2);
    getparstring("title", (char**)&title);
    data = (unsigned char *) malloc(n1 * n2 * sizeof(char) );

    frame = 0;

NextFrame:

    frame = (frame+1) % n3;

    sprintf(name, "LINE %d", (int) o3+frame*10 );
    XStoreName(display, window, name);

    position = frame * n1 * n2;

    lseek(0, position, 0);
    read(0, data, n1 * n2);
    width1 = width - 2 * hmargin;
    height1 = height - vmargin - VMARGIN;
    size = MAXWIDTH * height;
    idata = (unsigned char *) malloc(size);
    image =
        XCreateImage(display, visual, 8, ZPixmap, 0, (char *) idata, MAXWIDTH,
                     MAXHEIGHT, 8, 0);
    XFlush(display);
#if 0
    fprintf(stderr, "sbin=%d vbin=%d n1=%d n2=%d width=%d height=%d\n", sbin,
            vbin, n1, n2, width, height);
#endif

    if( annotate){
        XSelectInput(display, window, 
        ExposureMask
       |StructureNotifyMask
       |EnterWindowMask
       |ButtonPressMask
       |KeyPressMask
       |PointerMotionMask );
    }else{
        XSelectInput(display, window, ExposureMask|StructureNotifyMask);
    }

    XSetBackground(display, gc, BlackPixel(display, screen));
    XSetForeground(display, gc, WhitePixel(display, screen));

    for( i = 0; i < size; i++){
        idata[i] = cbase;
    }

    for( j = 0; j < width; j++ ){
        k = ((j * vbin) / (width - 1)) * sbin + sbin - 1 + cbase;

        for( i = 0; i < VMARGIN; i++ ){
            idata[i * MAXWIDTH + j] = k;
        }
    }

    for( i = 0; i < height1; i++ ){
        k = fk = (float) (i * n1) / (float) (height1 - 1);
        k2 = fk - k;
        k1 = 1. - k2;

        for( j = 0; j < width1; j++ ){
            m = fm = (float) (j * n2) / (float) (width1 - 1);
            m2 = fm - m;
            m1 = 1. - m2;

/*--------------------- dead code ------------------------------------*\
                        idata[(i+VMARGIN)*MAXWIDTH+j+hmargin] = cbase +
                                k1*m1*data[m*n1+k] +
                                k2*m1*data[m*n1+k+1] +
                                k1*m2*data[m*n1+k+n1] +
                                k2*m2*data[m*n1+k+n1+1];
\*--------------------- dead code ------------------------------------*/

            idata[(i + VMARGIN) * MAXWIDTH + j + hmargin] =
                cbase + data[m * n1 + k];
        }
    }

    XPutImage(display, window, gc, image, 0, 0, 0, 0, width, height);

    if( annotate ){

        for( i = 0, k = -1000; i < vbin; i++ ){
            j = (i * width) / vbin;

            if( (j - k) > CSPACE ){
                sprintf(text, "%-d", (int) vclip[i]);
                XDrawImageString(display, window, gc, j, VMARGIN, text,
                                 strlen(text));
                k = j;
            }
        }
        nbin = findbin(bin, height1 / 50, o1, o1 + n1 * d1);

        for( i = 0; i < nbin; i++ ){
            j = ((bin[i] - o1) * height1) / (d1 * n1);
            sprintf(text, "%g", bin[i]);
            XDrawImageString(display, window, gc, 0, j + VMARGIN + 5, text,
                             strlen(text));
            XDrawImageString(display, window, gc, width1 + hmargin,
                             j + VMARGIN + 5, text, strlen(text));
        }
        nbin = findbin(bin, width1 / 100, o2, o2 + n2 * d2);

        for( i = 0; i < nbin; i++ ){
            j = ((bin[i] - o2) * width1) / (d2 * n2);
            sprintf(text, "%g", bin[i]);
            XDrawImageString(display, window, gc, j + hmargin, VMARGIN + 10,
                             text, strlen(text));
            XDrawImageString(display, window, gc, j + hmargin,
                             height1 + VMARGIN, text, strlen(text));
        }
    }

    sprintf(text, "%s", title);
    XDrawImageString(display, window, gc, 0, height - 1, text, strlen(text));

    XMapWindow(display, window);
    XFlush(display);


    while (1 ){

        XNextEvent(display, &event);

        switch (event.type ){

           case ButtonPress:
              goto NextFrame;
              break;

           case ConfigureNotify:

            width = event.xconfigure.width;
            height = event.xconfigure.height;
            width1 = width - 2 * hmargin;
            height1 = height - vmargin - VMARGIN;
            size = MAXWIDTH * height;


            /*-----------------------*/
            /* initialize background */
            /*-----------------------*/

            for( i = 0; i < size; i++ ){
                idata[i] = BlackPixel(display, screen);
            }


            /*---------------*/
            /* draw colorbar */
            /*---------------*/

            for( j = 0; j < width; j++ ){
                k = ((j * vbin) / (width - 1)) * sbin + sbin - 2 + cbase;

                for( i = 0; i < VMARGIN; i++ ){
                    idata[i * MAXWIDTH + j] = k;
                }
            }


/*--------------------------------------------------------------------*\
                            redraw image 

   This logic is seriously flawed on several counts:

   it resizes the image by decimation-replication based on roundoff
   
   it fails to bounds check the data leading to an assortment of errors
\*--------------------------------------------------------------------*/


            for( i = 0; i < height1; i++ ){
                k = (i * n1) / (height1 - 1);

                for( j = 0; j < width1; j++ ){
                    m = (j * n2) / (width1 - 1);
                    idata[(i + VMARGIN) * MAXWIDTH + j + hmargin] =
                        data[m * n1 + k] + cbase;
                }
            }


            /* fall through */

          case Expose:

            XPutImage(display, window, gc, image, 0, 0, 0, 0, width, height);

            if( annotate ){

                for( i = 0, k = -1000; i < vbin; i++ ){
                    j = (i * width) / vbin;

                    if( (j - k) > CSPACE ){
                        sprintf(text, "%-d", (int) vclip[i]);
                        XDrawImageString(display, window, gc, j, VMARGIN, text,
                                         strlen(text));
                        k = j;
                    }
                }
                nbin = findbin(bin, height1 / 50, o1, o1 + n1 * d1);

                for( i = 0; i < nbin; i++ ){
                    j = ((bin[i] - o1) * height1) / (d1 * n1);
                    sprintf(text, "%g", bin[i]);
                    XDrawImageString(display, window, gc, 0, j + VMARGIN + 5,
                                     text, strlen(text));
                    XDrawImageString(display, window, gc, width1 + hmargin,
                                     j + VMARGIN + 5, text, strlen(text));
                }
                nbin = findbin(bin, width1 / 100, o2, o2 + n2 * d2);

                for( i = 0; i < nbin; i++ ){
                    j = ((bin[i] - o2) * width1) / (d2 * n2);
                    sprintf(text, "%g", bin[i]);
                    XDrawImageString(display, window, gc, j + hmargin,
                                     VMARGIN + 10, text, strlen(text));
                    XDrawImageString(display, window, gc, j + hmargin,
                                     height1 + VMARGIN, text, strlen(text));
                }
            }
            sprintf(text, "%s", title);
            XDrawImageString(display, window, gc, 0, height - 1, text,
                             strlen(text));
            break;

           case MotionNotify:
          
            if( idata[event.xmotion.y * MAXWIDTH + event.xmotion.x] < NXCOLOR 
             && idata[event.xmotion.y * MAXWIDTH + event.xmotion.x] > 0 ){

                sprintf(text, "%s " ,title );
                sprintf(foo, "LINE=%-5d " ,o3 );
                strcat( text ,foo );
                sprintf(foo, "X=%-5d  " ,(int) (o2 + (event.xmotion.x * d2 * n2) / width) );
                strcat( text ,foo );
                sprintf(foo, "Z=%-5d " ,(int) (o1 + ((event.xmotion.y - VMARGIN) * d1 * n1) / (height - 2 * VMARGIN)) );
                strcat( text ,foo );
    
                sprintf(foo, "VEL=%-5d", (int) clip[idata[event.xmotion.y * MAXWIDTH + event.xmotion.x]]);
                strcat( text ,foo );
                XDrawImageString(display, window, gc, 0, height - 1, text, strlen(text));
           }
            break;
        }
        XFlush(display);
    }
}

/*--------------------------------------------------------------------*\
\*--------------------------------------------------------------------*/
int      findbin(float *bin, int nbin, float low, float high)
{
    float    interval;
    int      nbin1;

    interval = (high - low) / nbin;
    interval = pow(10., rint(log10(interval)));

    if( (nbin1 = findbin2(bin, nbin, low, high, 0.2 * interval)) > 0 ){
        return (nbin1);
    }

    if( (nbin1 = findbin2(bin, nbin, low, high, 0.25 * interval)) > 0 ){
        return (nbin1);
    }

    if( (nbin1 = findbin2(bin, nbin, low, high, 0.4 * interval)) > 0 ){
        return (nbin1);
    }

    if( (nbin1 = findbin2(bin, nbin, low, high, 0.5 * interval)) > 0 ){
        return (nbin1);
    }

    if( (nbin1 = findbin2(bin, nbin, low, high, 0.75 * interval)) > 0 ){
        return (nbin1);
    }

    if( (nbin1 = findbin2(bin, nbin, low, high, 1.0 * interval)) > 0 ){
        return (nbin1);
    }

    if( (nbin1 = findbin2(bin, nbin, low, high, 2.0 * interval)) > 0 ){
        return (nbin1);
    }

    if( (nbin1 = findbin2(bin, nbin, low, high, 5.0 * interval)) > 0 ){
        return (nbin1);
    }
    return (0);
}

/*--------------------------------------------------------------------*\
\*--------------------------------------------------------------------*/

int      findbin2(float *bin, int nbin, float low, float high, float interval)
{
    int      ilow, ihigh, i;

    ilow = ceil(low / interval);
    ihigh = floor(high / interval);

    if( ihigh - ilow + 2 > nbin ){
        return (0);
    }

    for( i = 0; ilow <= ihigh; i++, ilow++ ){
        bin[i] = ilow * interval;
    }
    return (i);
}