pick.c

seismic software,very useful

/*--------------------------------------------------------------------*\
   pick object code pick object contains screen pick, map axis, view
   configuration and picking
\*--------------------------------------------------------------------*/

#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>

#include "par.h"

#include "main.h"
#include "axis.h"
#include "data.h"
#include "color.h"
#include "draw.h"
#include "map.h"
#include "render.h"
#include "plane.h"
#include "view.h"
#include "pick.h"
#include "ui_menu.h"
#include "ui_window.h"

PickLine picklist[PICKNLIST];
PickLine lastpick = 0;
string   pickfile = "stdio";

#define PICKDIR( pick,axis )      pick iaxis[axis]
#define PICKFRAME0( pick,axis )   pick index[0][PICKDIR( pick,axis )]
#define PICKFRAME( pick,axis )    pick index[PICKDIR( pick,axis )]

/*--------------------------------------------------------------------*\
   initialize pick object
\*--------------------------------------------------------------------*/

void     PickInit(void)
{

    int      i;
    static int first = 1;

    for( i = 0; i < PICKNLIST; i++ ){

        if( !first ){

            if( picklist[i] ){
                free(picklist[i]);
                picklist[i] = 0;
                if( memwatch ){
                    printf("free %s\n", " picklist[i] ");
                }
            };
        }

        picklist[i] = 0;
    }

    PickRead();
    lastpick = 0;

    if( !first ){
        ViewDrawAll();
    }

    first = 0;
}

/*--------------------------------------------------------------------*\
   decode an x,y by shadow lookup
\*--------------------------------------------------------------------*/

void     PickDecode(int x, int y, PickPoint pick, int print)
{

    extern Render render;
    extern View view;
    extern Data data;

    Buffer   buffer;
    Message  message;
    Shadow_  shadow1;
    Shadow_  shadow;

    int      diff;
    int      i;
    int      iaxis;
    int      idiff;
    int      index1[DATA_NAXIS];
    int      isame;
    int      jaxis;
    float    val;

    /*--------------*/
    /* no pick made */
    /*--------------*/

    if( !render || !view || !data ){
        return;
    }

    /*-----------------*/
    /* no invalid pick */
    /*-----------------*/

    for( iaxis = 0; iaxis < DATA_NAXIS; iaxis++ ){
        pick->iaxis[iaxis] = NO_INDEX;
        pick->index[iaxis] = NO_INDEX;
    }

/*--------------------------------------------------------------------*\
   decode directions; using neighboring horizontal & vertical pixels
\*--------------------------------------------------------------------*/

    shadow = RenderShadowValue(render, x, y);

    if( (int) shadow == NO_INDEX ){
        return;
    }

    PickDecodeShadow(shadow, pick->index);

    for( i = 1;; i++ ){
        shadow1 = RenderShadowValue(render, x + i, y + i);

        if( (int) shadow1 == NO_INDEX ){
            break;
        }

        if( shadow1 == shadow ){
            continue;
        }

        PickDecodeShadow(shadow1, index1);

        for( jaxis = 1, diff = 0; jaxis < DATA_NAXIS; jaxis++ ){
            diff += (index1[jaxis] != pick->index[jaxis]);
        }

        if( diff == 2 ){
            break;
        }
    }

    if( (int) shadow1 == NO_INDEX || shadow1 == shadow || diff < 2 ){
        for( i = -1;; i-- ){

            shadow1 = RenderShadowValue(render, x + i, y + i);

            if( (int) shadow1 == NO_INDEX ){
                break;
            }

            if( shadow1 == shadow ){
                continue;
            }

            PickDecodeShadow(shadow1, index1);

            for( jaxis = 1, diff = 0; jaxis < DATA_NAXIS; jaxis++ ){
                diff += (index1[jaxis] != pick->index[jaxis]);
            }

            if( diff == 2 ){
                break;
            }
        }
    }

    for( iaxis = 1, isame = diff + 1, idiff = 1; iaxis < DATA_NAXIS; iaxis++ ){
        if( pick->index[iaxis] != index1[iaxis] ){
            pick->iaxis[idiff++] = iaxis;
        } else {
            pick->iaxis[isame++] = iaxis;
        }

    }

    pick->iaxis[AXIS_COLOR] = DATA_VALUE;

/*------------------------------- dead code --------------------------*\

        if(  diff != 2 ){
                printf ( "%d %d %d %d\n",shadow,i,shadow1,diff );
                for(  i=0; i<DATA_NAXIS; i++ ) printf ( "%7d: ",i ); printf ( "\n" );
                for(  i=0; i<DATA_NAXIS; i++ ) printf ( "%8d ",pick->iaxis[i] ); printf ( "\n" );
                for(  i=0; i<DATA_NAXIS; i++ ) printf ( "%8d ",pick->index[i] ); printf ( "\n" );
                for(  i=0; i<DATA_NAXIS; i++ ) printf ( "%8d ",index1[i] ); printf ( "\n" );
                printf ( "\n" );
                return;
                }
\*------------------------------ dead code ---------------------------*/

    buffer = DataBuffer(data);

    if( data->overlay_mode ){
        pick->index[DATA_VALUE] = buffer[shadow] ;
        val = buffer[shadow]/irint(data->gh.d4/data->gh.scale); 
        val *= data->gh.dcdp2 / data->gh.scale;
        val += data->gh.o5 / data->gh.scale;

    }else{
        pick->index[DATA_VALUE] = buffer[shadow] ;
        val =  AxisValue(DataAxis(data, DATA_VALUE), pick->index[DATA_VALUE]);

    }

    /*-----------------------*/
    /* print pick in message */
    /*-----------------------*/

    if( print ){

        sprintf(message,
                "dir=%s frame=%d,%d,%d %s=%g %s=%g %s=%g %s=%g %s=%g %s=%g",
                AxisLabel(DataAxis(data, pick->iaxis[AXIS_DEEP])),
                pick->index[pick->iaxis[AXIS_DEEP]],
                pick->index[pick->iaxis[AXIS_4D]],
                pick->index[pick->iaxis[AXIS_5D]],
                AxisLabel(DataAxis(data, DATA_AXIS1)),
                AxisValue(DataAxis(data, DATA_AXIS1), pick->index[DATA_AXIS1]),
                AxisLabel(DataAxis(data, DATA_AXIS2)),
                AxisValue(DataAxis(data, DATA_AXIS2), pick->index[DATA_AXIS2]),
                AxisLabel(DataAxis(data, DATA_AXIS3)),
                AxisValue(DataAxis(data, DATA_AXIS3), pick->index[DATA_AXIS3]),
                AxisLabel(DataAxis(data, DATA_AXIS4)),
                AxisValue(DataAxis(data, DATA_AXIS4), pick->index[DATA_AXIS4]),
                AxisLabel(DataAxis(data, DATA_AXIS5)),
                AxisValue(DataAxis(data, DATA_AXIS5), pick->index[DATA_AXIS5]),
                AxisLabel(DataAxis(data, DATA_VALUE)), val );
        UIMessage(message);
    }

    return;
}

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

void     PickDecodeShadow(Shadow_ shadow, int *index)
{

    extern Data data;
    int      iaxis;

    for( iaxis = DATA_NAXIS - 1; iaxis > 0; iaxis-- ){
        index[iaxis] = shadow / AxisStride(DataAxis(data, iaxis));
        shadow = shadow % AxisStride(DataAxis(data, iaxis));
    }
}

/*--------------------------------------------------------------------*\
   find a pick list
\*--------------------------------------------------------------------*/

PickLine PickFind(int dir3, int frame3, int dir4, int frame4, int dir5,
                  int frame5)
{

    int      iset;

    for( iset = 0; iset < PICKNLIST; iset++ ){
        if( picklist[iset]
            && dir3 == PICKDIR(picklist[iset]->, AXIS_DEEP)
            && frame3 == PICKFRAME0(picklist[iset]->, AXIS_DEEP)
            && (dir4 == NO_INDEX || (dir4 == PICKDIR(picklist[iset]->, AXIS_4D)
                                     && frame4 == PICKFRAME0(picklist[iset]->,
                                                             AXIS_4D)
                                     && dir5 == PICKDIR(picklist[iset]->,
                                                        AXIS_5D)
                                     && frame5 == PICKFRAME0(picklist[iset]->,
                                                             AXIS_5D))) ){
            return (lastpick = picklist[iset]);
        }
    }
    return (lastpick = 0);
}

/*--------------------------------------------------------------------*\
   return size of pick list
\*--------------------------------------------------------------------*/

int      PickSize(void)
{

    int      iset;
    int      nset;

    for( iset = 0, nset = 0; iset < PICKNLIST; iset++ ){

        if( picklist[iset] ){
            nset++;
        }

    }
    return (nset);
}

/*--------------------------------------------------------------------*\
   return pick axis
\*--------------------------------------------------------------------*/

int      PickAxis(void)
{

    int      iset;

    for( iset = 0; iset < PICKNLIST; iset++ ){

        if( picklist[iset] ){
            return (PICKDIR(picklist[iset]->, AXIS_DEEP));
        }

    }
    return (NO_INDEX);
}

/*--------------------------------------------------------------------*\
   return pick direction
\*--------------------------------------------------------------------*/

int      PickDir(PickLine pickline)
{

    if( !pickline ){
        return (NO_INDEX);

    } else {
        return (PICKDIR(pickline->, AXIS_DEEP));

    }
}

/*--------------------------------------------------------------------*\
   return pick count
\*--------------------------------------------------------------------*/

int      PickCount(PickLine pickline)
{

    if( !pickline ){
        return (NO_INDEX);

    } else {
        return (pickline->npick);

    }
}

/*--------------------------------------------------------------------*\
   return pick sample ipick and idim
\*--------------------------------------------------------------------*/

int      PickIndex(PickLine pickline, int ipick, int idim)
{

    if( !pickline ){
        return (NO_INDEX);
    }

    if( ipick < 0 || ipick >= NPICK ){
        return (NO_INDEX);
    }

    if( idim < 0 || idim >= DATA_NAXIS ){
        return (NO_INDEX);
    }

    return (pickline->index[ipick][idim]);
}

/*--------------------------------------------------------------------*\
   return pick list frame
\*--------------------------------------------------------------------*/

int      PickFrame(int ipick)
{

    int      iset;

    for( iset = 0; iset < PICKNLIST; iset++ ){

        if( picklist[iset] ){
            ipick--;
        }

        if( ipick < 0 ){
            return (PICKFRAME0(picklist[iset]->, AXIS_DEEP));
        }

    }

    return (NO_INDEX);
}

/*--------------------------------------------------------------------*\
   print information about pick object
\*--------------------------------------------------------------------*/

void     PickInfo(void)
{

    Message  message;
    PickLine pickline = 0;
    int      iset;

    pickline = lastpick;

    if( pickline == 0 ){

        for( iset = 0; iset < PICKNLIST; iset++ ){

            if( picklist[iset] ){
                pickline = picklist[iset];
            }
        }
    }

    if( pickline ){
        sprintf(message, "Pick: nset=%d dir=%d frame=%d npick=%d pickfile=%s",
                PickSize()
                , PICKDIR(pickline->, AXIS_DEEP)
                , PICKFRAME0(pickline->, AXIS_DEEP)
                , pickline->npick, pickfile);

    } else {
        sprintf(message, "Pick: nset=0 pickfile=%s", pickfile);

    }

    UIMessage(message);
}

/*--------------------------------------------------------------------*\
   add valid pick to current set
\*--------------------------------------------------------------------*/

void     PickAdd(int x, int y)
{

    int      iset;
    int      iaxis;
    PickPoint_ pick;
    PickLine pickline;

    /*-------------*/
    /* recover set */
    /*-------------*/