view.c

seismic software,very useful

{
    extern View view;

    if( !view ){
        return;
    }
    view->showpicks = 1 - view->showpicks;
    PickDrawAll(view->showpicks);
    PikDraw(NO_INDEX, view->showpicks);
}

/* return pick state */
int ViewPick(void)
{
    extern View view;

    if( !view ){
        return (0);
    }else{
        return (view->showpicks);
    }
}

/* return view movie */
int ViewMovie(void)
{
    extern View view;

    if( !view ){
        return (NO_INDEX);
    }
    return (view->movie);
}

/* return map axis */
Map      ViewMovieMap(View view)
{
    return (view->map[view->movie]);
}

/* set frames to middle */
void ViewFramesMiddle(void)
{
    extern View view;
    int      imap;

    if( !view ){
        return;
    }
    for( imap = 1; imap < VIEW_NAXIS; imap++ ){
        MapSetFrameBounds(view->map[imap], MapFirst(view->map[imap]),
                          MapLast(view->map[imap]));
        MapSetFrame(view->map[imap],
                    (MapFirst(view->map[imap]) + MapLast(view->map[imap])) / 2);
    }
    ViewDrawAll();
}

/* set frames to origin */
void ViewFramesOrigin(void)
{
    extern View view;
    int      imap;

    if( !view ){
        return;
    }
    for( imap = 1; imap < VIEW_NAXIS; imap++ ){
        MapSetFrame(view->map[imap], 0);
    }
    ViewDrawAll();
}

/* swap two map axes and draw */
void ViewSwapAxis(int a, int b)
{
    extern View view;
    Map      map;

    if( !view ){
        return;
    }
    if( MapSize(view->map[b]) <= 1 || MapSize(view->map[b]) <= 1 ){
        return;
    }
    if( view->shape == SHAPE_FIT ){
        MapSwap(view->map[a], view->map[b]);
        DrawFreePixmaps();
    }else{
        map = view->map[a];
        view->map[a] = view->map[b];
        view->map[b] = map;
    }
    ViewSize(view);
    MapSetTics(view->map[a]);
    MapSetTics(view->map[b]);
    ViewSetMovie(view->movie);
    if( view->style != VIEW_ARRAY ){
        ViewDrawAll();
    }
}

/* flip an axes direction */
void ViewFlipAxis(int imap)
{
    extern View view;

    if( !view ){
        return;
    }
    MapFlip(view->map[imap]);
    DrawFreePixmaps();
    ViewDraw(view, DRAW_ALL);
    RenderDraw();
}

/* magnification window given corner coordinates */
void ViewWindow(int x1, int y1, int x2, int y2, int hzoom, int vzoom)
{
    extern View view;
    extern Data data;
    Map      map;
    int      v, iaxis, haxis, vaxis;
    PickPoint_ pick11, pick12, pick21, pick22;
    PickPoint_ bad = { {-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1}};

    if( !view ){
        return;
    }
    /* slippy mouse tolerance is five pixels */
    if( hzoom && (x1 - x2) * (x1 - x2) < 25 ){
        return;
    }
    if( vzoom && (y1 - y2) * (y1 - y2) < 25 ){
        return;
    }
    /* fetch indices */
    PickDecode((x1 < x2 ? x1 : x2), (y1 < y2 ? y1 : y2), &pick11, 0);
    PickDecode((x1 < x2 ? x1 : x2), (y1 > y2 ? y1 : y2), &pick12, 0);
    PickDecode((x1 > x2 ? x1 : x2), (y1 < y2 ? y1 : y2), &pick21, 0);
    PickDecode((x1 > x2 ? x1 : x2), (y1 > y2 ? y1 : y2), &pick22, 0);
    
    if(  !memcmp(&pick11 ,&bad , sizeof(bad) ) 
      || !memcmp(&pick12 ,&bad , sizeof(bad) ) 
      || !memcmp(&pick21 ,&bad , sizeof(bad) ) 
      || !memcmp(&pick22 ,&bad , sizeof(bad) ) ){
        return;
    }

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

       if( PickSameDir (&pick11,&pick22) ){ printf ("Pick direction is
       %s\n",AxisLabel(data->axis[pick11.iaxis[AXIS_DEEP]])); } if
       (PickSameFrame (&pick11,&pick22) ){ iaxis = pick11.iaxis[AXIS_DEEP];
       printf ("Pick frame is
       %s\n",AxisScript(data->axis[iaxis],pick11.index[iaxis])); } if
       ((haxis=PickSharedDir (&pick11,&pick12)) > 0 ){ printf ("Pick
       horizontal is %s\n",AxisLabel(data->axis[haxis])); } if
       ((vaxis=PickSharedDir (&pick11,&pick21)) > 0 ){ printf ("Pick vertical 
       is %s\n",AxisLabel(data->axis[vaxis])); } printf ("\n"); 
\*--------------------------------------------------------------------*/

    /* window across an array of frames */
    if( view->style == VIEW_ARRAY && PickSameDir(&pick11, &pick22)
        && !PickSameFrame(&pick11, &pick22) ){
        MapSetFrameBounds(view->map[AXIS_DEEP], pick11.index[haxis],
                          pick22.index[vaxis]);
        UIArrayReset(0);
        UIArrayDraw();
        return;
    }
    /* within a frame */
    if( !PickSameFrame(&pick11, &pick22) ){
        return;
    }
    /* sort out horizontal and vertical axes; horizontal is that which
       differs for two corners with same y coordinate vertical is that which
       differs for two corners with same x coordinate */
    haxis = PickSharedDir(&pick11, &pick12);
    vaxis = PickSharedDir(&pick11, &pick21);
    /* one of these will fail for a skewed plot; then the answer is the
       remaining coordinate */
    if( !haxis ){
        if( !vaxis ){
            return;
        }
        if( vaxis == pick11.iaxis[AXIS_ACROSS] ){
            haxis = pick11.iaxis[AXIS_DOWN];
        }else{
            haxis = pick11.iaxis[AXIS_ACROSS];
        }
    }
    if( !vaxis ){
        if( !haxis ){
            return;
        }
        if( haxis == pick11.iaxis[AXIS_ACROSS] ){
            vaxis = pick11.iaxis[AXIS_DOWN];
        }else{
            vaxis = pick11.iaxis[AXIS_ACROSS];
        }
    }
    /* map */
    if( hzoom ){
        for( iaxis = 1; iaxis < VIEW_NAXIS; iaxis++ ){
            if( AxisDir(MapAxis(view->map[iaxis])) == haxis ){
                break;
            }
        }
        map = view->map[iaxis];
        MapSet(map, MapAxis(map), MapSize(map),
               pick11.index[haxis], pick22.index[haxis],
               pick11.index[haxis], pick22.index[haxis], MapDmovie(map));
    }
    if( vzoom ){
        for( iaxis = 1; iaxis < VIEW_NAXIS; iaxis++ ){
            if( AxisDir(MapAxis(view->map[iaxis])) == vaxis ){
                break;
            }
        }
        map = view->map[iaxis];
        MapSet(map, MapAxis(map), MapSize(map),
               pick11.index[vaxis], pick22.index[vaxis],
               pick11.index[vaxis], pick22.index[vaxis], MapDmovie(map));
    }
    /* non-cube shapes require resize */
    if( view->shape == SHAPE_TRUE || view->shape == SHAPE_PIXEL ){
        ViewSize(view);
    }else{
        DrawFreePixmaps();
    }
    ViewDraw(view, DRAW_ALL);
    RenderDraw();
}

/* restore initial map */
void ViewWindow0(void)
{
    extern View view;
    Map      map;
    int      iaxis;

    if( !view ){
        return;
    }
    for( iaxis = 1; iaxis < VIEW_NAXIS; iaxis++ ){
        map = view->map[iaxis];
        MapSet(map, MapAxis(map), MapSize(map), 0, AxisSize(MapAxis(map)) - 1,
               0, AxisSize(MapAxis(map)) - 1, 1);

/*              MapSetFrame (map,0);*/
    }


    /* non-vue shapes require resize */
    if( !(view->shape == SHAPE_TRUE || view->shape == SHAPE_PIXEL) ){
        DrawFreePixmaps();
    }

    ViewSize(view);
    MapSetTics( view->map[0] );
    MapSetTics( view->map[1] );
    MapSetTics( view->map[2] );
    MapSetTics( view->map[3] );
    MapSetTics( view->map[4] );
    ViewDraw(view, DRAW_ALL);
    ViewSetMovie(view->movie);
    RenderDraw();
}
void ViewRestoreSize(void)
{
    extern View view;
    Map      map;
    int      iaxis;

    if( !view ){
        return;
    }
    for( iaxis = 1; iaxis < VIEW_NAXIS; iaxis++ ){
        map = view->map[iaxis];
        if( MapFirst(map) < MapLast(map) ){
            MapSet(map, MapAxis(map), MapSize(map), 
               0, AxisSize(MapAxis(map)) - 1,
               0, AxisSize(MapAxis(map)) - 1, 1);
        }else{
            MapSet(map, MapAxis(map), MapSize(map), 
               AxisSize(MapAxis(map)) - 1, 0,
               AxisSize(MapAxis(map)) - 1, 0 , 1);
        }
    }


    /* non-vue shapes require resize */
    if( !(view->shape == SHAPE_TRUE || view->shape == SHAPE_PIXEL) ){
        DrawFreePixmaps();
    }

    ViewSize(view);
    MapSetTics( view->map[0] );
    MapSetTics( view->map[1] );
    MapSetTics( view->map[2] );
    MapSetTics( view->map[3] );
    MapSetTics( view->map[4] );
    ViewDraw(view, DRAW_ALL);
    ViewSetMovie(view->movie);
    RenderDraw();
}

/* return view map */
Map      ViewMap(View view, int index)
{
    if( !view || index >= VIEW_NAXIS ){
        return (0);
    }
    return (view->map[index]);
}

/* return view map data axis */
Axis     ViewDataAxis(View view, int imap)
{
    return (MapAxis(view->map[imap]));
}

/* print view information */
void ViewInfo(View view)
{

    if( !view ){
        return;
    }
    sprintf(message,
            "Style: wide=%d hite=%d movie=%d style=%d shape=%d pick=%d across=%d down=%d delta=%d fence=%d rate=%d",
            view->wide, view->hite, view->movie, view->style, view->shape,
            view->showpicks, view->nacross, view->ndown, view->dacross,
            view->fence, view->rate);
    UIMessage(message);
}

/* save view parameters */
void ViewSavePar(View view)
{
    int      imap;

    if( !view ){
        return;
    }
    sprintf(message,
            "Style: wide=%d hite=%d movie=%d style=%d shape=%d showpicks=%d\n      across=%d down=%d delta=%d fence=%d rate=%d",
            view->wide, view->hite, view->movie, view->style, view->shape,
            view->showpicks, view->nacross, view->ndown, view->dacross,
            view->fence, view->rate);
    UISaveMessage(message);
    for( imap = 1; imap < VIEW_NAXIS; imap++ ){
        MapSavePar(view->map[imap]);
    }
}

/* initial axis orientation */
void ViewOrient0(void)
{
    extern View view;
    int      imap;
    Map_     map_[VIEW_NAXIS];
    Map      map[VIEW_NAXIS];

    /* copy map axes */
    for( imap = 1; imap < VIEW_NAXIS; imap++ ){
        map_[imap] = *view->map[imap];
        map[imap] = &map_[imap];
    }
    /* replace map axes in original order */
    for( imap = 1; imap < VIEW_NAXIS; imap++ ){
        MapSet(view->map[AxisDir(MapAxis(map[imap]))],
               MapAxis(map[imap]),
               MapSize(view->map[AxisDir(MapAxis(map[imap]))]),
               MapLow(map[imap]),
               MapHigh(map[imap]),
               MapLow(map[imap]), MapHigh(map[imap]), MapDmovie(map[imap]));
        MapSetFrame(view->map[AxisDir(MapAxis(map[imap]))],
                    MapFrame(map[imap]));
    }
    if( !(view->shape == SHAPE_TRUE || view->shape == SHAPE_PIXEL) ){
        DrawFreePixmaps();
    }
    ViewSize(view);
    MapSetTics( view->map[0] );
    MapSetTics( view->map[1] );
    MapSetTics( view->map[2] );
    MapSetTics( view->map[3] );
    MapSetTics( view->map[4] );
    ViewSetMovie(view->movie);
    ViewDraw(view, DRAW_ALL);
    RenderDraw();
}

#include <sys/time.h>
double   Tyme(void)
{
    double   tyme;
    struct timeval tp;
    struct timezone tzp;

    gettimeofday(&tp, &tzp);
    tyme = tp.tv_sec;
    tyme = tyme * 1000. + tp.tv_usec * .001;
    return (tyme);
}

static double   tyme;
void TymeStart(void)
{
    tyme = Tyme();
}

void TymeEnd(int pixels)
{
    if( pixels == 0 || tyme == 0.0 ){
        return;
    }
    tyme = Tyme() - tyme;
    sprintf(message, "render=%d msec pixels=%d rate=%d pixels/sec", (int) tyme,
            pixels, (int) (1000. * pixels / tyme));
    UIMessage(message);
    tyme = 0.0;
}