pick.c

seismic software,very useful

	PickDraw (pickline,DRAW);
	}

/* replace nearest pick */
PickReplace (x,y)
int x, y;
	{
	PickLine pickline;
	int i, j, span, metric, near, inear;
	PickPoint_ pick;

	/* recover set */
	PickDecode (x,y,&pick,1);
	if (PICKDIR(pick.,AXIS_DEEP) == NO_INDEX) return;
	if ((pickline = PickFind (PICKDIR(pick.,AXIS_DEEP),PICKFRAME(pick.,AXIS_DEEP),
		PICKDIR(pick.,AXIS_4D),PICKFRAME(pick.,AXIS_4D),
		PICKDIR(pick.,AXIS_5D),PICKFRAME(pick.,AXIS_5D))) == 0) return;
	if (pickline->npick == 0) return;
	PickDraw (pickline,ERASE);
	near = 1000000;
	inear = 0;
	for (i=0; i<pickline->npick; i++) {
		metric = 0;
		for (j=1; j<DATA_NAXIS; j++) {
			span = (pickline->index[i][j] - pick.index[j]);
			metric += span * span;
			}
		if (metric < near) {
			near = metric;
			inear = i;
			}
		}
	for (j=0; j<DATA_NAXIS; j++) {
		pickline->index[inear][j] = pick.index[j];
		}
	PickDraw (pickline,DRAW);
	}

/* delete nearest pick */
PickDelete (x,y)
int x, y;
	{
	PickLine pickline;
	int i, j, span, metric, near, inear;
	PickPoint_ pick;

	/* recover set */
	PickDecode (x,y,&pick,1);
	if (PICKDIR(pick.,AXIS_DEEP) == NO_INDEX) return;
	if ((pickline = PickFind (PICKDIR(pick.,AXIS_DEEP),PICKFRAME(pick.,AXIS_DEEP),
		PICKDIR(pick.,AXIS_4D),PICKFRAME(pick.,AXIS_4D),
		PICKDIR(pick.,AXIS_5D),PICKFRAME(pick.,AXIS_5D))) == 0) return;
	if (pickline->npick < 2) {
		PickClear (pickline);
		return;
		}
	PickDraw (pickline,ERASE);
	near = 1000000;
	inear = 0;
	for (i=0; i<pickline->npick; i++) {
		metric = 0;
		for (j=1; j<DATA_NAXIS; j++) {
			span = (pickline->index[i][j] - pick.index[j]);
			metric += span * span;
			}
		if (metric < near) {
			near = metric;
			inear = i;
			}
		}
	for (i=inear; i<pickline->npick-1; i++) {
		for (j=0; j<DATA_NAXIS; j++) {
			pickline->index[i][j] = pickline->index[i+1][j];
			}
		}
	pickline->npick--;
	PickDraw (pickline,DRAW);
	}

/* end pick enable */
PickDraw (pickline,draw)
PickLine pickline;
int draw;
	{
	Plane plane;
	int ipick, x, y, x0, y0, x1, y1, x2, y2, hskew=0, vskew=0;

	if (!pickline) return;
	if ((plane = PlaneFind(PICKDIR(pickline->,AXIS_DEEP),PICKFRAME0(pickline->,AXIS_DEEP),
		PICKDIR(pickline->,AXIS_4D),PICKFRAME0(pickline->,AXIS_4D),
		PICKDIR(pickline->,AXIS_5D),PICKFRAME0(pickline->,AXIS_5D))) == 0) return;
	if (PlaneType(plane) == RENDER_HORZ) hskew = PlaneSkew(plane);
	else vskew = PlaneSkew(plane);
	for (ipick=0; ipick<pickline->npick; ipick++) {
		x = MapInverse(PlaneHmap(plane),
		pickline->index[ipick][AxisDir(MapAxis(PlaneHmap(plane)))]);
		if (PlaneType(plane) == RENDER_VERT) {
			x = MapSize(PlaneHmap(plane)) - x;
			}
		y = MapInverse(PlaneVmap(plane),
		pickline->index[ipick][AxisDir(MapAxis(PlaneVmap(plane)))]);
		if (x != NO_INDEX && y != NO_INDEX) {
			x1 = x + PlaneH0(plane) + hskew * (MapSize(PlaneVmap(plane)) - y);
			y1 = y + PlaneV0(plane) + vskew * (PlaneNH(plane) - x);
			if (!ipick) DrawLine (x1-1,y1-1,x1,y1,draw);
			else if (x0 != NO_INDEX && y0 != NO_INDEX) {
				x2 = x0 + PlaneH0(plane) + hskew * 
					(MapSize(PlaneVmap(plane)) - y0);
				y2 = y0 + PlaneV0(plane) + vskew * (PlaneNH(plane) - x0);
				DrawLine (x1,y1,x2,y2,draw);
				}
			}
		x0 = x;
		y0 = y;
		}
	}

/* draw all pick sets */
PickDrawAll (draw)
int draw;
	{
	int iset;

	for (iset=0; iset<PICKNLIST; iset++) {
		if (picklist[iset]) PickDraw (picklist[iset],draw);
		}
	}

/* read pick file */
PickRead ()
	{
	FILE *fd, *fopen();
	extern Data data;
	string dummy, line;
	int iset=0, ipick, i, dir, frame, n1, n2, n3, n4, n5;
	float value[DATA_NAXIS];
	Message message;

	if (!data) return;
	if (GETPARSTRING ("annotate","s",pickfile) == 0) return;
	if ((fd = fopen (pickfile,"r")) == NULL) {
		UIMessage ("cant open pick file");
		return;
		}
	fgets (line,sizeof(line),fd);
/*
	fgets (line,sizeof(line),fd);
	sscanf (line,"%s %d %d %d %d %d",dummy,&n1,&n2,&n3,&n4,&n5);
	if (n1 != AxisSize(DataAxis(data,DATA_AXIS1))
	 || n2 != AxisSize(DataAxis(data,DATA_AXIS2)) 
	 || n3 != AxisSize(DataAxis(data,DATA_AXIS3)) 
	 || n4 != AxisSize(DataAxis(data,DATA_AXIS4)) 
	 || n5 != AxisSize(DataAxis(data,DATA_AXIS5))  ){
		UIMessage ("pick file wrong shape");
		return;
		}
*/
	fgets (line,sizeof(line),fd);
	while (fgets (line,sizeof(line),fd) != NULL) {
		if (!strncmp (line,"Pick#",5)) {
			iset++;
			NEW (PickLine,picklist[iset],1);
			sscanf (line,"%s %s %s %d %d %d %d %d",dummy,dummy,dummy,
				&PICKDIR(picklist[iset]->,AXIS_DOWN),
				&PICKDIR(picklist[iset]->,AXIS_ACROSS),
				&PICKDIR(picklist[iset]->,AXIS_DEEP),
				&PICKDIR(picklist[iset]->,AXIS_4D),
				&PICKDIR(picklist[iset]->,AXIS_5D),
				&PICKDIR(picklist[iset]->,AXIS_5D));
			picklist[iset]->npick = 0;
			}
		else	{
			if (picklist[iset]->npick < NPICK) {
				sscanf (line,"%f %f %f %f %f %f",
					&value[DATA_AXIS1],
					&value[DATA_AXIS2],
					&value[DATA_AXIS3],
					&value[DATA_AXIS4],
					&value[DATA_AXIS5],
					&value[DATA_VALUE]);
				for (i=1; i<DATA_NAXIS; i++) {
					picklist[iset]->index[picklist[iset]->npick][i] =
						AxisIndex(DataAxis(data,i),value[i]);
					}
				picklist[iset]->index[picklist[iset]->npick][DATA_VALUE] = value[DATA_VALUE];
				picklist[iset]->npick++;
				}
			}
		}
	fclose (fd);
	sprintf (message, "%d picklines read from %s", iset,pickfile);
	UIMessage (message);
	}

/* write pick file */
PickWrite ()
	{
	int iset, ipick, isave;
	extern FILE *outstream;
	FILE *fd;
	extern Data data;
	extern View view;
	Message message;

	if (picklist[0] == 0) return;
	if (!strcmp (pickfile,"stdio")) {
		fd = outstream;
		}
	else	{
		fd = fopen (pickfile,"w");
		}
	lseek (fd,0,0);
	fprintf (fd,"Picks for dataset: %s\n",DataTitle(data));
/*
	fprintf (fd,"Dimensions: %d %d %d %d %d\n",
		AxisSize(DataAxis(data,DATA_AXIS1)),
		AxisSize(DataAxis(data,DATA_AXIS2)),
		AxisSize(DataAxis(data,DATA_AXIS3)),
		AxisSize(DataAxis(data,DATA_AXIS4)),
		AxisSize(DataAxis(data,DATA_AXIS5)));
*/
	fprintf (fd,"%9s: %9s: %9s: %9s: %9s: %9s:\n",
	AxisLabel(DataAxis(data,DATA_AXIS1)),
	AxisLabel(DataAxis(data,DATA_AXIS2)),
	AxisLabel(DataAxis(data,DATA_AXIS3)),
	AxisLabel(DataAxis(data,DATA_AXIS4)),
	AxisLabel(DataAxis(data,DATA_AXIS5)),
	AxisLabel(DataAxis(data,DATA_AXIS0)));
	for (iset=0, isave=0; iset < PICKNLIST; iset++) {
		if (picklist[iset] && picklist[iset]->npick > 0) {
			fprintf (fd,"Pick# %d axis# %d %d %d %d %d %s\n",
				isave++,
				PICKDIR(picklist[iset]->,AXIS_DOWN),
				PICKDIR(picklist[iset]->,AXIS_ACROSS),
				PICKDIR(picklist[iset]->,AXIS_DEEP),
				PICKDIR(picklist[iset]->,AXIS_4D),
				PICKDIR(picklist[iset]->,AXIS_5D),
				AxisScript(DataAxis(data,PICKDIR(picklist[iset]->,AXIS_DEEP)),
				picklist[iset]->index[AXIS_DEEP]));
			for (ipick=0; ipick<picklist[iset]->npick; ipick++) {
				fprintf (fd,"%10g %10g %10g %10g %10g %10g\n",
				AxisValue (DataAxis(data,DATA_AXIS1),
					picklist[iset]->index[ipick][DATA_AXIS1]),
				AxisValue (DataAxis(data,DATA_AXIS2),
					picklist[iset]->index[ipick][DATA_AXIS2]),
				AxisValue (DataAxis(data,DATA_AXIS3),
					picklist[iset]->index[ipick][DATA_AXIS3]),
				AxisValue (DataAxis(data,DATA_AXIS4),
					picklist[iset]->index[ipick][DATA_AXIS4]),
				AxisValue (DataAxis(data,DATA_AXIS5),
					picklist[iset]->index[ipick][DATA_AXIS5]),
				(float)picklist[iset]->index[ipick][DATA_VALUE]);
				}
			}
		}
	fclose (fd);
	sprintf (message, "%d pick lines save in %s",isave,pickfile);
	UIMessage (message);
	}

/* remove set from pick list */
PickClear (pickline)
PickLine pickline;
	{
	int iset;

	if (!pickline) return;
	PickDraw (pickline,ERASE);
	for (iset=0; iset<PICKNLIST; iset++) {
		if (pickline == picklist[iset]) {
			FREE (picklist[iset]);
			picklist[iset] = 0;
			return;
			}
		}
	lastpick = 0;
	}

/* clear current pick */
PickClear0 ()
	{
	PickClear (lastpick);
	}

/* set pick frame */
PickSetFrame (index)
int index;
	{
	PickLine pickline;
	int iset;

	if (index < 0 || index > PickSize()) return;
	for (iset=0; iset<PICKNLIST; iset++) {
		if (picklist[iset]) index--;
		if (index < 0) {
			pickline = picklist[iset];
			break;
			}
		}
	if (iset == PICKNLIST) return;
	ViewSetMovie (PICKDIR(pickline->,AXIS_DEEP));
	ViewSetFrame (pickline->index[AXIS_DEEP],FRAME_ACTUAL);
	PickDraw (pickline);
	}

/* print a list of picks */
PickListInfo ()
	{
	int iset;

	printf ("Pick list:\n");
	for (iset= -1; iset<PICKNLIST; iset++) {
		if (picklist[iset]) printf ("dir=%d frame=%d\n",
			PICKDIR(picklist[iset]->,AXIS_DEEP),PICKFRAME0(picklist[iset]->,AXIS_DEEP));
		}
	}

/* save pick parameters */
PickSavePar ()
	{
	Message message;
	extern PickLine lastpick;

	if (!lastpick) return;
	sprintf (message,"Pick: nset=%d pickdir=%d pickframe=%d npick=%d pick=%s",
		PickSize(),
		PICKDIR(lastpick->,AXIS_DEEP),
		lastpick->index[AXIS_DEEP],
		lastpick->npick,
		pickfile);
	UISaveMessage (message);
	}

/* returns two picks are in same frame */
PickSameFrame (pick1,pick2)
PickPoint pick1, pick2;
	{
	return ((pick1->iaxis[AXIS_DOWN] == pick2->iaxis[AXIS_DOWN]) &&
		(pick1->iaxis[AXIS_ACROSS] == pick2->iaxis[AXIS_ACROSS]) &&
		(pick1->iaxis[AXIS_DEEP] == pick2->iaxis[AXIS_DEEP]) &&
		(pick1->iaxis[AXIS_4D] == pick2->iaxis[AXIS_4D]) &&
		(pick1->iaxis[AXIS_5D] == pick2->iaxis[AXIS_5D]) &&
		(pick1->index[pick1->iaxis[AXIS_DEEP]] == pick2->index[pick2->iaxis[AXIS_DEEP]]) &&
		(pick1->index[pick1->iaxis[AXIS_4D]] == pick2->index[pick2->iaxis[AXIS_4D]]) &&
		(pick1->index[pick1->iaxis[AXIS_5D]] == pick2->index[pick2->iaxis[AXIS_5D]]));
	}

/* returns two picks are same direction */
PickSameDir (pick1,pick2)
PickPoint pick1, pick2;
	{
	return ((pick1->iaxis[AXIS_DEEP] == pick2->iaxis[AXIS_DEEP]) &&
		(pick1->iaxis[AXIS_4D] == pick2->iaxis[AXIS_4D]) &&
		(pick1->iaxis[AXIS_5D] == pick2->iaxis[AXIS_5D]));
	}

/* returns direction of shared coordinate: 0, pick->iaxis[1] or pick->iaxis[2] */
PickSharedDir (pick1,pick2)
PickPoint pick1, pick2;
	{
	return (PickSameFrame (pick1,pick2) *
		(((pick1->index[pick1->iaxis[AXIS_DOWN]] == pick2->index[pick2->iaxis[AXIS_DOWN]])
		* pick1->iaxis[AXIS_DOWN]) +
		((pick1->index[pick1->iaxis[AXIS_ACROSS]] == pick2->index[pick2->iaxis[AXIS_ACROSS]])
		* pick1->iaxis[AXIS_ACROSS])));
	}

/* return non-zero if a is between b and c; angle a-b-c < 90; a is nearer to b */
PickBetween (a,b,c)
int *a, *b, *c;
	{
	int i;
	int ra=0, rb=0, rc=0;

	for (i=0; i<DATA_NAXIS; i++) {
		ra += (b[i] - c[i]) * (b[i] - c[i]);
		rb += (a[i] - c[i]) * (a[i] - c[i]);
		rc += (a[i] - b[i]) * (a[i] - b[i]);
		}
	return (rb < (ra + rc));
	}