render.c

seismic software,very useful

/*
render object code
draws raster images into various buffers
draws axis and cross-line annotations
contains optimized subroutines for rapid raster rendering
*/
#include <stdio.h>
#include "main.h"
#include "axis.h"
#include "data.h"
#include "map.h"
#include "render.h"
#include "plane.h"
#include "view.h"
#include "pick.h"
#include "rargs.h"

/* C or FORTRAN renderers */
#ifndef FORTRAN
#define RENDER_BASIC_HORZ	RenderBasicHorz CALLARGS
#define RENDER_BASIC_VERT	RenderBasicVert CALLARGS
#define RENDER_SHADOW_HORZ	RenderShadowHorz CALLARGS
#define RENDER_SHADOW_VERT	RenderShadowVert CALLARGS
#define RENDER_INTERP_HORZ	RenderInterpHorz CALLARGS
#define RENDER_INTERP_VERT	RenderInterpVert CALLARGS
#define RENDER_TRANSP_HORZ	RenderTranspHorz CALLARGS
#define RENDER_TRANSP_VERT	RenderTranspVert CALLARGS
#endif
#ifdef FORTRAN
#define RENDER_BASIC_HORZ	renderbasichorz_ FCALLARGS
#define RENDER_BASIC_VERT	renderbasicvert_ FCALLARGS
#define RENDER_SHADOW_HORZ	rendershadowhorz_ FCALLARGS
#define RENDER_SHADOW_VERT	rendershadowvert_ FCALLARGS
#define RENDER_INTERP_HORZ	renderinterphorz_ FCALLARGS
#define RENDER_INTERP_VERT	renderinterpvert_ FCALLARGS
#define RENDER_TRANSP_HORZ	rendertransphorz_ FCALLARGS
#define RENDER_TRANSP_VERT	rendertranspvert_ FCALLARGS
#endif
#define CORD3	AxisDir(MapAxis(zmap)),MapFrame(zmap),\
		AxisDir(MapAxis(map4)),MapFrame(map4),\
		AxisDir(MapAxis(map5)),MapFrame(map5)
#define CORD3P	AxisDir(MapAxis(zmap)),MapPrev(zmap),\
		AxisDir(MapAxis(map4)),MapFrame(map4),\
		AxisDir(MapAxis(map5)),MapFrame(map5)

/* initialize render object */
Render
RenderInit ()
	{
	Render render;

	NEW(Render,render,1);
	render->wide = 0;
	render->hite = 0;
	render->interp = 0;
	render->polarity = RENDER_POLARITY;
	render->fence_transp = RENDER_FENCE_TRANSP;
	render->low_transp = RENDER_LOW_TRANSP;
	render->high_transp = RENDER_HIGH_TRANSP;
	render->vol_transp = RENDER_VOL_TRANSP;
	GETPARINT ("interpolate","d",&render->interp);
	GETPARINT ("fence_transp","d",&render->fence_transp);
	GETPARINT ("vol_transp","d",&render->vol_transp);
	render->image = 0;
	render->shadow = 0;
	render->zbuffer = 0;
	return (render);
	}

/* adjust render size: reallocate buffers, adjust map axes */
RenderSize (wide,hite)
int wide, hite;
	{
	extern Render render;

	if (!render) return;
	/* reallocate buffers */
	if (wide != render->wide || hite != render->hite) {
		render->wide = wide;
		render->hite = hite;
		FREE(render->image);
		NEW(Buffer,render->image,render->wide*render->hite);
		FREE(render->zbuffer);
		NEW(Zbuffer,render->zbuffer,render->wide*render->hite);
		FREE (render->shadow);
		NEW(Shadow,render->shadow,render->wide*render->hite);
		}
	RenderClear ();
	}

/* extract plane in horizontal scan mode; given data, render buffers, three
   map attr->axes, origin, options to attr->image attr->skew, data, attr->axes, attr->shadow, and line */
RenderHorz (data,hmap,vmap,zmap,map4,map5,h0,v0,render,margins,attr)
Data data;
Map hmap, vmap, zmap, map4, map5;
Render render;
RenderAttr attr;
int h0, v0, margins[];
	{
	int x, y, transp;
	float tic;
	string label;

	if (!data || !render || !hmap || !hmap->map) return;
	attr->shadow = 1;
	/* clear previous pick */
	if (attr->pick && attr->mark==0) {
		PickDraw (PickFind(CORD3P),ERASE);
		}

	/* record plane */
	attr->orient = RENDER_HORZ;
	if (attr->image) {
		render->h0 = h0;
		render->v0 = v0;
		render->nh = MapSize (hmap) + attr->skew * (MapSize (vmap) + GAP) + attr->transp * MapSize(zmap);
		render->nh = render->wide - render->h0 < render->nh ? render->wide - render->h0 : render->nh;
		render->nv = MapSize (vmap) + attr->transp * MapSize(zmap);
		render->nv = render->hite - render->v0 < render->nv ? render->wide - render->v0 : render->nv;
		}
	if (attr->mark) PlaneSet (hmap,vmap,zmap,map4,map5,render->h0,render->v0,render->nh,render->nv,render,margins,attr);
	else {
		PlaneSetFrame (PlaneFind(CORD3P),MapFrame(zmap));
		}

	/* extract images */
	if (attr->image) {
		/* update window */
		if (attr->zbuffer) {
			if (!strcmp(MapName(zmap),"DEEP")) {
				if (render->interp) RenderFrontFenceInterpHorz CALLARGS;
				else RenderFrontFenceHorz CALLARGS;
				}
			if (!strcmp(MapName(zmap),"DOWN")) {
				if (render->interp) RenderTopFenceInterpHorz CALLARGS;
				else RenderTopFenceHorz CALLARGS;
				}
			}
		else if (attr->transp) {
			transp = render->fence_transp * DataValueSize (data) * .01;
			RENDER_TRANSP_HORZ;
			}
		else if (render->interp) RENDER_INTERP_HORZ;
		else RENDER_BASIC_HORZ;
		if (attr->shadow && !attr->zbuffer) RENDER_SHADOW_HORZ;
		}

	/* draw crosslines */
	if (attr->lines) {
		/* erase horizontal */
		x = h0 + attr->skew * (MapSize(vmap) -
			MapInverse(vmap,MapPrev(vmap)));
		y = v0 + MapInverse(vmap,MapPrev(vmap));
		DrawLine (x,y,x+MapSize(hmap),y,ERASE);
		/* erase vertical */
		x = h0 + MapInverse(hmap,MapPrev(hmap));
		DrawLine (x+attr->skew*MapSize(vmap),v0,x,v0+MapSize(vmap),ERASE);
		/* draw horizontal */
		x = h0 + attr->skew * (MapSize(vmap) -
			MapInverse(vmap,MapFrame(vmap)));
		y = v0 + MapInverse(vmap,MapFrame(vmap));
		DrawLine (x,y,x+MapSize(hmap),y,DRAW);
		/* draw vertical */
		x = h0 + MapInverse(hmap,MapFrame(hmap));
		DrawLine (x+attr->skew*MapSize(vmap),v0,x,v0+MapSize(vmap),DRAW);
		}

	/* draw box */
	if (attr->box) {
		DrawLine (h0-1+attr->skew*MapSize(vmap),v0-1,
			h0+MapSize(hmap)+attr->skew*MapSize(vmap),v0-1,DRAW);
		DrawLine (h0-1,v0+MapSize(vmap),h0+MapSize(hmap),
			v0+MapSize(vmap),DRAW);
		DrawLine (h0-1+attr->skew*(MapSize(vmap)+1),v0-1,h0-1,
			v0+MapSize(vmap),DRAW);
		DrawLine (h0+MapSize(hmap)+attr->skew*(MapSize(vmap)+1),v0-1,
			h0+MapSize(hmap),v0+MapSize(vmap),DRAW);
		}

	/* draw pick */
	if (attr->pick) {
		PickDraw (PickFind(CORD3),DRAW);
		}

	/* left tics */
	if (attr->axes&AXIS_LEFT) {
		for (tic=MapTic0(vmap); tic<=MapTic2(vmap)+.5*MapDtic(vmap);
			tic+=MapDtic(vmap)) {
			y = v0 + MapIndex (vmap,tic);
			x = h0 + attr->skew * (MapSize(vmap) - MapIndex(vmap,tic));
			sprintf (label,MapFormat(vmap),tic);
			DrawText (x-TIC_LENGTH-1,y-5,TEXT_V0|TEXT_H100,label);
			DrawLine (x-TIC_LENGTH,y,x,y,DRAW);
			}
		/* label */
		if (MapNtic(vmap) == 1) {
/*                	x = h0 - margins[MARGIN_LEFT] + attr->skew * MapSize(vmap) / 2;*/
			x = h0 - 5 + attr->skew * MapSize(vmap) / 2;
			y = v0 + MapSize(vmap) / 2;
			}
		else	{
			tic = (MapTic0(vmap) + MapTic2(vmap) +
				 (MapNtic(vmap)%2)*MapDtic(vmap)) / 2;
			y = v0 + MapIndex (vmap,tic);
/*
			x = h0 + attr->skew * (MapSize(vmap) -
				MapIndex(vmap,tic)) - margins[MARGIN_LEFT];
*/
			x = h0 - 5 + attr->skew * (MapSize(vmap) - MapIndex(vmap,tic));
			}
		DrawText (x,y,TEXT_V50|TEXT_H100,AxisLabel(MapAxis(vmap)));
		/* border line */
		DrawLine (h0-1+attr->skew*MapSize(vmap),v0,h0-1,v0+MapSize(vmap),DRAW);
		}

	/* base tics */
	if (attr->axes&AXIS_BASE) {
		for (tic=MapTic0(hmap); tic<MapTic2(hmap)+.5*MapDtic(hmap); 
			tic+=MapDtic(hmap)) {
			x = h0 + MapIndex (hmap,tic);
			y = v0 + MapSize(vmap);
			sprintf (label,MapFormat(hmap),tic);
			DrawText (x-10,y+TIC_LENGTH,TEXT_V0|TEXT_H0,label);
			DrawLine (x,y,x,y+TIC_LENGTH,DRAW);
			}
		/* label */
		if (MapNtic(hmap) == 1) {
			x = h0 + MapSize(hmap)/2;
			y = v0 + margins[MARGIN_BASE] + MapSize(vmap);
			}
		else	{
			tic = (MapTic0(hmap) + MapTic2(hmap) +
				(MapNtic(hmap)%2)*MapDtic(hmap)) / 2;
			x = h0 + MapIndex (hmap,tic);
			y = v0 + MapSize(vmap) + margins[MARGIN_BASE];
			}
		DrawText (x,y,TEXT_V100|TEXT_H50,AxisLabel(MapAxis(hmap)));
		/* border line */
		DrawLine (h0,v0+MapSize(vmap),h0+MapSize(hmap),
			v0+MapSize(vmap),DRAW);
		}
	}

/* extract panel in vertical scan line mode; permits vertical attr->skewing for side
of cubes */
RenderVert (data,hmap,vmap,zmap,map4,map5,h0,v0,render,margins,attr)
Data data;
Map hmap, vmap, zmap, map4, map5;
Render render;
RenderAttr attr;
int h0, v0, margins[];
	{
	int x, y, transp;
	float tic;
	string label;

	if (!data || !render || !hmap || !hmap->map) return;
	attr->shadow = 1;
	/* clear picks */
	if (attr->pick && attr->mark==0) {
		PickDraw (PickFind(CORD3P),ERASE);
		}

	/* record plane */
	attr->orient = RENDER_VERT;
	if (attr->image) {
		render->h0 = h0;
		render->v0 = v0 - attr->skew * (MapSize (hmap) + GAP);
		render->nh = MapSize (hmap) + attr->transp * MapSize(zmap);
		render->nv = MapSize (vmap) + attr->skew * (MapSize (hmap) + GAP) + attr->transp * MapSize(zmap);
		render->nh = render->wide - render->h0 < render->nh ? render->wide - render->h0 : render->nh;
		render->nv = render->hite - render->v0 < render->nv ? render->wide - render->v0 : render->nv;
		}
	if (attr->mark) PlaneSet (hmap,vmap,zmap,map4,map5,render->h0,render->v0,render->nh,render->nv,render,margins,attr);
	else {
		PlaneSetFrame (PlaneFind(CORD3P),MapFrame(zmap));
		}

	/* extract image */
	if (attr->image) {
		/* update window */
		if (attr->zbuffer) {
			if (!strcmp(MapName(zmap),"ACROSS")) {
				if (render->interp) RenderSideFenceInterpVert CALLARGS;
				else RenderSideFenceVert CALLARGS;
				}
			}
		else if (attr->transp) {
			transp = render->fence_transp * DataValueSize (data) * .01;
			RENDER_TRANSP_VERT;
			}
		else if (render->interp) RENDER_INTERP_VERT;
		else RENDER_BASIC_VERT;
		if (attr->shadow && !attr->zbuffer) RENDER_SHADOW_VERT;
		}

	/* draw cross lines */
	if (attr->lines) {
		/* erase horizontal line */
		y = v0 + MapInverse(vmap,MapPrev(vmap));
		DrawLine (h0,y,h0+MapSize(hmap),y-attr->skew*MapSize(hmap),ERASE);
		/* erase vertical line */
		x = h0 + MapSize(hmap) - MapInverse(hmap,MapPrev(hmap));
		y = v0 - attr->skew * (x - h0);
		DrawLine (x,y,x,y+MapSize(vmap),ERASE);
		/* draw horizontal line */
		y = v0 + MapInverse(vmap,MapFrame(vmap));
		DrawLine (h0,y,h0+MapSize(hmap),y-attr->skew*MapSize(hmap),DRAW);
		/* draw vertical line */
		x = h0 + MapSize(hmap) - MapInverse(hmap,MapFrame(hmap));
		y = v0 - attr->skew * (x - h0);
		DrawLine (x,y,x,y+MapSize(vmap),DRAW);
		}

	/* draw box */
	if (attr->box) {
		DrawLine (h0-1,v0-1,h0+MapSize(hmap),
			v0-1-attr->skew*(MapSize(hmap)+1),DRAW);
		DrawLine (h0-1,v0+MapSize(vmap)+1,h0+MapSize(hmap),
			v0+MapSize(vmap)+1-attr->skew*(MapSize(hmap)+1),DRAW);
		DrawLine (h0-1,v0,h0-1,v0+MapSize(vmap),DRAW);
		DrawLine (h0+MapSize(hmap),v0+1-attr->skew*MapSize(hmap),
		h0+MapSize(hmap),v0+1+MapSize(vmap)-attr->skew*MapSize(hmap),DRAW);
		}

	/* draw picks */
	if (attr->pick) {
		PickDraw (PickFind(CORD3),DRAW);
		}

	/* left tics */
	if (attr->axes&AXIS_LEFT) {
		for (tic=MapTic0(vmap); tic<=MapTic2(vmap)+.5*MapDtic(vmap);
			tic+=MapDtic(vmap)) {
			y = v0 + MapIndex (vmap,tic);
			x = h0;
			sprintf (label,MapFormat(hmap),tic);
			DrawText (x-TIC_LENGTH,y-5,TEXT_V0|TEXT_H100,label);
                        DrawLine (x-TIC_LENGTH,y,x,y,DRAW);
			}
		/* label */
		if (MapNtic(vmap) == 1) {
                	x = h0 - margins[MARGIN_LEFT];
			y = v0 + MapSize(vmap) / 2;
			}
		else	{
			tic = (MapTic0(vmap) + MapTic2(vmap) +
				(MapNtic(vmap)%2)*MapDtic(vmap)) / 2;
			y = v0 + MapIndex (vmap,tic);
			x = h0 + - margins[MARGIN_LEFT];
			}
		DrawText (x,y,TEXT_V50|TEXT_H0,AxisLabel(MapAxis(vmap)));
		/* border line */
		DrawLine (h0-1,v0,h0-1,v0+MapSize(vmap),DRAW);
		}

	/* base tics */
	if (attr->axes&AXIS_BASE) {
		for (tic=MapTic0(hmap); tic<=MapTic2(hmap)+.5*MapDtic(hmap);
			tic+=MapDtic(hmap)) {
			x = h0 + MapSize(hmap) - MapIndex (hmap,tic);
			y = v0 + MapSize(vmap) - attr->skew * (MapSize(hmap) -
				MapIndex(hmap,tic));
			sprintf (label,MapFormat(hmap),tic);
			if (attr->skew) {
				DrawText (x+TIC_LENGTH+1,y,TEXT_V50|TEXT_H0,label);
				DrawLine (x,y,x+TIC_LENGTH,y,DRAW);
				}
			else	{
				DrawText (x-10,y+TIC_LENGTH,TEXT_V0|TEXT_H0,label);
				DrawLine (x,y,x,y+TIC_LENGTH,DRAW);
				}
			}
		/* label */
		if (MapNtic(hmap) == 1) {
			x = h0 + MapSize(hmap)/2;
			y = v0 + (attr->skew>0?0:1) * margins[MARGIN_BASE] +
				MapSize(vmap) - attr->skew * MapSize(hmap)/2;
			}
		else	{
			tic = (MapTic0(hmap) + MapTic2(hmap) +
				(MapNtic(hmap)%2)*MapDtic(hmap)) / 2;
			x = h0 + MapSize(hmap) - MapIndex (hmap,tic);
			y = v0 + MapSize(vmap) + (attr->skew>0?0:1) *
				margins[MARGIN_BASE] - attr->skew * (MapSize(hmap) -
				MapIndex(hmap,tic));
			}
		if (attr->skew) DrawText (x,y+TIC_LENGTH,TEXT_V0|TEXT_H0,
			AxisLabel(MapAxis(hmap)));
		else DrawText (x,y,TEXT_V100|TEXT_H50,AxisLabel(MapAxis(hmap)));
		/* border line */
		DrawLine (h0,v0+MapSize(vmap),h0+MapSize(hmap),
			v0+MapSize(vmap)-attr->skew*MapSize(hmap),DRAW);
		}
	}

/* extract plane along pick line */
RenderDeep (data,hmap,vmap,zmap,map4,map5,h0,v0,render,margins,attr)
Data data;
Map hmap, vmap, zmap, map4, map5;
Render render;
RenderAttr attr;
int h0, v0, margins[];
	{
	Map_ hmap1, vmap1, zmap1;
	extern PickLine lastpick;
	int ipick, idim, rmap;
	float arclen, darc, dlen, dseg, seglen[NPICK], interp;
	extern double sqrt();

	if (!lastpick || PickCount(lastpick) < 2) return;  /* no active pick */
	/* compute new map maps based on supplied maps */
	/* hmap is zmap resized into zmap */
	/* vmap is replaced by pick map */
	/* zmap is inactive */
	hmap1 = *zmap;
	vmap1 = *vmap;
	zmap1 = *zmap;

	FREE (vmap1.map);
	NEW (Vec,vmap1.map,MapSize(&vmap1));
	hmap1.map = 0;
	MapSetSize (&hmap1,MapSize(&zmap1));
	zmap1.frame = 0;

	/* compute pick segment length in samples */
	for (ipick=1; ipick<PickCount(lastpick)-1; ipick++) {
		for (seglen[ipick]=0, idim=0; idim<3; idim++) {
			seglen[ipick] += (PickIndex(lastpick,ipick,idim) - 
				PickIndex(lastpick,ipick+1,idim)) *
				(PickIndex(lastpick,ipick,idim)-
				PickIndex(lastpick,ipick-1,idim));
			}
		seglen[ipick] = sqrt (seglen[ipick]);
		arclen += seglen[ipick];
		}
	/* compute interpolation axis */
	dlen = arclen / MapSize(&vmap1);
	for (darc=0, dseg=0, rmap=0, ipick=0; rmap<MapSize(&vmap1);
		rmap++, dseg+=dlen){
		/* check to see if in new segment of arc */
		if (dseg >= darc) {
			darc += seglen[ipick];
			ipick++;
			}
		/* interption along current arc segment */
		interp = (darc - dseg) / seglen[ipick-1];
		vmap1.map[rmap] = 0;
		/* add up interptional data offsets of two pick dimensions */
		for (idim=1; idim<4; idim++) {
			/* skip perpendicular dimension */
			if (idim != PickDir(lastpick)) {
				vmap1.map[rmap] += (int)(interp *
					 PickIndex(lastpick,ipick,idim) +
					(1.-interp) * PickIndex(lastpick,ipick-1,idim)) * 
					AxisStride(DataAxis(data,idim));
				}
			}
		}
	/* plot it */
	attr->orient = RENDER_DEEP;
	RenderHorz (data,&hmap1,&vmap1,&zmap1,h0,v0,render,margins,attr);
/*	(attr)	0,0,1,AXIS_BASE,1,1,1,0,margins*/
	}

/* return buffer value */
RenderBufferValue (render,x,y)
Render render;
int x, y;
	{
	if (!render) return (0);

	return (render->image[render->wide*y+x]);
	}

/* return shadow value */
RenderShadowValue (render,x,y)
Render render;
int x, y;
	{
	if (!render) return (NO_INDEX);

	if (x < 0 || x >= render->wide || y < 0 || y >= render->hite) return (NO_INDEX);
	return (render->shadow[render->wide*y+x]);
	}

/* return buffer */
Buffer
RenderBuffer (render)
Render render;
	{

	if (!render) return (0);
	return (render->image);
	}

/* draw render */
RenderDraw ()
	{
	extern Render render;

	if (!render || UIFirst()) return;
	DrawMask (254);
	if (MovieRun()) {
		DrawImage (render,render->h0,render->v0,render->nh,render->nv);
		}
	else	{
		DrawImage (render,0,0,render->wide,render->hite);
		}
	}

/* print render information */
RenderInfo (render)
Render render;
	{
	Message message;

	if (!render) return;
	sprintf (message,"Render: wide=%d hite=%d interpolate=%d fence_transp=%d low_transp=%d high_transp=%d vol_transp=%d",
		render->wide,
		render->hite,
		render->interp,
		render->fence_transp,
		render->low_transp,
		render->high_transp,
		render->vol_transp);
	UIMessage (message);
	}

/* save render parameters */
RenderSavePar ()
	{
	Message message;
	extern Render render;

	if (!render) return;
	sprintf (message,"Render: wide=%d hite=%d interpolate=%d fence_transp=%d low_transp=%d high_transp=%d vol_transp=%d",
		render->wide,
		render->hite,
		render->interp,