pik.c

seismic software,very useful

    int      range1;
    int      range2;
    int      x1;
    int      y1;

    if (!pik || !pik->npik) {
        return (NO_INDEX);
    }

    PickDecode(x, y, &pick, 1);
    plane =
        PlaneFind(pick.iaxis[AXIS_DEEP], pick.index[pick.iaxis[AXIS_DEEP]], -1,
                  -1, -1, -1);
    dir = PlaneDir(plane);
    frame = PlaneFrame(plane);
    range1 = frame - pik->range;
    range2 = frame + pik->range;
    range1 = range1 > 0 ? range1 : 0;
    range2 =
        range2 <
        AxisSize(DataAxis(data, dir)) -
        1 ? range2 : AxisSize(DataAxis(data, dir)) - 1;
    near = 100000000;
    inear = NO_INDEX;
    dir1 = pick.iaxis[1];
    dir2 = pick.iaxis[2];

    for (ipik = 0; ipik < pik->npik; ipik++) {

        if (pik->pik[ipik][0] != NO_INDEX && pik->pik[ipik][dir] >= range1
            && pik->pik[ipik][dir] <= range2) {
            distance =
                (pik->pik[ipik][dir1] -
                 pick.index[dir1]) * (pik->pik[ipik][dir1] - pick.index[dir1])
                + (pik->pik[ipik][dir2] -
                   pick.index[dir2]) * (pik->pik[ipik][dir2] -
                                        pick.index[dir2]);
            if (distance < near) {
                near = distance;
                inear = ipik;
            }
        }
    }

    if (!PikCoord(inear, plane, &x1, &y1)) {
        return (NO_INDEX);
    }

    if ((x - x1) * (x - x1) + (y - y1) * (y - y1) > PIK_NEAR) {
        return (NO_INDEX);
    }

    return (inear);
}

/*--------------------------------------------------------------------*\
    Return the pick coordinates ???
\*--------------------------------------------------------------------*/

int      PikCoord(int ipik, Plane plane, int *x, int *y)
{

    int      hskew = 0;
    int      vskew = 0;
    int      x1;
    int      y1;

    *x = NO_INDEX;
    *y = NO_INDEX;

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

    } else {
        vskew = PlaneSkew(plane);
    }

    x1 =
        MapInverse(PlaneHmap(plane),
                   pik->pik[ipik][AxisDir(MapAxis(PlaneHmap(plane)))]);
    if (PlaneType(plane) == RENDER_VERT) {
        x1 = MapSize(PlaneHmap(plane)) - x1;
    }

    y1 =
        MapInverse(PlaneVmap(plane),
                   pik->pik[ipik][AxisDir(MapAxis(PlaneVmap(plane)))]);
    if (x1 == NO_INDEX || y1 == NO_INDEX) {
        return (0);
    }

    *x = x1 + PlaneH0(plane) + hskew * (MapSize(PlaneVmap(plane)) - y1);
    *y = y1 + PlaneV0(plane) + vskew * (PlaneNH(plane) - x1);
    return (1);
}

/*--------------------------------------------------------------------*\
   inquire about pick nearest to mouse pick
\*--------------------------------------------------------------------*/

void     PikQuery(int x, int y)
{

    int      inear;
    extern Data data;
    Message  message;

    inear = PikNear(x, y);
    if (inear != NO_INDEX) {
        sprintf(message, "Pik%d= %s=%g %s=%g %s=%g %s%g %s=%g %s=%g", inear,
                AxisLabel(DataAxis(data, 1)), AxisValue(DataAxis(data, 1),
                                                        pik->pik[inear][1]),
                AxisLabel(DataAxis(data, 2)), AxisValue(DataAxis(data, 2),
                                                        pik->pik[inear][2]),
                AxisLabel(DataAxis(data, 3)), AxisValue(DataAxis(data, 3),
                                                        pik->pik[inear][3]),
                AxisLabel(DataAxis(data, 4)), AxisValue(DataAxis(data, 4),
                                                        pik->pik[inear][4]),
                AxisLabel(DataAxis(data, 5)), AxisValue(DataAxis(data, 5),
                                                        pik->pik[inear][5]),
                AxisLabel(DataAxis(data, 0)), AxisValue(DataAxis(data, 0),
                                                        pik->pik[inear][0]));
        UIMessage(message);
    }
}

/*--------------------------------------------------------------------*\
   add a pick at mouse pick location
\*--------------------------------------------------------------------*/

void     PikAdd(int x, int y)
{

    int      iaxis;
    PickPoint_ pick;

    if (!pik) {
        return;
    }

    PickDecode(x, y, &pick, 1);

    for (iaxis = 0; iaxis < DATA_NAXIS; iaxis++) {
        pik->pik[pik->npik][iaxis] = pick.index[iaxis];
    }
    pik->npik = pik->npik < pik->nmax - 1 ? pik->npik + 1 : pik->nmax - 1;
    PikDraw(pik->npik - 1, DRAW);
    pik->last_op = PIKOP_ADD;
    pik->last_item = pik->npik - 1;
    pik->changed = 1;
}

/*--------------------------------------------------------------------*\
   add a pick at X edge nearest mouse location
\*--------------------------------------------------------------------*/

void     PikEdge(int x, int y)
{

    int      iaxis;
    PickPoint_ pick;
    extern Data data;

    if (!pik) {
        return;
    }

    PickDecode(x, y, &pick, 1);

    if (pick.iaxis[1] == 1 && pick.iaxis[2] == 2) {
        if (pick.index[2] < data->axis[2]->size / 2) {
            pick.index[2] = 0;
        } else {
            pick.index[2] = data->axis[2]->size - 1;
        }

    } else if (pick.iaxis[1] == 1 && pick.iaxis[2] == 3) {
        if (pick.index[3] < data->axis[3]->size / 2) {
            pick.index[3] = 0;
        } else {
            pick.index[3] = data->axis[3]->size - 1;
        }

    } else if (pick.iaxis[1] == 2 && pick.iaxis[2] == 3) {
        if (pick.index[2] < data->axis[2]->size / 2) {
            pick.index[2] = 0;
        } else {
            pick.index[2] = data->axis[2]->size - 1;
        }

    }

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

    pik->npik = pik->npik < pik->nmax - 1 ? pik->npik + 1 : pik->nmax - 1;
    PikDraw(pik->npik - 1, DRAW);
    pik->last_op = PIKOP_ADD;
    pik->last_item = pik->npik - 1;
    pik->changed = 1;
}

/*--------------------------------------------------------------------*\
   delete nearest pick to mouse pick location
\*--------------------------------------------------------------------*/

void     PikDelete(int x, int y)
{

    int      inear, ipik, iaxis;

    if (!pik || !pik->npik) {
        return;
    }

    inear = PikNear(x, y);

    if (inear == NO_INDEX) {
        return;
    }

    PikDraw(inear, ERASE);

    for (iaxis = 0; iaxis < DATA_NAXIS; iaxis++) {
        pik->pik[pik->npik][iaxis] = pik->pik[inear][iaxis];
    }

    for (ipik = inear; ipik < pik->npik; ipik++) {

        for (iaxis = 0; iaxis < DATA_NAXIS; iaxis++) {
            pik->pik[ipik][iaxis] = pik->pik[ipik + 1][iaxis];
        }
    }
    pik->npik = pik->npik > 0 ? pik->npik - 1 : 0;
    pik->pik[pik->npik][0] = NO_INDEX;
    pik->last_op = PIKOP_DELETE;
    pik->last_item = pik->npik;
    pik->changed = 1;
}

/*--------------------------------------------------------------------*\
   move nearest pick to mouse pick location
\*--------------------------------------------------------------------*/

void     PikMove(int x, int y)
{

    int      inear;
    int      iaxis;
    PickPoint_ pick;

    if (!pik || !pik->npik) {
        return;
    }

    inear = PikNear(x, y);
    if (inear == NO_INDEX) {
        return;
    }

    PikDraw(inear, ERASE);
    PickDecode(x, y, &pick, 1);

    for (iaxis = 0; iaxis < DATA_NAXIS; iaxis++) {
        pik->pik[pik->npik][iaxis] = pik->pik[inear][iaxis];
    }

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

    PikDraw(inear, DRAW);
    pik->last_op = PIKOP_MOVE;
    pik->last_item = inear;
    pik->changed = 1;
}

/*--------------------------------------------------------------------*\
   move nearest pick to nearest edge

   This is a fragile hack because of the data model being used for
   piks.  The whole internal data model needs a serious rexamination.
\*--------------------------------------------------------------------*/

void     PikMoveEdge(int x, int y)
{

    int      inear;
    int      iaxis;
    PickPoint_ pick;
    extern Data data;

    if (!pik || !pik->npik) {
        return;
    }

    inear = PikNear(x, y);
    if (inear == NO_INDEX) {
        return;
    }

    PikDraw(inear, ERASE);
    PickDecode(x, y, &pick, 1);

    if (pick.iaxis[1] == 1 && pick.iaxis[2] == 2) {
        if (pick.index[2] < data->axis[2]->size / 2) {
            pick.index[2] = 0;
        } else {
            pick.index[2] = data->axis[2]->size - 1;
        }
        pick.index[3] = pik->pik[inear][3];

    } else if (pick.iaxis[1] == 1 && pick.iaxis[2] == 3) {
        if (pick.index[3] < data->axis[3]->size / 2) {
            pick.index[3] = 0;
        } else {
            pick.index[3] = data->axis[3]->size - 1;
        }
        pick.index[2] = pik->pik[inear][2];

    } else if (pick.iaxis[1] == 2 && pick.iaxis[2] == 3) {
        if (pick.index[2] < data->axis[2]->size / 2) {
            pick.index[2] = 0;
        } else {
            pick.index[2] = data->axis[2]->size - 1;
        }
        pick.index[3] = pik->pik[inear][3];

    }

    pick.index[0] = pik->pik[inear][0];
    pick.index[1] = pik->pik[inear][1];
    pick.index[4] = pik->pik[inear][4];
    pick.index[5] = pik->pik[inear][5];

    for (iaxis = 0; iaxis < DATA_NAXIS; iaxis++) {
        pik->pik[pik->npik][iaxis] = pik->pik[inear][iaxis];
    }

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

    PikDraw(inear, DRAW);
    pik->last_op = PIKOP_MOVE;
    pik->last_item = inear;
    pik->changed = 1;
}

/*--------------------------------------------------------------------*\
   undo a pick modification operation
\*--------------------------------------------------------------------*/

void     PikUndo(void)
{

    int      iaxis;
    int      save;

    switch (pik->last_op) {

       case 'a':
        PikDraw(pik->npik - 1, ERASE);
        pik->npik = pik->npik > 0 ? pik->npik - 1 : 0;
        pik->pik[pik->npik][0] = NO_INDEX;
        pik->last_op = PIKOP_DELETE;
        pik->last_item = pik->npik;
        break;

       case 'd':
        pik->pik[pik->npik][0] = 0;
        pik->npik = pik->npik < pik->nmax - 1 ? pik->npik + 1 : pik->nmax - 1;
        PikDraw(pik->npik, DRAW);
        pik->last_op = PIKOP_ADD;
        pik->last_item = pik->npik - 1;
        break;

       case 'm':
        PikDraw(pik->last_item, ERASE);

        for (iaxis = 0; iaxis < DATA_NAXIS; iaxis++) {
            save = pik->pik[pik->last_item][iaxis];
            pik->pik[pik->last_item][iaxis] = pik->pik[pik->npik][iaxis];
            pik->pik[pik->npik][iaxis] = save;
        }

        PikDraw(pik->last_item, DRAW);
        break;

       case 'u':
        printf("no undo\n");
        break;
    }
}

/*--------------------------------------------------------------------*\
   print attributes of pick list
\*--------------------------------------------------------------------*/

void     PikInfo(void)
{

    Message  message;

    sprintf(message, "Pik: file=%s npick=%d nmax=%d range=%d size=%d",
            pik->file, pik->npik, pik->nmax, pik->range, pik->size);
    UIMessage(message);
}

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

void     PikSave(void)
{

    Message  message;

    sprintf(message, "Pik: pick=%s npick=%d pickrange=%d picksize=%d",
            pik->file, pik->npik, pik->range, pik->size);
    UISaveMessage(message);
}

/*--------------------------------------------------------------------*\
   Increment the size of the pick markers
\*--------------------------------------------------------------------*/

int      PikIncreaseSize(void)
{

    if (!pik) {
        return 0;
    }

    PikDraw(NO_INDEX, ERASE);
    pik->size++;
    PikDraw(NO_INDEX, DRAW);
    PikInfo();
    return 0;
}

/*--------------------------------------------------------------------*\
   Decrement the size of the pick markers
\*--------------------------------------------------------------------*/

int      PikDecreaseSize(void)
{

    if (!pik) {
        return 0;
    }

    if (pik->size < 2) {
        return 0;
    }

    PikDraw(NO_INDEX, ERASE);
    pik->size--;
    PikDraw(NO_INDEX, DRAW);
    PikInfo();
    return 0;
}

/*--------------------------------------------------------------------*\
   Increment the number of frames over which a pick is shown by a box
\*--------------------------------------------------------------------*/

int      PikIncreaseRange(void)
{

    if (!pik) {
        return 0;
    }

    PikDraw(NO_INDEX, ERASE);
    pik->range++;
    PikDraw(NO_INDEX, DRAW);
    PikInfo();
    return 0;
}

/*--------------------------------------------------------------------*\
   Decrement the number of frames over which a pick is shown by a box
\*--------------------------------------------------------------------*/

int      PikDecreaseRange(void)
{

    if (!pik) {
        return 0;
    }

    if (pik->range == 0) {
        return 0;
    }

    PikDraw(NO_INDEX, ERASE);
    pik->range--;
    PikDraw(NO_INDEX, DRAW);
    PikInfo();
    return 0;
}