region.c

seismic software,very useful

/*
Identifies and processes continginous region between bounds starting at a seed.
There are three definitions of continginous: 6 faces +- 12 edges +- 8 corners.
The eighth bit of the data bytes stores the region mark.
*/
#include <stdio.h>
#include "main.h"
#include "axis.h"
#include "data.h"
#include "render.h"
#include "region.h"

REgion region;

/* initialize region object */
RegionInit ()
	{
	extern Data data;
	extern REgion region;
	int n1, n2, n3, iaxis;

	NEW (REgion,region,1);
	region->live = 1;
	region->neighborhood = MARK_FACE | MARK_EDGE | MARK_CORNER;
	region->bound[0] = 0;
	region->bound[1] = 0;
	for (iaxis=DATA_AXIS0; iaxis<=DATA_AXIS3; iaxis++) region->seed[iaxis] = NO_INDEX;
	n1 = AxisSize (DataAxis(data,DATA_AXIS0));
	n2 = AxisSize (DataAxis(data,DATA_AXIS1));
	n3 = AxisSize (DataAxis(data,DATA_AXIS2));
	region->nlist = 4 * (n1 * n2 + n2 * n3 + n3 * n1);
	NEW (Shadow,region->list,region->nlist);
	region->size = 0;
	region->save = 0;
	region->index = 0;
	}

/* turn on region picking callback */
RegionSetLive (live)
int live;
	{
	extern REgion region;

	if (!region) return;
	region->live = live;
	}

/* set bound */
RegionSetBound (index,ibound)
int index, ibound;
	{
	extern REgion region;

	if (!region) return;
	if (ibound < 0 || ibound > 1) return;
	region->bound[ibound] = index;
	}

/* set region neighborhood mode callback */
RegionSetNeighborhood (mode)
int mode;
	{
	extern REgion region;
	
	if (!region) return;
	if (region->neighborhood != mode) {
		region->neighborhood = mode;
		RegionMark0 ();
		}
	}

/* set region seed callback */
RegionSetSeed (seed)
int seed[4];
	{
	int iaxis;
	extern REgion region;
	extern Data data;

	if (!region) return;
	if (!region->live) return;
	for (iaxis=DATA_AXIS0; iaxis<=DATA_AXIS3; iaxis++) region->seed[iaxis] = seed[iaxis];
	UNMARK(region->seed[DATA_VALUE]);
	}

/* return bound */
RegionBound (ibound)
int ibound;
	{
	if (!region) return (NO_INDEX);
	if (ibound < 0 || ibound > 1) return (NO_INDEX);
	return (region->bound[ibound]);
	}

/* return region size */
RegionSize ()
	{
	if (!region) return (NO_INDEX);
	return (region->size);
	}

/* mark a region callback */
RegionMark0 ()
	{
	extern REgion region;
	extern Data data;
	Message message;

	if (!region) return;
	if (!region->live) return;
	if (region->seed[DATA_AXIS1] == NO_INDEX) return;
	region->size = RegionMark (DataBuffer(data),
		AxisSize(DataAxis(data,DATA_AXIS1)),
		AxisSize(DataAxis(data,DATA_AXIS2)),
		AxisSize(DataAxis(data,DATA_AXIS3)),
		region->seed[DATA_AXIS1],
		region->seed[DATA_AXIS2],
		region->seed[DATA_AXIS3],
		region->bound[0]<region->bound[1]?region->bound[0]:region->bound[1],
		region->bound[0]>region->bound[1]?region->bound[0]:region->bound[1],
		region->neighborhood,
		region->list,
		region->nlist);
	if (region->size) ViewDrawAll();
	sprintf (message,"Region: min=%g max=%g size=%d",
		DataValue (data,region->bound[0]),
		DataValue (data,region->bound[1]),
		region->size);
	UIMessage (message);
	}

/* fill a region with a value callback */
RegionFill (seed,bound1,bound2,value)
int seed[4], bound1, bound2, value;
	{
	int iaxis;
	extern REgion region;
	extern Data data;
	Message message;

	if (!region) return;
	for (iaxis=DATA_AXIS0; iaxis<=DATA_AXIS3; iaxis++) region->seed[iaxis] = seed[iaxis];
	region->bound[0] = bound1;
	region->bound[1] = bound2;
	region->size = RegionMark (DataBuffer(data),
		AxisSize(DataAxis(data,DATA_AXIS1)),
		AxisSize(DataAxis(data,DATA_AXIS2)),
		AxisSize(DataAxis(data,DATA_AXIS3)),
		region->seed[DATA_AXIS1],
		region->seed[DATA_AXIS2],
		region->seed[DATA_AXIS3],
		region->bound[0],
		region->bound[1],
		region->neighborhood,
		region->list,
		region->nlist);
	if (region->size) {
		RegionSetValue (value,value);
		RegionClear ();
		}
	sprintf (message,"Region: min=%g max=%g size=%d",
		DataValue (data,region->bound[0]),
		DataValue (data,region->bound[1]),
		region->size);
	UIMessage (message);
	}

/* clear region marks in data */
RegionClear ()
	{
	extern Data data;
	register Buffer datap, edata;

	if (!region || !data) return;
	for (datap=DataBuffer(data), edata=datap+DataSize(data); datap<edata;) {
		UNMARK (*datap++);
		}
	if (region->size > 0) {
		ViewDrawAll ();
		}
	}

/* set all marked cells to value */
RegionSetValue (bound1,bound2)
int bound1, bound2;
	{
	extern Data data;
	unsigned char _table[256];
	register Buffer datap, edata, savep, buf, table;
	register Shadow indexp;
	int ibound;

	if (!region || !data) return;
	if (bound1 == NO_INDEX) return;
	/* initialize table */
	if (region->bound[0] < region->bound[1]) {
		for (ibound=region->bound[0]; ibound<=region->bound[1]; ibound++) {
			_table[ibound] = bound1 + (ibound*(bound2-bound1))/(region->bound[1]-region->bound[0]);
			}
		}
	else if (region->bound[0] > region->bound[1]) {
		for (ibound=region->bound[1]; ibound<=region->bound[0]; ibound++) {
			_table[ibound] = bound1 + (ibound*(bound2-bound1))/(region->bound[1]-region->bound[0]);
			}
		}
	else _table[region->bound[0]] = bound2;
	table = _table;
	FREE (region->index);
	FREE (region->save);
	NEW (Shadow,region->index,region->size);
	NEW (byte,region->save,region->size);
	buf = DataBuffer(data);
	indexp = region->index;
	savep = region->save;
	for (datap=buf, edata=datap+DataSize(data); datap<edata; datap++) {
		if (ISMARK(*datap)) {
			*indexp++ = datap - buf;
			*savep = (*datap) & 0x7F;
			*datap = table[*savep++];
			}
		}
	}

/* undo last region smoothing */
RegionRestoreValue ()
	{
	extern REgion region;
	extern Data data;
	register Buffer datap, savep, endp;
	register Shadow indexp;

	if (!region) return;
	if (region->size == 0) {
		UIMessage ("no smoothing or can only unsmooth once");
		return;
		}
	indexp = region->index;
	datap = DataBuffer (data);
	savep = region->save;
	endp = savep + region->size;
	for (; savep<endp;) {
		datap[*indexp++] = *savep++;
		}
	region->size = 0;
	FREE (region->index);
	FREE (region->save);
	}

/* return message about geion callback */
RegionInfo ()
	{
	Message message;

	sprintf (message, "Region: live=%d size=%d bound1=%d bound2=%d seed=(%d,%d,%d) value=%d neighborhood=%d nlist=%d",
		region->live,
		region->size,
		region->bound[0],
		region->bound[1],
		region->seed[DATA_AXIS1],
		region->seed[DATA_AXIS2],
		region->seed[DATA_AXIS3],
		region->seed[DATA_VALUE],
		RegionNeighbors(),
		region->nlist);
	UIMessage (message);
	}

/* count neighbors */
RegionNeighbors ()
	{
	return (
		(region->neighborhood & MARK_FACE)/MARK_FACE * 6 +
		(region->neighborhood & MARK_EDGE)/MARK_EDGE * 12 +
		(region->neighborhood & MARK_CORNER)/MARK_CORNER * 8
		);
	}

/* save region parameters */
RegionSavePar ()
	{
	Message message;

	sprintf (message, "Region: seed=%d,%d,%d value=%d neighborhood=%d",
		region->seed[DATA_AXIS1],
		region->seed[DATA_AXIS2],
		region->seed[DATA_AXIS3],
		region->seed[DATA_VALUE],
		region->neighborhood);
	UISaveMessage (message);
	}

/* mark contiguous voxels, given seed, min and max;
   continginous defined by mode: MARK_FACE=6, MARK_EDGE=12, MARK_CORNER=8
   list returned; nlist is maximum size
 */
RegionMark (data,size1,size2,size3,seed1,seed2,seed3,min,max,neighborhood,list,nlist)
Buffer data;
Shadow list;
int nlist;
int size1, size2, size3;