view.c

seismic software,very useful

/*
view object code
*/
#include <stdio.h>
#include <string.h>
#include "main.h"
#include "axis.h"
#include "data.h"
#include "map.h"
#include "movie.h"
#include "render.h"
#include "view.h"
#include "pick.h"

/* set rendering attributes for a view */
RenderAttr _attr_;
#define RENDER_ATTR(_transp,_skew,_mark,_zbuffer,_image,_axes,_shadow,_lines,_box,_pick) \
	_attr_->image = (_image);\
	_attr_->shadow = (_shadow);\
	_attr_->zbuffer = (_zbuffer);\
	_attr_->box = (_box);\
	_attr_->axes = (_axes);\
	_attr_->lines = (_lines);\
	_attr_->pick = (_pick);\
	_attr_->skew = (_skew);\
	_attr_->transp = (_transp);\
	_attr_->mark = (_mark);\
	/*printf ("image=%d shadow=%d zbuffer=%d box=%d axes=%d lines=%d pick=%d skew=%d transp=%d mark=%d\n",_image,_shadow,_zbuffer,_box,_axes,_lines,_pick,_skew,_transp,_mark)*/
Message message;

/* initialize view object */
string viewnamelist[] = VIEW_NAMELIST;
View
ViewInit (data)
Data data;
	{
	View view;
	string option;
	int i;

	NEW(View,view,1);
	view->margins[MARGIN_LEFT] = LEFT_MARGIN;
	view->margins[MARGIN_RIGHT] = RIGHT_MARGIN;
	view->margins[MARGIN_BASE] = BASE_MARGIN;
	view->margins[MARGIN_TOP] = TOP_MARGIN;
	view->style = VIEW_CUBE;
	if (GETPARSTRING ("style","s",option)) {
		for (view->style=0; view->style<sizeof (viewnamelist) / sizeof(viewnamelist[0]); view->style++) {
			if (!strcmp (viewnamelist[view->style],option)) break;
			}
		}
	else GETPARINT ("style","d",&view->style);
	GETPARINT ("wide","d",&view->wide);
	GETPARINT ("hite","d",&view->hite);
	switch (view->style) {
	case VIEW_TRANSP:
	case VIEW_SIDE:
		view->movie = MOVIE_SIDE;
		break;
	case VIEW_TOP:
		view->movie = MOVIE_TOP;
		break;
	default:
		view->movie = MOVIE_FRONT;
		}
	if (GETPARSTRING ("movie","s",option)) {
		if (!strcmp (option,"in")) {
			view->movie = MOVIE_FRONT;
			MovieSetDir (MOVIE_REVERSE);
			MovieSetRun (1);
			}
		if (!strcmp (option,"out")) {
			view->movie = MOVIE_FRONT;
			MovieSetDir (MOVIE_FORWARD);
			MovieSetRun (1);
			}
		if (!strcmp (option,"left")) {
			view->movie = MOVIE_SIDE;
			MovieSetDir (MOVIE_REVERSE);
			MovieSetRun (1);
			}
		if (!strcmp (option,"right")) {
			view->movie = MOVIE_SIDE;
			MovieSetDir (MOVIE_FORWARD);
			MovieSetRun (1);
			}
		if (!strcmp (option,"up")) {
			view->movie = MOVIE_TOP;
			MovieSetDir (MOVIE_REVERSE);
			MovieSetRun (1);
			}
		if (!strcmp (option,"down")) {
			view->movie = MOVIE_TOP;
			MovieSetDir (MOVIE_REVERSE);
			MovieSetRun (1);
			}
		}
	if (view->style == VIEW_TRANSP) view->shape = SHAPE_PIXEL;
	else view->shape = SHAPE_FIT;
	if (GETPARSTRING ("shape","s",option)) {
		if (!strcmp (option,"fit")) view->shape = SHAPE_FIT;
		else if (!strcmp (option,"cube")) view->shape = SHAPE_FIT;
		else if (!strcmp (option,"0")) view->shape = SHAPE_FIT;
		else if (!strcmp (option,"true")) view->shape = SHAPE_TRUE;
		else if (!strcmp (option,"1")) view->shape = SHAPE_TRUE;
		else if (!strcmp (option,"pixel")) view->shape = SHAPE_PIXEL;
		else if (!strcmp (option,"2")) view->shape = SHAPE_PIXEL;
		}
	view->showpicks = DRAW;
	GETPARINT ("showpicks","d",&view->showpicks);
	view->nacross = 1;
	GETPARINT ("across","d",&view->nacross);
	view->ndown = 1;
	GETPARINT ("down","d",&view->ndown);
	view->dacross = 1;
	GETPARINT ("delta","d",&view->dacross);
	view->rate = VIEW_RATE_TENTHS;
	GETPARINT ("rate","d",&view->rate);
	view->fence = DRAW_ALL;
	GETPARINT ("fence","d",&view->fence);
	view->map[AXIS_DOWN] = MapInit (DataAxis(data,DATA_AXIS1),"DOWN",AXIS_DOWN);
	view->map[AXIS_ACROSS] = MapInit (DataAxis(data,DATA_AXIS2),"ACROSS",AXIS_ACROSS);
	view->map[AXIS_DEEP] = MapInit (DataAxis(data,DATA_AXIS3),"DEEP",AXIS_DEEP);
	view->map[AXIS_4D] = MapInit (DataAxis(data,DATA_AXIS4),"4D",AXIS_4D);
	view->map[AXIS_5D] = MapInit (DataAxis(data,DATA_AXIS5),"5D",AXIS_5D);
	if (GETPARSTRING ("orient","s",option)) {
		if (!strcmp (option,"side")) {
			MapSwap (view->map[AXIS_ACROSS],view->map[AXIS_DEEP]);
			}
		else if (!strcmp (option,"top")) {
			MapSwap (view->map[AXIS_DOWN],view->map[AXIS_DEEP]);
			}
		else if (!strcmp (option,"extra")) {
			MapSwap (view->map[AXIS_4D],view->map[AXIS_DEEP]);
			}
		}
	view->map[AXIS_COLOR] = MapInit (DataAxis(data,DATA_VALUE),"COLOR",AXIS_COLOR);
	MapFlip (view->map[AXIS_DEEP]);
	if (view->style == VIEW_FENCE) strcpy (option,"center");
	else strcpy (option,"option");
	GETPARSTRING ("origin","s",option);
	if (!strcmp (option,"center") || !strcmp (option,"middle")) {
		for (i=1; i<VIEW_NAXIS; i++) {
			MapSetFrame (view->map[i],AxisSize(MapAxis(view->map[i]))/2);
			}
		}
	NEW (RenderAttr,_attr_,1);
	return (view);
	}

/* adjust view size: reallocate buffers,adjust map axes */
ViewSize (view)
View view;
	{
	int wide,hite, size, deep;
	float fwide,fhite, scale;

	if (!view) return;
	/* get new size */
	UICanvasSize (&wide,&hite);
	RenderSize (wide,hite);
	view->wide = wide;
	view->hite = hite;
	/* adjust axes lengths depending upon shape and style */
	switch (view->style) {
	/* the four cubical views */
	case VIEW_CUBE:
	case VIEW_FENCE:
	case VIEW_THREE:
	case VIEW_TRANSP:
		/* actual real estate */
		wide = view->wide - HMARGIN - GAP;
		hite = view->hite - VMARGIN - GAP;
		switch (view->shape) {
		case SHAPE_FIT:
			deep = (wide < hite ? wide : hite) * (1. - FRAC);
			MapSetSize (view->map[AXIS_DOWN],hite-deep);
			MapSetSize (view->map[AXIS_ACROSS],wide-deep);
			MapSetSize (view->map[AXIS_DEEP],deep);
			break;
		case SHAPE_TRUE:
			fwide = (float)wide / (float)(MapZoom (view->map[AXIS_ACROSS]) +
				MapZoom (view->map[AXIS_DEEP]));
			fhite = (float)hite / (float)(MapZoom (view->map[AXIS_DOWN]) +
				MapZoom (view->map[AXIS_DEEP]));
			if (fwide < fhite ) {
				MapSetSize (view->map[AXIS_DOWN],
				(int)(fwide*MapZoom(view->map[AXIS_DOWN])));
				MapSetSize (view->map[AXIS_ACROSS],
				(int)(fwide*MapZoom(view->map[AXIS_ACROSS])));
				MapSetSize (view->map[AXIS_DEEP],
				(int)(fwide*MapZoom(view->map[AXIS_DEEP])));
				}
			else	{
				MapSetSize (view->map[AXIS_DOWN],
				(int)(fhite*MapZoom(view->map[AXIS_DOWN])));
				MapSetSize (view->map[AXIS_ACROSS],
				(int)(fhite*MapZoom(view->map[AXIS_ACROSS])));
				MapSetSize (view->map[AXIS_DEEP],
				(int)(fhite*MapZoom(view->map[AXIS_DEEP])));
				}
			break;
		case SHAPE_PIXEL:
			fwide = (float)wide / (float)(MapWindow (view->map[AXIS_ACROSS]) +
				MapWindow (view->map[AXIS_DEEP]));
			fhite = (float)hite / (float)(MapWindow (view->map[AXIS_DOWN]) +
				MapWindow (view->map[AXIS_DEEP]));
			if (fwide < 1.0) {
				UIMessage ("dataset too wide; shrink data or enlarge window");
/*				ViewSetShape (SHAPE_FIT);*/
				break;
				}
			if (fhite < 1.0) {
				UIMessage ("dataset too high; window data or enlarge window");
/*				ViewSetShape (SHAPE_FIT);*/
				break;
				}
			MapSetSize (view->map[AXIS_DOWN],
			MapWindow(view->map[AXIS_DOWN]));
			MapSetSize (view->map[AXIS_ACROSS],
			MapWindow(view->map[AXIS_ACROSS]));
			MapSetSize (view->map[AXIS_DEEP],
			MapWindow(view->map[AXIS_DEEP]));
			break;
			}
		break;
	case VIEW_FRONT:
		ViewSingleSize (view->map[AXIS_ACROSS],view->map[AXIS_DOWN],view->map[AXIS_DEEP]);
		break;
	case VIEW_SIDE:
		ViewSingleSize (view->map[AXIS_DEEP],view->map[AXIS_DOWN],view->map[AXIS_ACROSS]);
		break;
	case VIEW_TOP:
		ViewSingleSize (view->map[AXIS_ACROSS],view->map[AXIS_DEEP],view->map[AXIS_DOWN]);
		break;
	case VIEW_XSEC:
		MapSetSize (view->map[AXIS_DOWN],view->hite-VMARGIN);
		MapSetSize (view->map[AXIS_ACROSS],(view->wide-HMARGIN)/2);
		break;
	case VIEW_ARRAY:
		MapSetSize (view->map[AXIS_ACROSS],
		(view->wide-(view->nacross-1)*GAP)/view->nacross);
		MapSetSize (view->map[AXIS_DOWN],
		(view->hite-(view->ndown-1)*GAP)/view->ndown);
		break;
		}
	DrawFreePixmaps();
	}

/* size for single panel */
ViewSingleSize (hmap,vmap,zmap)
Map hmap, vmap, zmap;
	{
	float fwide, fhite, scale;
	int size;
	extern View view;

	switch (view->shape) {
	case SHAPE_FIT:
		MapSetSize (hmap,view->wide-HMARGIN);
		MapSetSize (vmap,view->hite-VMARGIN);
		break;
	case SHAPE_TRUE:
		fwide = (float)(view->wide - HMARGIN) / (float)MapZoom(hmap);
		fhite = (float)(view->hite - VMARGIN) / (float)MapZoom(vmap);
		scale = fwide < fhite ? fwide : fhite;
		MapSetSize (vmap,(int)scale*MapZoom(vmap));
		MapSetSize (hmap,(int)scale*MapZoom(vmap));
		break;
	case SHAPE_PIXEL:
		fwide = (float)(view->wide - HMARGIN) / (float)MapWindow(hmap);
		fhite = (float)(view->hite - VMARGIN) / (float)MapWindow(vmap);
		size = (fhite < 1. ? fhite : 1.) *
			(MapLast (vmap) -
			MapFirst (vmap));
		MapSet (vmap,
			MapAxis(vmap),
			size>0?size:-size,
			MapFirst (vmap),
			MapLast (vmap),
			MapFirst (vmap),
			MapLast (vmap),
			MapDmovie (hmap));
		size = (fwide < 1. ? fwide : 1.) *
			(MapLast (hmap) -
			MapFirst (hmap));
		MapSet (hmap,
			MapAxis(hmap),
			size>0?size:-size,
			MapFirst (hmap),
			MapLast (hmap),
			MapFirst (hmap),
			MapLast (hmap),
			MapDmovie (hmap));
		break;
		}
	}

/* callback for initial view size */
ViewSize0 ()
	{
	extern View view;

	ViewSize (view);
	}

/* extract view from data; depends upon movie and view mode */
ViewDraw (view,mode)
View view;
int mode;
	{
	extern Data data;
	extern Render render;
	Map map;
	int pixels;
	if (UIFirst()) return;
	if (!view || !view->map[AXIS_DEEP]) return;
	pixels = 0;

	if (mode == DRAW_ALL) {
		TymeStart ();
		DrawWatch (1);
		if (view->style != VIEW_FENCE) {
			RenderClear ();
			DrawClear();
			}
		PlaneReset ();
		}
	if (view->showpicks && view->style != VIEW_TRANSP) PikDraw (NO_INDEX,ERASE);
	switch (view->style) {
	case VIEW_CUBE:
		ViewDrawCube (view,mode);
		pixels += MapSize (view->map[AXIS_DOWN]) * MapSize (view->map[AXIS_ACROSS]);
		pixels += MapSize (view->map[AXIS_DEEP]) * MapSize (view->map[AXIS_DOWN]);
		pixels += MapSize (view->map[AXIS_ACROSS]) * MapSize (view->map[AXIS_DEEP]);
		break;
	case VIEW_FENCE:
		ViewDrawFence (view,view->fence);
		if (view->fence & DRAW_FRONT) {
			pixels += MapSize (view->map[AXIS_DOWN]) * MapSize (view->map[AXIS_ACROSS]);
			}
		if (view->fence & DRAW_SIDE) {
			pixels += MapSize (view->map[AXIS_DEEP]) * MapSize (view->map[AXIS_DOWN]);
			}
		if (view->fence & DRAW_TOP) {
			pixels += MapSize (view->map[AXIS_ACROSS]) * MapSize (view->map[AXIS_DEEP]);
			}
		break;
	case VIEW_THREE:
		ViewDrawPlan (view,mode);
		pixels += MapSize (view->map[AXIS_DOWN]) * MapSize (view->map[AXIS_ACROSS]);
		pixels += MapSize (view->map[AXIS_DEEP]) * MapSize (view->map[AXIS_DOWN]);
		pixels += MapSize (view->map[AXIS_ACROSS]) * MapSize (view->map[AXIS_DEEP]);
		break;
	case VIEW_FRONT:
	case VIEW_XSEC:
	RENDER_ATTR(0,0,mode==DRAW_ALL,0,(mode&DRAW_IMAGE),(AXIS_LEFT|AXIS_BASE)*!MovieRun(),!MovieRun(),0,!MovieRun(),view->showpicks);
	RenderHorz (data,view->map[AXIS_ACROSS],view->map[AXIS_DOWN],view->map[AXIS_DEEP],
		view->map[AXIS_4D],view->map[AXIS_5D],
		view->margins[MARGIN_LEFT],view->margins[MARGIN_TOP],
		render,view->margins,_attr_);
		pixels += MapSize (view->map[AXIS_DOWN]) * MapSize (view->map[AXIS_ACROSS]);
		break;
	case VIEW_SIDE:
	RENDER_ATTR(0,0,mode==DRAW_ALL,0,(mode&DRAW_IMAGE),(AXIS_LEFT|AXIS_BASE)*!MovieRun(),!MovieRun(),0,!MovieRun(),view->showpicks);
	RenderHorz (data,view->map[AXIS_DEEP],view->map[AXIS_DOWN],
		view->map[AXIS_ACROSS],view->map[AXIS_4D],view->map[AXIS_5D],
		view->margins[MARGIN_LEFT],view->margins[MARGIN_TOP],
		render,view->margins,_attr_);
		pixels += MapSize (view->map[AXIS_DOWN]) * MapSize (view->map[AXIS_DEEP]);
		break;
	case VIEW_TOP:
	RENDER_ATTR(0,0,mode==DRAW_ALL,0,(mode&DRAW_IMAGE),(AXIS_LEFT|AXIS_BASE)*!MovieRun(),!MovieRun(),0,!MovieRun(),view->showpicks);
	RenderHorz (data,view->map[AXIS_ACROSS],view->map[AXIS_DEEP],
		view->map[AXIS_DOWN],view->map[AXIS_4D],view->map[AXIS_5D],
		view->margins[MARGIN_LEFT],view->margins[MARGIN_TOP],
		render,view->margins,_attr_);
		pixels += MapSize (view->map[AXIS_ACROSS]) * MapSize (view->map[AXIS_DEEP]);
		break;
	case VIEW_ARRAY:
		ViewDrawArray (view);
		pixels += MapSize (view->map[AXIS_DOWN]) * MapSize (view->map[AXIS_ACROSS]) * view->nacross * view->ndown;
		break;
	case VIEW_TRANSP:
		ViewDrawTransp (view);
		pixels += MapSize (view->map[AXIS_DOWN]) * MapSize (view->map[AXIS_ACROSS]) * MapSize(view->map[AXIS_DEEP]);
		break;
		}
	map = ViewMovieMap (view);
	switch (view->style) {
	case VIEW_CUBE:
	case VIEW_FENCE:
	case VIEW_THREE:
		sprintf (message,"%s %s %s %s %s",
		AxisScript(MapAxis(view->map[AXIS_DOWN]),MapFrame(view->map[AXIS_DOWN])),
		AxisScript(MapAxis(view->map[AXIS_ACROSS]),MapFrame(view->map[AXIS_ACROSS])),
		AxisScript(MapAxis(view->map[AXIS_DEEP]),MapFrame(view->map[AXIS_DEEP])),
		AxisScript(MapAxis(view->map[AXIS_4D]),MapFrame(view->map[AXIS_4D])),
		AxisScript(MapAxis(view->map[AXIS_5D]),MapFrame(view->map[AXIS_5D])) );
		strcat (message,"                                   ");
		DrawText (view->margins[MARGIN_LEFT],0,TEXT_H0|TEXT_V0,DataTitle(data));
		DrawText (view->margins[MARGIN_LEFT],15,TEXT_H0|TEXT_V0,message);
		break;
	case VIEW_FRONT:
	case VIEW_SIDE:
	case VIEW_TOP:
		strcpy (message,AxisScript(MapAxis(map),MapFrame(map)));
		strcat (message,"                                   ");
		DrawText (view->margins[MARGIN_LEFT],0,TEXT_H0|TEXT_V0,DataTitle(data));
		DrawText (view->margins[MARGIN_LEFT],15,TEXT_H0|TEXT_V0,message);
		break;
		}
	if (view->showpicks && view->style != VIEW_TRANSP) PikDraw (NO_INDEX,DRAW);
	if (mode == DRAW_ALL && view->style != VIEW_TRANSP) {
		TymeEnd (pixels);
		DrawWatch (0);
		}
	}

/* set array */
ViewArray (nacross,ndown,across0,dacross)
int nacross, ndown, across0, dacross;
	{
	extern View view;

	if (!view) return;
	if (view->style != VIEW_ARRAY) {
		view->style = VIEW_ARRAY;
		MapSetFrame (ViewMovieMap(view),0);
		}
	view->nacross = nacross;
	view->ndown = ndown;
	view->dacross = dacross;
	view->across0 = across0;
	MapSetFrameBounds (view->map[AXIS_DEEP],view->across0,view->across0+view->nacross*view->ndown*view->dacross);
	ViewSize (view);
	ViewDraw (view,DRAW_ALL);
	RenderDraw ();
	}

/* draw array */
ViewDrawArray (view)
View view;
	{
	extern Data data;
	extern Render render;
	int panel,frame, ih, iv, margins[4];
	string label;
	char *labelp,labelp1;

	MapSaveFrame (view->map[AXIS_DEEP]);
	for (panel=0; panel<view->nacross*view->ndown; panel++) {
		frame = panel * view->dacross + view->across0;
		if (frame >= AxisSize(MapAxis(view->map[AXIS_DEEP]))) break;
		iv = panel / view->nacross;
		ih = panel % view->nacross;
		MapSetFrame (view->map[AXIS_DEEP],frame);
		RENDER_ATTR(0,0,1,0,DRAW_FRONT,0,1,0,0,view->showpicks);
		RenderHorz (data,view->map[AXIS_ACROSS],
			view->map[AXIS_DOWN],view->map[AXIS_DEEP],view->map[AXIS_4D],view->map[AXIS_5D],
			ih=ih*(MapSize(view->map[AXIS_ACROSS])+GAP),
			iv=iv*(MapSize(view->map[AXIS_DOWN])+GAP),
			render,view->margins,_attr_);
			if (MapSize(view->map[AXIS_ACROSS]) > 100) {
			DrawText (ih,iv+2,TEXT_H0|TEXT_V0,AxisScript(ViewDataAxis(view,AXIS_DEEP),frame));
			}
		else	{
			labelp = AxisScript(ViewDataAxis(view,AXIS_DEEP),frame);
			while (*labelp != '=' && *labelp != '\0') labelp++;
			if (*labelp == '=') labelp++;
			else labelp = AxisScript(ViewDataAxis(view,AXIS_DEEP),frame);
			DrawText (ih,iv,TEXT_H0|TEXT_V0,labelp);
			}
		}
	MapRestoreFrame (view->map[AXIS_DEEP]);
	}

/* draw array of picked renders */
ViewDrawPicks (view)
View view;
	{
	extern Data data;
	extern Render render;
	int panel,frame, ih, iv, margins[4], save;
	string label;
	char *labelp;

	save = MapFrame(view->map[AXIS_DEEP]);
	for (panel=0; panel<view->nacross*view->ndown; panel++) {