pick.c

seismic software,very useful

    if( PlaneType(plane) == RENDER_HORZ ){
        hskew = PlaneSkew(plane);

    } else {
        vskew = PlaneSkew(plane);
    }

    for( ipick = 0; ipick < pickline->npick; ipick++ ){
        x = MapInverse(PlaneHmap(plane),
                       pickline->index[ipick][AxisDir
                                              (MapAxis(PlaneHmap(plane)))]);
        if( PlaneType(plane) == RENDER_VERT ){
            x = MapSize(PlaneHmap(plane)) - x;
        }
        y = MapInverse(PlaneVmap(plane),
                       pickline->index[ipick][AxisDir
                                              (MapAxis(PlaneVmap(plane)))]);
        if( x != NO_INDEX && y != NO_INDEX ){
            x1 = x + PlaneH0(plane) + hskew * (MapSize(PlaneVmap(plane)) - y);
            y1 = y + PlaneV0(plane) + vskew * (PlaneNH(plane) - x);
            if( !ipick ){
                DrawLine(x1 - 1, y1 - 1, x1, y1, draw);

            } else if( x0 != NO_INDEX && y0 != NO_INDEX ){
                x2 = x0 + PlaneH0(plane) + hskew *
                    (MapSize(PlaneVmap(plane)) - y0);
                y2 = y0 + PlaneV0(plane) + vskew * (PlaneNH(plane) - x0);
                DrawLine(x1, y1, x2, y2, draw);
            }
        }
        x0 = x;
        y0 = y;
    }
}

/*--------------------------------------------------------------------*\
   draw all pick sets
\*--------------------------------------------------------------------*/

void     PickDrawAll(int draw)
{

    int      iset;

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

        if( picklist[iset] ){
            PickDraw(picklist[iset], draw);
        }
    }
}

/*--------------------------------------------------------------------*\
   read pick file
\*--------------------------------------------------------------------*/

void     PickRead(void)
{

    FILE    *fd;
    FILE    *fopen(const char *, const char *);

    extern Data data;
    string   dummy;
    string   line;
    int      iset = 0;
    int      i;
    float    value[DATA_NAXIS];
    Message  message;
    cwp_String str;

    if( !data ){
        return;
    }

    if( getparstring ("annotate", &str) == 0 ){
        return;
    }

    strcpy( pickfile ,str );

    if( (fd = fopen(pickfile, "r")) == NULL ){
        UIMessage("cant open pick file");
        return;
    }

    fgets(line, sizeof(line), fd);

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

    int      n1;
    int      n2;
    int      n3;
    int      n4;
    int      n5;

    sscanf ( line,"%s %d %d %d %d %d",dummy,&n1,&n2,&n3,&n4,&n5 );
    if(  n1 != AxisSize( DataAxis( data,DATA_AXIS1 ) )
     || n2 != AxisSize( DataAxis( data,DATA_AXIS2 ) ) 
     || n3 != AxisSize( DataAxis( data,DATA_AXIS3 ) ) 
     || n4 != AxisSize( DataAxis( data,DATA_AXIS4 ) ) 
     || n5 != AxisSize( DataAxis( data,DATA_AXIS5 ) ) ){
            UIMessage ( "pick file wrong shape" );
            return;
    }

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

    fgets(line, sizeof(line), fd);

    while (fgets(line, sizeof(line), fd) != NULL ){

        if( !strncmp(line, "Pick#", 5) ){
            iset++;

            {
                extern int _alloc;

                picklist[iset] =
                    (PickLine) malloc((1) * sizeof(picklist[iset][0]));
                    _alloc += (1) * sizeof(picklist[iset][0]);
                if( picklist[iset] == 0 ){
                    err
                        ("cant allocate %d bytes for picklist[iset] ; %d already allocated",
                         (1) * sizeof(picklist[iset][0]), _alloc);
                }
                if( memwatch ){
                    (void) printf("malloc %s=%d\n", "picklist[iset] ",
                                  (1) * sizeof(picklist[iset][0]));
                }
            };
            sscanf(line, "%s %s %s %d %d %d %d %d %d", dummy, dummy, dummy,
                   &PICKDIR(picklist[iset]->, AXIS_DOWN),
                   &PICKDIR(picklist[iset]->, AXIS_ACROSS),
                   &PICKDIR(picklist[iset]->, AXIS_DEEP),
                   &PICKDIR(picklist[iset]->, AXIS_4D),
                   &PICKDIR(picklist[iset]->, AXIS_5D),
                   &PICKDIR(picklist[iset]->, AXIS_5D));
            picklist[iset]->npick = 0;

        } else {

            if( picklist[iset]->npick < NPICK ){
                sscanf(line, "%f %f %f %f %f %f",
                       &value[DATA_AXIS1],
                       &value[DATA_AXIS2],
                       &value[DATA_AXIS3],
                       &value[DATA_AXIS4],
                       &value[DATA_AXIS5], &value[DATA_VALUE]);

                for( i = 1; i < DATA_NAXIS; i++ ){
                    picklist[iset]->index[picklist[iset]->npick][i] =
                        AxisIndex(DataAxis(data, i), value[i]);
                }

                picklist[iset]->index[picklist[iset]->npick][DATA_VALUE] =
                    value[DATA_VALUE];
                picklist[iset]->npick++;
            }
        }
    }

    fclose(fd);
    sprintf(message, "%d picklines read from %s", iset, pickfile);
    UIMessage(message);
}

#ifdef UNUSED_CODE

/*--------------------------------------------------------------------*\
   write pick file
\*--------------------------------------------------------------------*/

void     PickWrite(void)
{

    FILE    *fd;
    Message  message;

    extern Data data;
    extern FILE *outstream;

    int      ipick;
    int      isave;
    int      iset;

    if( picklist[0] == 0 ){
        return;
    }

    if( !strcmp(pickfile, "stdio") ){
        fd = outstream;

    } else {
        fd = fopen(pickfile, "w");
    }

    fseek(fd, 0L, SEEK_SET);
    fprintf(fd, "Picks for dataset: %s\n", DataTitle(data));

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

        fprintf ( fd,"Dimensions: %d %d %d %d %d\n",
                AxisSize( DataAxis( data,DATA_AXIS1 ) ),
                AxisSize( DataAxis( data,DATA_AXIS2 ) ),
                AxisSize( DataAxis( data,DATA_AXIS3 ) ),
                AxisSize( DataAxis( data,DATA_AXIS4 ) ),
                AxisSize( DataAxis( data,DATA_AXIS5 ) ) );

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

    fprintf(fd, "%9s: %9s: %9s: %9s: %9s: %9s:\n",
            AxisLabel(DataAxis(data, DATA_AXIS1)),
            AxisLabel(DataAxis(data, DATA_AXIS2)),
            AxisLabel(DataAxis(data, DATA_AXIS3)),
            AxisLabel(DataAxis(data, DATA_AXIS4)),
            AxisLabel(DataAxis(data, DATA_AXIS5)),
            AxisLabel(DataAxis(data, DATA_AXIS0)));

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

        if( picklist[iset] && picklist[iset]->npick > 0 ){
            fprintf(fd, "Pick# %d axis# %d %d %d %d %d %s\n",
                    isave++,
                    PICKDIR(picklist[iset]->, AXIS_DOWN),
                    PICKDIR(picklist[iset]->, AXIS_ACROSS),
                    PICKDIR(picklist[iset]->, AXIS_DEEP),
                    PICKDIR(picklist[iset]->, AXIS_4D),
                    PICKDIR(picklist[iset]->, AXIS_5D),
                    AxisScript(DataAxis
                               (data, PICKDIR(picklist[iset]->, AXIS_DEEP)),
                               picklist[iset]->index[AXIS_DEEP]));

            for( ipick = 0; ipick < picklist[iset]->npick; ipick++ ){
                fprintf(fd, "%10g %10g %10g %10g %10g %10g\n",
                        AxisValue(DataAxis(data, DATA_AXIS1),
                                  picklist[iset]->index[ipick][DATA_AXIS1]),
                        AxisValue(DataAxis(data, DATA_AXIS2),
                                  picklist[iset]->index[ipick][DATA_AXIS2]),
                        AxisValue(DataAxis(data, DATA_AXIS3),
                                  picklist[iset]->index[ipick][DATA_AXIS3]),
                        AxisValue(DataAxis(data, DATA_AXIS4),
                                  picklist[iset]->index[ipick][DATA_AXIS4]),
                        AxisValue(DataAxis(data, DATA_AXIS5),
                                  picklist[iset]->index[ipick][DATA_AXIS5]),
                        (float) picklist[iset]->index[ipick][DATA_VALUE]);
            }
        }
    }
    fclose(fd);
    sprintf(message, "%d pick lines save in %s", isave, pickfile);
    UIMessage(message);
}

#endif

/*--------------------------------------------------------------------*\
   remove set from pick list
\*--------------------------------------------------------------------*/

void     PickClear(PickLine pickline)
{

    int      iset;

    if( !pickline ){
        return;
    }

    PickDraw(pickline, ERASE);

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

        if( pickline == picklist[iset] ){

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

/*--------------------------------------------------------------------*\
   clear current pick
\*--------------------------------------------------------------------*/

void     PickClear0(void)
{

    PickClear(lastpick);
}

/*---------------------- unreferenced code ---------------------------*\
   set pick frame

void PickSetFrame( int index ){

    PickLine pickline;
    int      iset;

    if(  index < 0 || index > PickSize(  ) ){
        return;
    }

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

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

        if(  index < 0 ){
            pickline = picklist[iset];
            break;
        }
    }
    if(  iset == PICKNLIST ){
        return;
    }

    ViewSetMovie( PICKDIR( pickline-> ,AXIS_DEEP ) );
    ViewSetFrame( pickline->index[AXIS_DEEP] ,FRAME_ACTUAL );

    PickDraw( pickline ,DRAW );

}
\*---------------------- unreferenced code ---------------------------*/

/*--------------------------------------------------------------------*\
   print a list of picks
\*--------------------------------------------------------------------*/

void     PickListInfo(void)
{

    int      iset;

    printf("Pick list:\n");

    for( iset = -1; iset < PICKNLIST; iset++ ){

        if( picklist[iset] ){
            printf("dir=%d frame=%d\n",
                   PICKDIR(picklist[iset]->, AXIS_DEEP),
                   PICKFRAME0(picklist[iset]->, AXIS_DEEP));
        }
    }
}

/*--------------------------------------------------------------------*\
   save pick parameters
\*--------------------------------------------------------------------*/

void     PickSavePar(void)
{

    Message  message;
    extern PickLine lastpick;

    if( !lastpick ){
        return;
    }

    sprintf(message, "Pick: nset=%d pickdir=%d pickframe=%d npick=%d pick=%s",
            PickSize()
            , PICKDIR(lastpick->, AXIS_DEEP)
            , PICKFRAME0(lastpick->, AXIS_DEEP)
            , lastpick->npick, pickfile);

    UISaveMessage(message);
}

/*--------------------------------------------------------------------*\
   returns two picks are in same frame
\*--------------------------------------------------------------------*/

int      PickSameFrame(PickPoint pick1, PickPoint pick2)
{

    return ((pick1->iaxis[AXIS_DOWN] == pick2->iaxis[AXIS_DOWN]) &&
            (pick1->iaxis[AXIS_ACROSS] == pick2->iaxis[AXIS_ACROSS]) &&
            (pick1->iaxis[AXIS_DEEP] == pick2->iaxis[AXIS_DEEP]) &&
            (pick1->iaxis[AXIS_4D] == pick2->iaxis[AXIS_4D]) &&
            (pick1->iaxis[AXIS_5D] == pick2->iaxis[AXIS_5D]) &&
            (pick1->index[pick1->iaxis[AXIS_DEEP]] ==
             pick2->index[pick2->iaxis[AXIS_DEEP]])
            && (pick1->index[pick1->iaxis[AXIS_4D]] ==
                pick2->index[pick2->iaxis[AXIS_4D]])
            && (pick1->index[pick1->iaxis[AXIS_5D]] ==
                pick2->index[pick2->iaxis[AXIS_5D]]));
}

/*--------------------------------------------------------------------*\
   returns two picks are same direction
\*--------------------------------------------------------------------*/

int      PickSameDir(PickPoint pick1, PickPoint pick2)
{

    return ((pick1->iaxis[AXIS_DEEP] == pick2->iaxis[AXIS_DEEP]) &&
            (pick1->iaxis[AXIS_4D] == pick2->iaxis[AXIS_4D]) &&
            (pick1->iaxis[AXIS_5D] == pick2->iaxis[AXIS_5D]));
}

/*--------------------------------------------------------------------*\
   returns direction of shared coordinate: 0 ,pick->iaxis[1] or
   pick->iaxis[2]
\*--------------------------------------------------------------------*/

int      PickSharedDir(PickPoint pick1, PickPoint pick2)
{

    return (PickSameFrame(pick1, pick2) *
            (((pick1->index[pick1->iaxis[AXIS_DOWN]] ==
               pick2->index[pick2->iaxis[AXIS_DOWN]]) *
              pick1->iaxis[AXIS_DOWN]) +
             ((pick1->index[pick1->iaxis[AXIS_ACROSS]] ==
               pick2->index[pick2->iaxis[AXIS_ACROSS]]) *
              pick1->iaxis[AXIS_ACROSS])));
}

/*--------------------------------------------------------------------*\
   return non-zero if a is between b and c; angle a-b-c < 90; a is
   nearer to b
\*--------------------------------------------------------------------*/
int      PickBetween(int *a, int *b, int *c)
{
    int      i;
    int      ra = 0;
    int      rb = 0;
    int      rc = 0;

    for( i = 0; i < DATA_NAXIS; i++ ){
        ra += (b[i] - c[i]) * (b[i] - c[i]);
        rb += (a[i] - c[i]) * (a[i] - c[i]);
        rc += (a[i] - b[i]) * (a[i] - b[i]);
    }
    return (rb < (ra + rc));
}