view.c

seismic software,very useful

/* set transparency draw rate */
ViewSetTranspRate (mode)
int mode;
	{
	extern View view;

	if (!view) return;
	if (view->rate == mode) return;
	view->rate = mode;
	}

/* set shape mode */
ViewSetShape (shape)
int shape;
	{
	extern View view;

	if (!view) return;
	if (view->shape != shape) {
		view->shape = shape;
		ViewSize (view);
		ViewDraw (view,DRAW_ALL);
		RenderDraw ();
		}
	}

/* set fence mode */
ViewToggleFence (mode)
int mode;
	{
	extern View view;

	if (!view) return;
	view->fence ^= mode;
	view->style = VIEW_FENCE;
	DrawFreePixmaps ();
	ViewDraw (view,DRAW_ALL);
	RenderDraw ();
	}

/* set two cross line frames */
ViewSetFrames (x,y)
int x,y;
	{
	extern View view;
	Map map;
	PickPoint_ pick;
	int iaxis;

	if (!view) return;
	/* undefined views */
	switch (view->style) {
	case VIEW_FRONT:
	case VIEW_SIDE:
	case VIEW_TOP:
	case VIEW_XSEC:
	case VIEW_ARRAY:
	case VIEW_TRANSP:
		return;
		}
	/* translate pick */
	PickDecode (x,y,&pick,1);
	/* reset frames */
	for (iaxis=1; iaxis<VIEW_NAXIS; iaxis++) {
		map = view->map[iaxis];
		MapSetFrame (map,pick.index[AxisDir(MapAxis(map))]);
		}
	DrawFreePixmaps ();
	ViewDraw (view,DRAW_ALL);
	RenderDraw ();
	}

/* set frame from slider */
ViewSetFrame (index,mode)
int index,mode;
	{
	extern View view;
	Map map;
	int frame;

	map = ViewMovieMap (view);
	if (mode == FRAME_PERCENT) {
		frame = MapLow(map) + (index * (MapHigh(map) - MapLow(map))) / 100;
		}
	MapSetFrame (map,frame);
	if (view->style == VIEW_ARRAY) {
		RenderClear();
		DrawClear();
		}
	switch (view->movie) {
	case MOVIE_TOP: ViewDraw (view,DRAW_TOP); break;
	case MOVIE_SIDE: ViewDraw (view,DRAW_SIDE); break;
	case MOVIE_FRONT: ViewDraw (view,DRAW_FRONT); break;
		}
	RenderDraw ();
	}

/* set pick mode */
ViewSetPick (pick)
int pick;
	{
	extern View view;

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

/* toggle pick mode */
ViewTogglePick ()
	{
	extern View view;

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

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

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


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

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

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

/* set frames to middle */
ViewFramesMiddle ()
	{
	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 */
ViewFramesOrigin ()
	{
	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 */
ViewSwapAxis (a,b)
int a,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);
		}
	ViewSetMovie (view->movie);
	if (view->style != VIEW_ARRAY) ViewDrawAll ();
	}

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

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

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

	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 (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 */
ViewWindow0 ()
	{
	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);*/
		}
	MapFlip (view->map[AXIS_DEEP]);
	/* non-vue shapes require resize */
	if (view->shape == SHAPE_TRUE || view->shape == SHAPE_PIXEL) ViewSize (view);
	else DrawFreePixmaps ();
	ViewDraw (view,DRAW_ALL);
	ViewSetMovie (view->movie);
	RenderDraw ();
	}

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


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

/* print view information */
ViewInfo (view)
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 */
ViewSavePar (view)
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 */
ViewOrient0 ()
	{
	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++) {
		if (AxisDir(MapAxis(map[imap])) == AXIS_DEEP) {
			MapSet (view->map[AxisDir(MapAxis(map[imap]))],
				MapAxis(map[imap]),
				MapSize(view->map[AxisDir(MapAxis(map[imap]))]),
				MapHigh(map[imap]),
				MapLow(map[imap]),
				MapHigh(map[imap]),
				MapLow(map[imap]),
				MapDmovie(map[imap]));
				}
			else	{
			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) ViewSize (view);
	else DrawFreePixmaps ();
	ViewSetMovie (view->movie);
	ViewDraw (view,DRAW_ALL);
	RenderDraw();
	}

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

	gettimeofday (&tp,&tzp);
	tyme = tp.tv_sec;
	tyme = tyme*1000. + tp.tv_usec*.001;
	return (tyme);
	}
#else
#include <sys/types.h>
#include <sys/timeb.h>
double Tyme()
	{
	double tyme;
	struct timeb tp;

	ftime (&tp);
	tyme = tp.time;
	tyme = tyme*1000. + tp.millitm;
	return (tyme);
	}
#endif

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

TymeEnd (pixels)
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;
	}