/* JRG, the Resource Geology Seismic Processing System for Java,
   and Viewmat for Java are Copyright 1998-2007 by John N. Louie

License is hereby granted for anyone to make any use of this software and
its associated source and compiled binary codes, including free re-distribution,
and incorporation into commercial products, provided this copyright notice
is retained within all files, versions, and distribution media substantially
incorporating John Louie's original work.

The software and methods here are the subject of academic research,
not commercial products. I would like to know what use you make of
my methods, and have your feedback on their success or failure.
Also, by letting me know who you are, I can inform you if bugs or
errors are discovered.
 
Please send me an email message with: your name and email address;
whether you are a student or faculty member, consultant or employee;
the name of your university or company, and department; and a sentence
or two describing what use you intend to make of these methods.
Send your message to louie@seismo.unr.edu */


import java.util.*;
import java.io.*;
import java.lang.Math;
import java.net.*;
import java.awt.*;
import java.awt.image.*;
import java.awt.event.*;
import java.applet.Applet;

class testplane
	{
	public static void main(String args[])
		{
		int i;
		
		FltPlane fltplane = new FltPlane(210, 1000);
		fltplane.readBinaryFile("test.flt", 0);
		float rms = fltplane.rms();
		fltplane.viewinFrame("test.flt", true, (0.001F*2000F/2F)/15.24F,
			RgCtab.rwb, false, 3F*rms);
		
		FltPlane fp = new FltPlane(100, 178);
		fp.readBinaryFile("dixie-migvels", 0);	
		fp.addc(-(fp.min()));
		fp.viewinFrame("dixie-migvels", false, 1F, RgCtab.yglobe, true, -1F);
		}
	}

public class FltPlane extends FltVec
	{
	public int ne;
	public int vecs;
	public String VecUnits;
	public float Vec0;
	public float DVec;
	public Viewmat fpviewmat;
	public RgHead headers[];
	public boolean geogr;
	
	public static Menu makeMethodsMenu(FltVol fvol)
		{
		Menu methods = new Menu("On Each Vector", true);
		methods.add(new MenuItem("agc"));
		methods.add(new MenuItem("ale"));
		methods.add(new MenuItem("autocor"));
		methods.add(new MenuItem("bpfilter"));
		methods.add(new MenuItem("conv2to3d"));
		methods.add(new MenuItem("ctr"));
		if (fvol == null)
			methods.add(new MenuItem("cutTime"));
		if (fvol == null)
			methods.add(new MenuItem("decimate"));
		methods.add(new MenuItem("demult"));
		methods.add(new MenuItem("despike"));
		methods.add(new MenuItem("differentiate"));
		if (fvol == null)
			methods.add(new MenuItem("dipfil"));
		methods.add(new MenuItem("fixCoords"));
		methods.add(new MenuItem("hann"));
		if (fvol == null)
			methods.add(new MenuItem("mirror"));
		if (fvol == null)
			methods.add(new MenuItem("pad"));
		methods.add(new MenuItem("powerspectra"));
		if (fvol == null)
			methods.add(new MenuItem("reduceT"));
		methods.add(new MenuItem("rev"));
		methods.add(new MenuItem("setHeader"));
		if (fvol == null)
			methods.add(new MenuItem("shade"));
		methods.add(new MenuItem("slant"));
		if (fvol == null)
			methods.add(new MenuItem("smooth"));
		if (fvol == null)
			methods.add(new MenuItem("sort"));
		if (fvol == null)
			methods.add(new MenuItem("stackHits"));
		methods.add(new MenuItem("sweep"));
		methods.add(new MenuItem("sweepTrig"));
		methods.add(new MenuItem("tegain"));
		methods.add(new MenuItem("tracedit"));
		if (fvol == null)
			methods.add(new MenuItem("vspect"));
		if (fvol == null)
			methods.add(new MenuItem("window"));
		methods.add(new MenuItem("xcor"));
		if (fvol == null)
			methods.add(new MenuItem("xcorInterf"));
		/* Add new FltPlane methods below: */
		
		return methods;
		}
	public static void handleMethod(ViewmatFrame f, boolean inplace, String label)
		{
		f.setCursor(Cursor.WAIT_CURSOR);
		boolean redimension;
		redimension = false;
		boolean clipmax;
		clipmax = true;
		String title = f.vm.title + " + " + label;
		ViewmatAction vad = new ViewmatAction(f);
		vad.beginPanel();
		if (label.equals("agc"))
			FltPlane.agcPanel(vad, f, inplace, label);
		else if (label.equals("ale"))
			FltPlane.alePanel(vad, f, inplace, label);
		else if (label.equals("autocor"))
			FltPlane.autocorPanel(vad, f, inplace, label);
		else if (label.equals("bpfilter"))
			FltPlane.bpfilterPanel(vad, f, inplace, label);
		else if (label.equals("conv2to3d"))
			FltPlane.conv2to3dPanel(vad, f, inplace, label);
		else if (label.equals("ctr"))
			FltPlane.ctrPanel(vad, f, inplace, label);
		else if (label.equals("cutTime"))
			{
			inplace = false;
			FltPlane.cutTimePanel(vad, f, inplace, label);
			}
		else if (label.equals("decimate"))
			{
			inplace = false;
			FltPlane.decimatePanel(vad, f, inplace, label);
			}
		else if (label.equals("demult"))
			{
			inplace = false;
			redimension = true;
			FltPlane.demultPanel(vad, f, inplace, label);
			}
		else if (label.equals("despike"))
			FltPlane.despikePanel(vad, f, inplace, label);
		else if (label.equals("differentiate"))
			FltPlane.differentiatePanel(vad, f, inplace, label);
		else if (label.equals("dipfil"))
			FltPlane.dipfilPanel(vad, f, inplace, label);
		else if (label.equals("fixCoords"))
			{
			inplace = true;
			FltPlane.fixCoordsPanel(vad, f, inplace, label);
			}
		else if (label.equals("hann"))
			FltPlane.hannPanel(vad, f, inplace, label);
		else if (label.equals("mirror"))
			FltPlane.mirrorPanel(vad, f, inplace, label);
		else if (label.equals("pad"))
			{
			inplace = false;
			FltPlane.padPanel(vad, f, inplace, label);
			}
		else if (label.equals("powerspectra"))
			{
			inplace = false;
			redimension = true;
			FltPlane.powerspectraPanel(vad, f, inplace, label);
			}
		else if (label.equals("reduceT"))
			{
			inplace = false;
			FltPlane.reduceTPanel(vad, f, inplace, label);
			}
		else if (label.equals("rev"))
			FltPlane.revPanel(vad, f, inplace, label);
		else if (label.equals("setHeader"))
			{
			inplace = true;
			FltPlane.setHeaderPanel(vad, f, inplace, label);
			}
		else if (label.equals("shade"))
			FltPlane.shadePanel(vad, f, inplace, label);
		else if (label.equals("slant"))
			{
			inplace = false;
			redimension = true;
			FltPlane.slantPanel(vad, f, inplace, label);
			}
		else if (label.equals("smooth"))
			FltPlane.smoothPanel(vad, f, inplace, label);
		else if (label.equals("sort"))
			{
			inplace = true;
			FltPlane.sortPanel(vad, f, inplace, label);
			}
		else if (label.equals("stackHits"))
			{
			inplace = false;
			FltPlane.stackHitsPanel(vad, f, inplace, label);
			}
		else if (label.equals("sweep"))
			{
			inplace = false;
			redimension = true;
			FltPlane.sweepPanel(vad, f, inplace, label);
			}
		else if (label.equals("sweepTrig"))
			{
			inplace = false;
			redimension = true;
			FltPlane.sweepTrigPanel(vad, f, inplace, label);
			}
		else if (label.equals("tegain"))
			FltPlane.tegainPanel(vad, f, inplace, label);
		else if (label.equals("tracedit"))
			FltPlane.traceditPanel(vad, f, inplace, label);
		else if (label.equals("vspect"))
			{
			Class haveReMi = null;
			try { haveReMi = Class.forName("ReMi"); }
			catch (ClassNotFoundException cnfe)
				{ haveReMi = null; }
			if (haveReMi == null)
				{
				f.Errout("ReMi not licensed to this system.\n"
				+ "Please contact John N. Louie at louie@seismo.unr.edu\n"
				+ "for licensing information.");
				vad.dispose();
				f.setCursor(Cursor.DEFAULT_CURSOR);
				return;
				}
			else
				{
				inplace = false;
				ReMi.vspectPanel(vad, f, inplace, label);
				}
			}
		else if (label.equals("window"))
			{
			inplace = false;
			FltPlane.windowPanel(vad, f, inplace, label);
			}
		else if (label.equals("xcor"))
			FltPlane.xcorPanel(vad, f, inplace, label);
		else if (label.equals("xcorInterf"))
			FltPlane.xcorInterfPanel(vad, f, inplace, label);
		/* Add new FltPlane methods below: */
		
		if (inplace)
			vad.setTitle(label + " on " + f.getTitle() + " in-place");
		else
			vad.setTitle(label + " on " + f.getTitle() + " to new window");
		Button apply = new Button(label);
		vad.pp.add(apply);
		apply.addActionListener(vad);
		vad.finishPanel();
		f.setCursor(Cursor.DEFAULT_CURSOR);
		vad.center();
		vad.show();
		if (vad.done == false)
			{
			vad.dispose();
			return;
			}
		f.setCursor(Cursor.WAIT_CURSOR);
		FltPlane fp = null;
		FltPlane ofp = null;
		FltPlane tfp = null;
		FltVol fvol = null;
		MethodRun mrun = null;
		if (vad.noticeonly == true)
			{
			if (f.vm.fvol == null)
				fp = f.vm.fp;
			else
				fp = f.vm.fvol;
			}
		else if (inplace)
			{
			if (f.vm.fvol == null)
				{
				ofp = f.vm.fp;
				fp = new FltPlane(f.vm.fp, f.vm.fp.vec);
				}
			else
				{
				ofp = f.vm.fvol;
				fp = new FltPlane(f.vm.fvol, f.vm.fvol.vec);
				}
			}
		else
			{
			if (!redimension)
				{
				if (f.vm.fvol == null)
					{
					mrun = new MethodRun(f.vm.fp, f.fd.getDirectory(),
						title, f.vm.rowsdown,
						f.vm.ve, f.vm.ctab, f.vm.positive, f.vm.clip);
					ofp = mrun.fp;
					fp = new FltPlane(mrun.fp, mrun.fp.vec);
					}
				else
					{
					mrun = new MethodRun(f.vm.fvol, f.fd.getDirectory(),
						title, f.vm.rowsdown,
						f.vm.ve, f.vm.ctab, f.vm.positive, f.vm.clip);
					ofp = mrun.fvol;
					fp = new FltPlane(mrun.fvol, mrun.fvol.vec);
					}
				}
			}
		if (label.equals("agc"))
			{
			fp.doagc(vad);
			clipmax = false;
			}
		else if (label.equals("ale"))
			fp.doale(vad);
		else if (label.equals("autocor"))
			fp.autocor();
		else if (label.equals("bpfilter"))
			fp.dobpfilter(vad);
		else if (label.equals("conv2to3d"))
			fp.doconv2to3d(vad);
		else if (label.equals("ctr"))
			fp.ctr();
		else if (label.equals("cutTime"))
			{
			tfp = fp.docutTime(vad);
			ofp.vec = new float[tfp.vec.length];
			ofp.copyvals(tfp);
			fp.copyvals(tfp);
			ofp.copyvec(tfp);
			tfp.vec = null;
			tfp = null;
			}
		else if (label.equals("decimate"))
			{
			tfp = fp.dodecimate(vad);
			ofp.vec = new float[tfp.vec.length];
			ofp.copyvals(tfp);
			fp.copyvals(tfp);
			ofp.copyvec(tfp);
			tfp.vec = null;
			tfp = null;
			}
		else if (label.equals("demult"))
			{
			if (f.vm.fvol == null)
				fp = f.vm.fp.demult();
			else
				fp = f.vm.fvol.demult();
			mrun = new MethodRun(fp, f.fd.getDirectory(),
				title, f.vm.rowsdown,
				f.vm.ve, f.vm.ctab, f.vm.positive, f.vm.clip);
			}
		else if (label.equals("despike"))
			fp.dodespike(vad);
		else if (label.equals("differentiate"))
			fp.dodifferentiate(vad);
		else if (label.equals("dipfil"))
			fp.dodipfil(vad);
		else if (label.equals("fixCoords"))
			fp.dofixCoords(vad);
		else if (label.equals("hann"))
			fp.dohann(vad);
		else if (label.equals("mirror"))
			fp.domirror(vad);
		else if (label.equals("pad"))
			{
			tfp = fp.dopad(vad);
			mrun = new MethodRun(tfp, f.fd.getDirectory(),
				title, f.vm.rowsdown,
				f.vm.ve, f.vm.ctab, f.vm.positive, f.vm.clip);
			}
		else if (label.equals("powerspectra"))
			{
			if (f.vm.fvol == null)
				{
				fp = new FltPlane(f.vm.fp, f.vm.fp.vec);
				fp.dopowerspectra(vad);
				mrun = new MethodRun(fp, f.fd.getDirectory(),
					title, f.vm.rowsdown,
					f.vm.ve, RgCtab.yglobe, true, fp.max());
				}
			else
				{
				fvol = new FltVol(f.vm.fvol, f.vm.fvol.vec);
				fvol.dopowerspectra(vad);
				mrun = new MethodRun(fvol, f.fd.getDirectory(),
					title, f.vm.rowsdown,
					f.vm.ve, RgCtab.yglobe, true, fvol.max());
				}
			}
		else if (label.equals("reduceT"))
			{
			tfp = fp.doreduceT(vad);
			ofp.vec = new float[tfp.vec.length];
			ofp.copyvals(tfp);
			fp.copyvals(tfp);
			ofp.copyvec(tfp);
			tfp.vec = null;
			tfp = null;
			}
		else if (label.equals("rev"))
			fp.rev();
		else if (label.equals("setHeader"))
			fp.dosetHeader(vad);
		else if (label.equals("shade"))
			{
			fp.doshade(vad);
			clipmax = true;
			/*
			f.vm.positive = true;
			f.vm.ctab = RgCtab.gray;
			*/
			}
		else if (label.equals("slant"))
			{
			if (f.vm.fvol == null)
				fp = f.vm.fp.doslant(vad);
			else
				fp = f.vm.fvol.doslant(vad);
			mrun = new MethodRun(fp, f.fd.getDirectory(),
				title, f.vm.rowsdown,
				f.vm.ve, f.vm.ctab, f.vm.positive, f.vm.clip);
			}
		else if (label.equals("smooth"))
			fp.dosmooth(vad);
		else if (label.equals("sort"))
			fp.dosort(vad);
		else if (label.equals("stackHits"))
			{
			tfp = fp.dostackHits(vad);
			if (tfp == null)
				{
				vad.dispose();
				f.setCursor(Cursor.DEFAULT_CURSOR);
				return;
				}
			ofp.vec = new float[tfp.vec.length];
			ofp.copyvals(tfp);
			fp.copyvals(tfp);
			ofp.copyvec(tfp);
			tfp.vec = null;
			tfp = null;
			}
		else if (label.equals("sweep"))
			{
			if (f.vm.fvol == null)
				fp = f.vm.fp.dosweep(vad);
			else
				fp = f.vm.fvol.dosweep(vad);
			mrun = new MethodRun(fp, f.fd.getDirectory(),
				title, f.vm.rowsdown,
				f.vm.ve, f.vm.ctab, false, fp.max());
			}
		else if (label.equals("sweepTrig"))
			{
			if (f.vm.fvol == null)
				fp = f.vm.fp.dosweepTrig(vad);
			else
				fp = f.vm.fvol.dosweepTrig(vad);
			mrun = new MethodRun(fp, f.fd.getDirectory(),
				title, f.vm.rowsdown,
				f.vm.ve, f.vm.ctab, false, fp.max());
			}
		else if (label.equals("tegain"))
			{
			fp.tegain();
			clipmax = false;
			}
		else if (label.equals("tracedit"))
			fp.dotracedit(vad);
		else if (label.equals("vspect"))
			{
			tfp = ReMi.dovspectSum(fp, vad);
			ofp.vec = new float[tfp.vec.length];
			ofp.copyvals(tfp);
			fp.copyvals(tfp);
			ofp.copyvec(tfp);
			tfp.vec = null;
			tfp = null;
			mrun.rowsdown = false;
			mrun.ve = 2.5F*ofp.ne/ofp.vecs/4.2F;
			mrun.positive = true;
			mrun.clip = 2.5F /*ofp.max()*/;
			mrun.ctab = RgCtab.yglobe;
			}
		else if (label.equals("window"))
			{
			tfp = fp.dowindow(vad);
			ofp.vec = new float[tfp.vec.length];
			ofp.copyvals(tfp);
			fp.copyvals(tfp);
			ofp.copyvec(tfp);
			tfp.vec = null;
			tfp = null;
			}
		else if (label.equals("xcor"))
			fp.doxcor(vad);
		else if (label.equals("xcorInterf"))
			fp.doxcorInterf(vad);
		/* Add new FltPlane methods below: */
		
		if (vad.noticeonly == true)
			{
			vad.dispose();
			f.setCursor(Cursor.DEFAULT_CURSOR);
			return;
			}
		vad.dispose();
		if (!redimension)
			ofp.copyvals(fp);
		if (inplace)
			{
			f.setTitle(title);
			f.props.setTitle(title + " Properties");
			f.picks.setTitle(title + " Picks");
			f.geom.setTitle(title + " Geometry");
			f.vm.titletf.setText(title);
			f.vm.cvs.vmat.title = new String(title);
			f.vm.cvs.zoom(f.vm.fzoom);
			f.vm.resetPropsPanel(f.props, f.props.pp);
			f.vm.setParameters(f.props, f.props.pp);
			if (f.vm.fvol == null)
				{
				if (!clipmax)
					f.vm.cvs.vmat.clip = 3*f.vm.fp.rms();
				f.vm.fp.replotinFrame(f);
				}
			else
				{
				if (!clipmax)
					f.vm.cliptf.setText("3*rms");
				f.props.applyChanges();
				}
			}
		else
			{
			if (!clipmax)
				mrun.clip = 3F*fp.rms();
			/* altered 3/1/06 JNL to workaround MacOS 10.4 bug
			   thanks to Leiph Preston!
			new Thread(mrun).start();
			*/
			mrun.run();
			}
		f.setCursor(Cursor.DEFAULT_CURSOR);
		return;
		}
	
	/* put implementations of new FltPlane methods below: */
	
	public void agc(int Window, boolean Detect, int DetectWindow, float Threshold)
		{
		Notice("FltPlane.agc: gaining " + this.vecs + " vectors of " + this.ne
			+ " elements by L1 norm of " + Window + "-element moving"
			+ " window; Detect=" + Detect + "... ");
		for (int j=0; j<vecs; j++)
			this.agc(j*ne, ne, Window, Detect, DetectWindow, Threshold);
		if (Window == this.ne && Detect == false)
			this.AmpUnits = this.AmpUnits + " after Trace-Equalize";
		else
			this.AmpUnits = this.AmpUnits + " after AGC";
		Noticeln("done.");
		}
	static void agcPanel(ViewmatAction vad, ViewmatFrame f,
		boolean inplace, String label)
		{
		int ne, twin=200, tdwin=10;
		vad.expl = new TextArea(label + " of " + f.getTitle()
			+ (inplace ? " in-place\n" : " in new window\n")
			+ "\n"
			+ "The " + label + " method on class FltPlane data\n"
			+ "irreversibly gains each vector by the L1 norm\n"
			+ "of a moving window. Parameters below:\n"
			+ "Window is the length in elements of the moving window.\n"
			+ "Detect if checked will detect the first significant energy "
			+ "by comparing a short moving window with an initial "
			+ "average, and set the output ahead of detection to zero.\n"
			+ "DetectWindow is the length in elements of the detection window.\n"
			+ "Threshold is the amplitude factor over the initial average "
			+ "required for detection.",
			5, 35);
		vad.pp.add(vad.expl);
		if (f.vm.fvol == null)
			ne = f.vm.fp.ne;
		else
			ne = f.vm.fvol.ne;
		if (ne < twin)
			twin = ne/5;
		if (twin < tdwin)
			tdwin = twin/5;
		vad.lab0 = new Label("Window Length (pos. integer):");
		vad.pp.add(vad.lab0);
		vad.tf0 = new TextField("" + twin, 8);
		vad.pp.add(vad.tf0);
		vad.cb0 = new Checkbox("Detect Initial Energy?");
		vad.pp.add(vad.cb0);
		vad.cb0.setState(false);
		vad.lab1 = new Label("DetectWindow (pos. integer):");
		vad.pp.add(vad.lab1);
		vad.tf1 = new TextField("" + tdwin, 8);
		vad.pp.add(vad.tf1);
		vad.lab2 = new Label("Threshold (pos. float):");
		vad.pp.add(vad.lab2);
		vad.tf2 = new TextField("25.0", 8);
		vad.pp.add(vad.tf2);
		}
	public void doagc(ViewmatAction vad)
		{
		int temp, twin=200, tdwin=10;
		float htemp, thresh=25F;
		boolean detect;
		try {temp = Integer.valueOf(vad.tf0.getText()).intValue(); }
		catch (NumberFormatException nfe)
			{temp = twin; }
		twin = temp;
		if (this.ne < twin)
			twin = this.ne;
		detect = vad.cb0.getState();
		if (detect)
			{
			try {temp = Integer.valueOf(vad.tf1.getText()).intValue(); }
			catch (NumberFormatException nfe)
				{temp = tdwin; }
			tdwin = temp;
			if (twin < tdwin)
				tdwin = twin/2;
			try {htemp = Float.valueOf(vad.tf2.getText()).floatValue(); }
			catch (NumberFormatException nfe)
				{htemp = thresh; }
			if (htemp < 0)
				htemp = -htemp;
			thresh = htemp;
			}
		this.agc(twin, detect, tdwin, thresh);
		}
	static void tegainPanel(ViewmatAction vad, ViewmatFrame f,
		boolean inplace, String label)
		{
		vad.expl = new TextArea(label + " of " + f.getTitle()
			+ (inplace ? " in-place\n" : " in new window\n")
			+ "\n"
			+ "The " + label + " method on class FltPlane data\n"
			+ "irreversibly gains each vector by the L1 norm\n"
			+ "of the whole trace. It is equivalent to an AGC\n"
			+ "with the window length set to the trace length.",
			5, 35);
		vad.pp.add(vad.expl);
		}
	public void tegain()
		{
		agc(this.ne, false, 10, 25F);
		}
	
	/*	Ale.c	Adaptive Line Enhancement prediction error filtering.
	Translated to C by J. Louie 10/12/93
	Adapted for Java and JRG by J. Louie 10/9/2000
		nw=100		number of weights
		ndel=30		samples of decorrelation delay
		icon=true		false: stationary weights
				true: time-varying weights
		alpha=0.001	convergence parameter
		beta=0.999	smoothing parameter
		eps=0.0001	minimum input power
	This program implements adaptive line enhancer
	using  TDL structure.
	9/20/93		Byong Kun Chang, UNR EE
	Algorithm:  W(k+1) = W(k)+(alpha/var)e(k)X(k)
		    where W(k) is weight vector at time k
		          e(k) is error signal at time k
		          X(k) is input signal vector at time k
	                      var is the estimate of input power. */
	public void ale(int nw, int ndel, boolean icon, float alpha, float beta,
		float eps)
       		{
		int nx, nd;
		int i, k, l, IW;
		float b1=0F, var;
		Notice("FltPlane.ale: computing adaptive line enhancement on " + this.ne
			+ " elements in " + this.vecs + " vectors... ");
		nx = this.vecs;
		nd = this.ne;
		if (icon)
			{
			b1 = 1F - beta;
			var = 0F;
			}
		 else
			var = 1F;
		float x[] = new float[nd+ndel+nw];
		float yo[] = new float[nd];
		float e[] = new float[nd];
		float w[] = new float[nw];
		IW = ndel + nw;
		for (l=0; l<nx; l++) /* loop through traces */
			{
			/* initialization */
			for (i= -IW; i<=0; i++)
				x[i+IW] = 0F;
			for (k=0; k<nw; k++)
				w[k] = 0F;
			/* copy input */
			for (i=0; i<nd; i++)
				x[IW+i] = getElem(l, i);
			/* main loop */
			for (i=0; i<nd; i++)
				{
				/* multichannel TDL output */
				yo[i] = 0F;
				for (k=0; k<nw; k++)
					yo[i] = yo[i] + w[k]*x[i+IW-k-ndel];
				/* generate final output */
				e[i] = x[i+IW] - yo[i];
				/* update filter coefficients by LMS (Least Mean Square) algorithm */
				if (icon)
					{
					var = beta*var + b1*x[i+IW-ndel]*x[i+IW-ndel];
					if (var < eps)
						var = eps;
					}
				for (k=0; k<nw; k++)
					w[k] = w[k] + alpha*e[i]*x[i+IW-k-ndel]/var;
				}
			/* copy output */
			for (i=0; i<nd; i++)
				setElem(l, i, e[i]);
			if (l==0 || l==1 || l==20 || l==50 || l==100 || l==200
			|| l==500 || l%1000 == 0)
				Noticeln("Processed trace " + (l+1) + " of " + nx);
			}
		this.AmpUnits = this.AmpUnits + " after ALE";
		Noticeln("done.");
		}
	public void ale()
		{
		ale(100, 30, true, 0.001F, 0.999F, 0.0001F);
		}
	static void alePanel(ViewmatAction vad, ViewmatFrame f,
		boolean inplace, String label)
		{
		int nw=100, ndel=30, temp;
		boolean icon=true;
		float alpha=0.001F, beta=0.999F, eps=0.0001F, htemp;
		vad.expl = new TextArea(label + " of " + f.getTitle()
			+ (inplace ? " in-place\n" : " in new window\n")
			+ "\n"
			+ "The " + label + " method on class FltPlane data\n"
			+ "implements the adaptive line enhancer with\n"
			+ "TDL structure of Byong Kun Chang, UNR EE, 9/20/93,\n"
			+ "separately on each vector.\n"
			+ "Algorithm:  W(k+1) = W(k)+(alpha/var)e(k)X(k)\n"
			+ "where W(k) is weight vector at time k\n"
			+ "e(k) is error signal at time k\n"
			+ "X(k) is input signal vector at time k\n"
			+ "var is the estimate of input power.\n",
			5, 35);
		vad.pp.add(vad.expl);
		vad.lab0 = new Label("Number of Weights (pos. integer):");
		vad.pp.add(vad.lab0);
		vad.tf0 = new TextField("" + nw, 6);
		vad.pp.add(vad.tf0);
		vad.lab1 = new Label("Decorrelation Delay Samples (+int):");
		vad.pp.add(vad.lab1);
		vad.tf1 = new TextField("" + ndel, 4);
		vad.pp.add(vad.tf1);
		vad.lab2 = new Label("Convergence Parameter (pos. float):");
		vad.pp.add(vad.lab2);
		vad.tf2 = new TextField("" + alpha, 6);
		vad.pp.add(vad.tf2);
		vad.cb0 = new Checkbox("Time-Varying Weights?");
		vad.pp.add(vad.cb0);
		vad.cb0.setState(true);
		vad.lab3 = new Label("Smoothing Parameter (pos. float):");
		vad.pp.add(vad.lab3);
		vad.tf3 = new TextField("" + beta, 6);
		vad.pp.add(vad.tf3);
		vad.lab4 = new Label("Minimum Input Power (pos. float):");
		vad.pp.add(vad.lab4);
		vad.tf4 = new TextField("" + eps, 6);
		vad.pp.add(vad.tf4);
		}
	public void doale(ViewmatAction vad)
		{
		int nw=100, ndel=30, temp;
		boolean icon=true;
		float alpha=0.001F, beta=0.999F, eps=0.0001F, htemp;
		try {temp = Integer.valueOf(vad.tf0.getText()).intValue(); }
		catch (NumberFormatException nfe)
			{temp = nw; }
		if (temp < 0)
			temp = -temp;
		if (temp < 0 || temp > 1000*this.ne)
			temp = nw;
		nw = temp;
		try {temp = Integer.valueOf(vad.tf1.getText()).intValue(); }
		catch (NumberFormatException nfe)
			{temp = ndel; }
		if (temp < 0)
			temp = -temp;
		if (temp < 0 || temp > 1000*this.ne)
			temp = ndel;
		ndel = temp;
		try {htemp = Float.valueOf(vad.tf2.getText()).floatValue(); }
		catch (NumberFormatException nfe)
			{htemp = alpha; }
		if (htemp < 0F)
			htemp = -htemp;
		if (htemp == 0F)
			htemp = alpha;
		alpha = htemp;
		icon = vad.cb0.getState();
		try {htemp = Float.valueOf(vad.tf3.getText()).floatValue(); }
		catch (NumberFormatException nfe)
			{htemp = beta; }
		if (htemp < 0F)
			htemp = -htemp;
		if (htemp == 0F)
			htemp = beta;
		beta = htemp;
		try {htemp = Float.valueOf(vad.tf4.getText()).floatValue(); }
		catch (NumberFormatException nfe)
			{htemp = eps; }
		if (htemp < 0F)
			htemp = -htemp;
		if (htemp == 0F)
			htemp = eps;
		eps = htemp;
		this.ale(nw, ndel, icon, alpha, beta, eps);
		}
	
	static void autocorPanel(ViewmatAction vad, ViewmatFrame f,
		boolean inplace, String label)
		{
		vad.expl = new TextArea(label + " of " + f.getTitle()
			+ (inplace ? " in-place\n" : " in new window\n")
			+ "\n"
			+ "The " + label + " method on class FltPlane data\n"
			+ "separately computes the autocorrelation of\n"
			+ "each trace, without any scaling.",
			5, 35);
		vad.pp.add(vad.expl);
		}
	public void autocor()
		{
		Noticeln("Autocorrelating " + this.vecs + " vectors of "
			+ this.ne + " elements each...");
		for (int j=0; j<this.vecs; j++)
			{
			this.autocor(j*this.ne, this.ne);
			if (j==0 || j==1 || (j+1)%20 == 0)
				Noticeln("\ttrace " + (j+1) + " of " + this.vecs + " done.");
			}
		this.setAmpUnits("Autocorrelated " + this.AmpUnits);
		this.setUnitsofDim(0, "Lag " + this.getUnitsofDim(0));
		Noticeln("Autocor done.");
		}
	static void xcorPanel(ViewmatAction vad, ViewmatFrame f,
		boolean inplace, String label)
		{
		vad.expl = new TextArea(label + " of " + f.getTitle()
			+ (inplace ? " in-place\n" : " in new window\n")
			+ "\n"
			+ "The " + label + " method on class FltPlane data\n"
			+ "cross-correlates each trace of the curent data\n"
			+ "against the first trace of the selected file.\n"
			+ "If the file has the same total number of traces\n"
			+ "as the current data, corresponding traces are\n"
			+ "individually correlated.",
			5, 35);
		vad.pp.add(vad.expl);
		setupReadBinaryFile(vad, f, inplace, label, false);
		}
	public void doxcor(ViewmatAction vad)
		{
		boolean eqnx;
		FltPlane fp = readEqualFile(vad, false);
		if (fp == null)
			{
			Errout("Could not crosscorrelate the selected file against the current data.");
			return;
			}
		if (this.vecs == fp.vecs)
			eqnx = true;
		else
			eqnx = false;
		Noticeln("Correlating " + this.vecs + " vectors of "
			+ this.ne + " elements each against "
			+ (eqnx ? "all vectors" : "first vector") + " of "
			+ vad.nametf.getText() + " ... ");
		for (int j=0; j<this.vecs; j++)
			{
			this.xcor(j*this.ne, this.ne, fp, (eqnx ? j : 0)*fp.ne, fp.ne);
			if (j==0 || j==1 || (j+1)%20 == 0)
				Noticeln("\ttrace " + (j+1) + " of " + this.vecs + " done.");
			}
		this.setAmpUnits("Correlated " + this.AmpUnits);
		fp = null;
		Noticeln("Xcor done.");
		}
	static void xcorInterfPanel(ViewmatAction vad, ViewmatFrame f,
		boolean inplace, String label)
		{
		int nvec;
		if (f.vm.fvol == null)
			nvec = f.vm.fp.vecs;
		else
			nvec = f.vm.fvol.vecs;
		vad.expl = new TextArea(label + " of " + f.getTitle()
			+ (inplace ? " in-place\n" : " in new window\n")
			+ "\n"
			+ "The " + label + " method on class FltPlane data\n"
			+ "cross-correlates each trace of the curent data\n"
			+ "against the single trace at the designated\n"
			+ "index.",
			5, 35);
		vad.pp.add(vad.expl);
		vad.lab0 = new Label("Trace Index (0-" + (nvec-1) + "):");
		vad.pp.add(vad.lab0);
		vad.tf0 = new TextField("0", 4);
		vad.pp.add(vad.tf0);
		}
	public void doxcorInterf(ViewmatAction vad)
		{
		int index=0, temp;
		int nvec = this.vecs;
		try {temp = Integer.valueOf(vad.tf0.getText()).intValue(); }
		catch (NumberFormatException nfe)
			{temp = index; }
		if (temp < 0)
			temp = 0;
		if (temp > nvec-1)
			temp = nvec-1;
		index = temp;
		Noticeln("Cross-correlating " + this.vecs + " vectors of "
			+ this.ne + " elements each against trace at index "
			+ index + " ... ");
		FltPlane trace = new FltPlane(1, this.ne);
		trace.setNoticeOn(false);
		trace.windowof(this, index, 1, 0, 1);
		for (int j=0; j<this.vecs; j++)
			{
			this.xcor(j*this.ne, this.ne, trace, 0, trace.ne);
			if (j==0 || j==1 || (j+1)%20 == 0)
				Noticeln("\ttrace " + (j+1) + " of " + this.vecs + " done.");
			}
		this.setAmpUnits("Cross-correlated " + this.AmpUnits);
		trace = null;
		Noticeln("XcorInterf done.");
		if (this.headers == null)
			return;
		for (int i=0; i<nvec; i++)
			{
			headers[i].svp = headers[index].gvp;
			headers[i].sx = headers[index].gx;
			headers[i].sy = headers[index].gy;
			headers[i].sz = headers[index].gz;
			headers[i].off = headers[i].calcOffset(this.geogr);
			headers[i].allset = true;
			}
		}
	
	public void bpfilter(float dt, int pad, float flowdown, float flowup,
		float fhighup, float fhighdown, int spect)
		{
		ComplexVec cdata;
		ComplexVec temp=null;
		FltVec tfv=null;
		FltPlane tfp=null;
		int MAX, HALF, lowdown, lowup, highup, highdown, nx, nt;
		nx = this.vecs;
		nt = this.ne;
		int  j, t, t1;
		float df;
		if (pad < 1)
			{
			Errout("bpfilter: pad=" + pad + "; must be 1 or greater");
			return;
			}
		MAX = ComplexVec.getPowerof2(nt*pad);
		HALF = MAX/2;
		df = 0.5F/dt/HALF;
		lowdown = (int)(flowdown/df);
		lowup = (int)(flowup/df);
		highdown = (int)(fhighdown/df);
		highup = (int)(fhighup/df);
		if ((!(0 <= lowdown) || !(lowdown <= lowup) || !(lowup <= highup)
			|| !(highup <= highdown) || !(highdown <= HALF)) && spect != 1
			&& spect != 2)
			{
			Errout("bpfilter: 0<=lowdown<=lowup<=highup<=highdown<="
				+ (HALF*df) + " must be true");
			return;
			}
		cdata = new ComplexVec(MAX);
		cdata.setDUnitofDim(0, this.getDUnitofDim(0));
		if (spect == 1 || spect == 2)
			{
			temp = new ComplexVec(HALF);
			tfv = new FltVec(HALF);
			tfp = new FltPlane(nx, HALF);
			temp.setNoticeOn(false);
			tfv.setNoticeOn(false);
			tfp.setNoticeOn(false);
			Noticeln("powespectra: transforming " + nx + " vectors of " + MAX
				+ " elements to the Fourier domain... ");
			}
		else
			Noticeln("bpfilter: filtering " + nx + " vectors of " + MAX
				+ " elements in the Fourier domain... ");
		for (j=0; j<nx; j++)
			{
			for (t=0; t<nt; t++)
				{
				cdata.vec[t].re = this.vec[j*nt+t];
				cdata.vec[t].im = 0F;
				}
			for (t=nt; t<MAX; t++)
				{
				cdata.vec[t].re = 0F;
				cdata.vec[t].im = 0F;
				}
			ComplexVec.filt(cdata, lowdown, lowup, highup, highdown, spect);
			if (spect == 1 || spect == 2)
				{
				temp.windowof(cdata, 0, 1);
				temp.powtoFltVec(tfv);
				tfv.tileto(tfp, j, 0, 1);
				if ((j+1)%20 == 0)
					Noticeln("powerspectra: transformed vector " + (j+1) + " of " + nx + ".");
				}
			else
				{
				for (t=0; t<nt; t++)
					this.vec[j*nt+t] = cdata.vec[t].re;
				if ((j+1)%20 == 0)
					Noticeln("bpfilter: filtered vector " + (j+1) + " of " + nx + ".");
				}
			}
		if (spect == 1 || spect == 2)
			{
			this.ne = HALF;
			this.vec = new float[this.ne*nx];
			this.copyvec(tfp);
			temp = null;
			tfv = null;
			tfp = null;
			this.Amp0 *= this.Amp0;
			this.AmpFac *= this.AmpFac;
			this.AmpUnits = "Power of " + this.AmpUnits;
			this.Elem0 = 0F;
			this.DElem = df;
			this.ElemUnits = "Frequency, Hz";
			Noticeln("powerspectra done.");
			}
		else
			{
			this.AmpUnits = this.AmpUnits + " after " + flowup + "-"
				+ fhighup + " Hz BP Filter";
			Noticeln("bpfilter done.");
			}
		cdata = null;
		}
	static void bpfilterPanel(ViewmatAction vad, ViewmatFrame f,
		boolean inplace, String label)
		{
		int pad=2;
		float dt, ld=0F, lu=0F, hu, hd;
		if (f.vm.fvol == null)
			dt = f.vm.fp.DElem;
		else
			dt = f.vm.fvol.DElem;
		hu = 0.5F/dt;
		hd = hu;
		vad.expl = new TextArea(label + " of " + f.getTitle()
			+ (inplace ? " in-place\n" : " in new window\n")
			+ "\n"
			+ "The " + label + " method on class FltPlane data\n"
			+ "irreversibly bandpass filters each vector\n"
			+ "through scaling by a trapezoidal, tapered\n"
			+ "frequency band in the Fourier domain.\n"
			+ "Parameters below:\n"
			+ "Pad, a positive integer factor, enlarges each "
			+ "vector to prevent Fourier wraparound artifacts; "
			+ "larger values demand more time and memory.\n"
			+ "Dt, the sampling interval between elements, "
			+ "in seconds, should be supplied or corrected.\n"
			+ "Low, Down is the complete-cut low frequency, in Hz.\n"
			+ "Low, Up is the top of the low-cut ramp, in Hz.\n"
			+ "High, Up is the top of the high-cut ramp, in Hz.\n"
			+ "High, Down is the complete-cut high frequency, in Hz.\n"
			+ "0<=(Low, Down)<=(Low, Up)<=(High, Up)<=(High, Down)"
			+ "<=Nyquist=0.5/dt must be true.",
			5, 35);
		vad.pp.add(vad.expl);
		vad.lab0 = new Label("Pad (pos. integer):");
		vad.pp.add(vad.lab0);
		vad.tf0 = new TextField("" + pad, 2);
		vad.pp.add(vad.tf0);
		vad.lab1 = new Label("Dt (sec., pos. float):");
		vad.pp.add(vad.lab1);
		vad.tf1 = new TextField("" + dt, 6);
		vad.pp.add(vad.tf1);
		vad.lab2 = new Label("0< Low, Down (Hz, pos. float):");
		vad.pp.add(vad.lab2);
		vad.tf2 = new TextField("" + ld, 6);
		vad.pp.add(vad.tf2);
		vad.lab3 = new Label("< Low, Up:");
		vad.pp.add(vad.lab3);
		vad.tf3 = new TextField("" + lu, 6);
		vad.pp.add(vad.tf3);
		vad.lab4 = new Label("< High, Up:");
		vad.pp.add(vad.lab4);
		vad.tf4 = new TextField("" + hu, 6);
		vad.pp.add(vad.tf4);
		vad.lab5 = new Label("< High, Down:");
		vad.pp.add(vad.lab5);
		vad.tf5 = new TextField("" + hd, 6);
		vad.pp.add(vad.tf5);
		vad.lab6 = new Label("<Nyquist");
		vad.pp.add(vad.lab6);
		vad.height = 400;
		}
	public void dobpfilter(ViewmatAction vad)
		{
		int pad;
		float htemp, dt, ld, lu, hu, hd;
		try {pad = Integer.valueOf(vad.tf0.getText()).intValue(); }
		catch (NumberFormatException nfe)
			{pad = 2; }
		if (pad == 0)
			pad = 1;
		else if (pad < 0)
			pad = -pad;
		try {htemp = Float.valueOf(vad.tf1.getText()).floatValue(); }
		catch (NumberFormatException nfe)
			{
			if (vad.f.vm.fvol == null)
				htemp = vad.f.vm.fp.DElem;
			else
				htemp = vad.f.vm.fvol.DElem;
			}
		if (htemp == 0F)
			{
			if (vad.f.vm.fvol == null)
				htemp = vad.f.vm.fp.DElem;
			else
				htemp = vad.f.vm.fvol.DElem;
			}
		else if (htemp < 0F)
			htemp = -htemp;
		dt = htemp;
		try {htemp = Float.valueOf(vad.tf2.getText()).floatValue(); }
		catch (NumberFormatException nfe)
			{htemp = 0F; }
		if (htemp < 0F)
			htemp = -htemp;
		ld = htemp;
		try {htemp = Float.valueOf(vad.tf3.getText()).floatValue(); }
		catch (NumberFormatException nfe)
			{htemp = 0F; }
		if (htemp < 0F)
			htemp = -htemp;
		lu = htemp;
		try {htemp = Float.valueOf(vad.tf4.getText()).floatValue(); }
		catch (NumberFormatException nfe)
			{htemp = 0.5F/dt; }
		if (htemp < 0F)
			htemp = -htemp;
		hu = htemp;
		try {htemp = Float.valueOf(vad.tf5.getText()).floatValue(); }
		catch (NumberFormatException nfe)
			{htemp = 0.5F/dt; }
		if (htemp < 0F)
			htemp = -htemp;
		hd = htemp;
		this.bpfilter(dt, pad, ld, lu, hu, hd, 0);
		}
	public void powerspectra(float dt)
		{
		this.bpfilter(dt, 1, 0F, 0F, 1F, 1F, 1);
		}
	static void powerspectraPanel(ViewmatAction vad, ViewmatFrame f,
		boolean inplace, String label)
		{
		vad.expl = new TextArea(label + " of " + f.getTitle()
			+ " in new window\n"
			+ "(Cannot be done in-place.)\n"
			+ "The " + label + " method on class FltPlane data\n"
			+ "computes the power spectrum of each\n"
			+ "vector separately. Dt, the sampling interval\n"
			+ "between elements, in seconds, should be\n"
			+ "supplied or corrected",
			5, 35);
		vad.pp.add(vad.expl);
		vad.lab0 = new Label("Dt (seconds, positive float):");
		vad.pp.add(vad.lab0);
		if (f.vm.fvol == null)
			vad.tf0 = new TextField("" + f.vm.fp.DElem, 8);
		else
			vad.tf0 = new TextField("" + f.vm.fvol.DElem, 8);
		vad.pp.add(vad.tf0);
		}
	public void dopowerspectra(ViewmatAction vad)
		{
		float htemp;
		try {htemp = Float.valueOf(vad.tf0.getText()).floatValue(); }
		catch (NumberFormatException nfe)
			{
			if (vad.f.vm.fvol == null)
				htemp = vad.f.vm.fp.DElem;
			else
				htemp = vad.f.vm.fvol.DElem;
			}
		if (htemp == 0F)
			{
			if (vad.f.vm.fvol == null)
				htemp = vad.f.vm.fp.DElem;
			else
				htemp = vad.f.vm.fvol.DElem;
			}
		else if (htemp < 0F)
			htemp = -htemp;
		this.powerspectra(htemp);
		}
		
	/* Derived from ltop.c by John Vidale 8/11/85 and adapted by J. Louie, 2007 */
	public void conv2to3d()
		{
		conv2to3d(getDUnitofDim(0));
		}
	public void conv2to3d(float Dt)
		{
		float dt = Dt;
		int nt = this.ne;
		int ncpt = nt/2;
		int ntr = this.vecs;
		float t[], y[];
		int i,j,k;
		if (Dt == 0F)
			{
			Noticeln("conv2to3d: Dt="
			 + Dt + " is zero, must abort.");
			return;
			}
		if (Dt < 0)
			Dt = -Dt;
		Notice("conv2to3d: convolving sqrt(1/t) along " + ntr
			 + " vectors of " + nt + " elements each with Dt="
			 + Dt + "... ");
		t= new float[ncpt];
		y= new float[ncpt+nt];
		/* make sqrt(1/t) trace */
		for(i=2;i<ncpt;i++)
			t[i]=1/(float)(Math.sqrt(i*dt));
		t[0]=(float)(Math.sqrt(2/dt));
		t[1]=t[0]*((float)(Math.sqrt(3))-1F);
		/* convolve input time series by t[] */
		for(k=0;k<ntr;k++)
			{
			for(i=0;i<nt+ncpt;i++)
				y[i]=0F;
			for(i=0;i<nt;i++)
				for(j=0;j<ncpt;j++)
					y[i+j]+=this.vec[k*nt + i]*t[j]*dt;
			/* (and take derivative) 
			for(i=0;i<nt;i++)
				this.vec[k*nt + i]=y[i+1]-y[i];
			*/
			for(i=0;i<nt;i++)
				this.vec[k*nt + i]=y[i];
			this.vec[k*nt + i-1] = 0F;
			}
		t = null;
		y = null;
	  	this.AmpUnits = "Sqrt(1/t) Convolved " + this.AmpUnits;
		Noticeln("done.");
		}
	static void conv2to3dPanel(ViewmatAction vad, ViewmatFrame f,
		boolean inplace, String label)
		{
		float Dt;
		String units;
		if (f.vm.fvol == null)
			{
			Dt = f.vm.fp.getDUnitofDim(0);
			units = f.vm.fp.getUnitsofDim(0);
			}
		else
			{
			Dt = f.vm.fvol.getDUnitofDim(0);
			units = f.vm.fvol.getUnitsofDim(0);
			}
		if (Dt == 0)
			Dt = 1F;
		if (Dt < 0)
			Dt = -Dt;
		vad.expl = new TextArea(label + " of " + f.getTitle()
			+ (inplace ? " in-place\n" : " in new window\n")
			+ "\n"
			+ "The " + label + " method on class FltPlane data\n"
			+ "convolves each trace separately in the time\n"
			+ "(or element) direction with sqrt(1/t) to effect the\n"
			+ "2-d infinite-line source to 3-d point source\n"
			+ "conversion of Vidale, Helmberger, Clayton, 1985,\n"
			+ "Finite-Difference Seismograms for Sh Waves:\n"
			+ "Bulletin of the Seismological Society of America,\n"
			+ "Vol. 75, No. 6, pp. 1765-1782; p. 1769 eq. 14,\n"
			+ "applying the specified sample interval Dt.\n"
			+ "Parameters below:\n"
			+ "Dt is the time sample interval (nonzero float).",
			5, 35);
		vad.pp.add(vad.expl);
		vad.lab0 = new Label("Time Sample Interval Dt (pos. float):");
		vad.pp.add(vad.lab0);
		vad.tf0 = new TextField("" + Dt, 5);
		vad.pp.add(vad.tf0);
		vad.lab1 = new Label("Dt units are " + units);
		vad.pp.add(vad.lab1);
		}
	public void doconv2to3d(ViewmatAction vad)
		{
		float Dt;
		String units;
		if (f.vm.fvol == null)
			Dt = f.vm.fp.getDUnitofDim(0);
		else
			Dt = f.vm.fvol.getDUnitofDim(0);
		if (Dt == 0)
			Dt = 1F;
		if (Dt < 0)
			Dt = -Dt;
		float htemp;
		try {htemp = Float.valueOf(vad.tf0.getText()).floatValue(); }
		catch (NumberFormatException nfe)
			{htemp = Dt; }
		if (htemp == 0F)
			htemp = Dt;
		if (htemp < 0)
			htemp = -htemp;
		Dt = htemp;
		this.conv2to3d(Dt);
		}

	public FltPlane copy(int copies)
		{
		int i, j, k;
		Notice("copy: producing copies of " + this.ne
			+ "-element vectors in " + this.vecs + "-vector plane "
			+ copies + " times each... ");
		FltPlane cpy = new FltPlane(copies*this.vecs, this.ne);
		if (this.headers != null)
			cpy.headers = new RgHead[copies*this.vecs];
		cpy.AmpUnits = new String(this.AmpUnits);
		cpy.Amp0 = this.Amp0;
		cpy.AmpFac = this.AmpFac;
		cpy.ElemUnits = new String(this.ElemUnits);
		cpy.VecUnits = new String(this.VecUnits);
		cpy.Elem0 = this.Elem0;
		cpy.DElem = this.DElem;
		cpy.Vec0 = this.Vec0;
		cpy.DVec = this.DVec/copies;
		cpy.f = this.f;
		for (j=0; j<this.vecs; j++)
			for (k=0; k<copies; k++)
				{
				for (i=0; i<this.ne; i++)
					cpy.vec[((j*copies)+k)*cpy.ne + i] =
						this.vec[j*this.ne + i];
				if (this.headers != null)
					cpy.headers[(j*copies)+k].copy(this.headers[j]);
				}
		Noticeln("done.");
		return cpy;
		}
	
	public void ctr()
       		{
		float avg;
		int i, j;
		Notice("FltPlane.ctr: removing averages from " + this.ne
			+ " elements in " + this.vecs + " vectors... ");
		for (j=0; j<vecs; j++)
			{
			avg = 0.0F;
              		for (i=0; i<ne; i++)
				avg += vec[j*ne + i];
			avg /= (float)(ne);
			for (i=0; i<ne; i++)
 				{
				vec[j*ne + i] -= avg;
				}
			}
		this.Amp0 = 0F;
		Noticeln("done.");
		}
	public void demean()
		{this.ctr(); }
	static void ctrPanel(ViewmatAction vad, ViewmatFrame f,
		boolean inplace, String label)
		{
		vad.expl = new TextArea(label + " of " + f.getTitle()
			+ (inplace ? " in-place\n" : " in new window\n")
			+ "\n"
			+ "The " + label + " method on class FltPlane data\n"
			+ "subtracts each vector's arithmetic mean\n"
			+ "from the amplitude of elements in the vector.",
			5, 35);
		vad.pp.add(vad.expl);
		}
	
	public FltPlane demult()
       		{
		int i, j;
		Notice("demult: demultiplexing " + this.vecs
			+ " vectors of " + this.ne + " elements to new plane with "
			+ this.ne + " vectors of " + this.vecs + " elements... ");
		FltPlane fp = new FltPlane(this.ne, this.vecs);
		fp.AmpUnits = new String(this.AmpUnits);
		fp.ElemUnits = new String(this.VecUnits);
		fp.VecUnits = new String(this.ElemUnits);
		fp.Amp0 = this.Amp0;
		fp.AmpFac = this.AmpFac;
		fp.Elem0 = this.Vec0;
		fp.DElem = this.DVec;
		fp.Vec0 = this.Elem0;
		fp.DVec = this.DElem;
		fp.f = this.f;
		for (j=0; j<fp.vecs; j++)
			{
			for (i=0; i<fp.ne; i++)
 				{
				fp.vec[j*fp.ne + i] = this.vec[i*this.ne + j];
				}
			}
		Noticeln("done.");
		return fp;
		}
	public void demultto(FltPlane fp)
		{
		int i, j;
		/*
		Notice("demult: demultiplexing " + this.vecs
			+ " vectors of " + this.ne + " elements to existing plane with "
			+ this.ne + " vectors of " + this.vecs + " elements... ");
		*/
		if (fp.vec.length < this.vec.length)
			{
			Errout("demultto: target FltPlane vec.length="
			+ fp.vec.length + " not large enough; must be at least "
			+ this.vec.length);
			return;
			}
		fp.ne = this.vecs;
		fp.vecs = this.ne;
		/*
		if (fp.getNMembofDim(2) > 1)
			fp.nv = fp.vec.length/fp.getNMembofDim(2)/fp.ne;
		*/
		fp.AmpUnits = new String(this.AmpUnits);
		fp.ElemUnits = new String(this.VecUnits);
		fp.VecUnits = new String(this.ElemUnits);
		fp.Amp0 = this.Amp0;
		fp.AmpFac = this.AmpFac;
		fp.Elem0 = this.Vec0;
		fp.DElem = this.DVec;
		fp.Vec0 = this.Elem0;
		fp.DVec = this.DElem;
		fp.f = this.f;
		for (j=0; j<fp.vecs; j++)
			{
			for (i=0; i<fp.ne; i++)
 				{
				fp.vec[j*fp.ne + i] = this.vec[i*this.ne + j];
				}
			}
		/*
		Noticeln("done.");
		*/
		}
	static void demultPanel(ViewmatAction vad, ViewmatFrame f,
		boolean inplace, String label)
		{
		vad.expl = new TextArea(label + " of " + f.getTitle()
			+ " in new window\n"
			+ "(Cannot be done in-place.)\n"
			+ "The " + label + " method on class FltPlane data\n"
			+ "demultiplexes or corner-turns the plane,\n"
			+ "converting the number of elements into\n"
			+ "the number of vectors and vice-versa.\n"
			+ "Any trace header information is deleted.",
			5, 35);
		vad.pp.add(vad.expl);
		}

	/* To deal with spikes introduced by 2004 firmware in 64-Mb Texans
	   J. Louie, Dec. 6, 2004 */
	public void despike(float Factor, int SpikeWidth, int SampleInterval)
		{
		int i, j, k, spikes;
		float max, val;
		boolean isspike;
		Notice("despike: de-spiking " + this.vecs + " vectors of " + this.ne
			+ " elements each with Factor=" + Factor
			+ " SpikeWidth=" + SpikeWidth
			+ " SampleInterval=" + SampleInterval + " ... ");
		spikes = 0;
		for (j=0; j<this.vecs; j++)
		for (i=SampleInterval+1; i<this.ne-SampleInterval-SpikeWidth; i++)
			{
			max = 0F;
			isspike = false;
			for (k=i-SampleInterval; k<i; k++)
				{
				val = this.vec[j*this.ne + k];
				val = val<0F ? -val : val;
				if (val > max)
					max = val;
				}
			for (k=i+ SpikeWidth; k<i+SampleInterval+ SpikeWidth; k++)
				{
				val = this.vec[j*this.ne + k];
				val = val<0F ? -val : val;
				if (val > max)
					max = val;
				}
			for (k=i; k<i+SpikeWidth; k++)
				{
				val = this.vec[j*this.ne + k];
				val = val<0F ? -val : val;
				if (val > Factor*max)
					isspike = true;
				else
					{
					isspike = false;
					break;
					}
				}
			if (isspike)
				{
				for (k=i; k<i+SpikeWidth; k++)
					this.vec[j*this.ne + k] =
					(this.vec[j*this.ne + i - 1]
					+ this.vec[j*this.ne + i
					+ SpikeWidth])/2F;
				spikes++;
				}
			}
		Noticeln("done. " + spikes + " spikes removed.");
		}
	static void despikePanel(ViewmatAction vad, ViewmatFrame f,
		boolean inplace, String label)
		{
		float Factor;
		int SampleInterval, SpikeWidth;
		Factor = 2F;
		SpikeWidth = 3;
		if (f.vm.fvol == null)
			SampleInterval = f.vm.fp.ne/100;
		else
			SampleInterval = f.vm.fvol.ne/100;
		if (SampleInterval < 2)
			SampleInterval = 2;
		vad.expl = new TextArea(label + " of " + f.getTitle()
			+ (inplace ? " in-place\n" : " in new window\n")
			+ "\n"
			+ "The " + label + " method on class FltPlane data\n"
			+ "irreversibly replaces spikes with the average\n"
			+ "amplitude of the adjacent samples. Spikes are\n"
			+ "defined as isolated runs of samples all having\n"
			+ "absolute value a Factor above the maximum\n"
			+ "absolute value of all surrounding samples\n"
			+ "within a set Sample Interval.\n"
			+ "Parameters below:\n"
			+ "Factor is defines spike absolute value (pos. float).\n"
			+ "Spike Width is samples per spike (pos. integer).\n"
			+ "Sample Interval is number of samples before and\n"
			+ "also after a spike above which the maximum\n"
			+ "absolute value is measured (pos. integer).",
			5, 35);
		vad.pp.add(vad.expl);
		vad.lab0 = new Label("Factor (pos. float):");
		vad.pp.add(vad.lab0);
		vad.tf0 = new TextField("" + Factor, 8);
		vad.pp.add(vad.tf0);
		vad.lab1 = new Label("Spike Width (no. samples, pos. int.): ");
		vad.pp.add(vad.lab1);
		vad.tf1 = new TextField("" + SpikeWidth, 2);
		vad.pp.add(vad.tf1);
		vad.lab2 = new Label("Sample Interval (no. samples, pos. int.): ");
		vad.pp.add(vad.lab2);
		vad.tf2 = new TextField("" + SampleInterval, 6);
		vad.pp.add(vad.tf2);
		}
	public void dodespike(ViewmatAction vad)
		{
		float Factor;
		int SpikeWidth, SampleInterval;
		Factor = 1000F;
		SpikeWidth = 3;
		SampleInterval = this.ne/10;
		if (SampleInterval < 2)
			SampleInterval = 2;
		float htemp;
		try {htemp = Float.valueOf(vad.tf0.getText()).floatValue(); }
		catch (NumberFormatException nfe)
			{htemp = Factor; }
		if (htemp < 1.001F)
			htemp = 1.001F;
		else if (htemp > 1e28F)
			htemp = 1e28F;
		Factor = htemp;
		int itemp;
		try {itemp = Integer.valueOf(vad.tf2.getText()).intValue(); }
		catch (NumberFormatException nfe)
			{itemp = SampleInterval; }
		if (itemp < 2)
			itemp = 2;
		else if (itemp > this.ne/3)
			itemp = this.ne/3;
		SampleInterval = itemp;
		try {itemp = Integer.valueOf(vad.tf1.getText()).intValue(); }
		catch (NumberFormatException nfe)
			{itemp = SpikeWidth; }
		if (itemp > SampleInterval)
			itemp = SampleInterval/2;
		if (itemp < 1)
			itemp = 1;
		SpikeWidth = itemp;
		this.despike(Factor, SpikeWidth, SampleInterval);
		}

	/* J. Louie, 2007 */
	public void differentiate()
		{
		differentiate(getDUnitofDim(0));
		}
	public void differentiate(float Dt)
		{
		int ix, iy, nx, ny;
		nx = this.ne;
		ny = this.vecs;
		float fdx, sdx;
		if (Dt == 0F)
			{
			Noticeln("differentiate: Dt="
			 + Dt + " is zero, must abort.");
			return;
			}
		/* obtain space for buffer array */
		float buf[] = new float[nx];
		Notice("differentiate: finite-differencing along " + ny
			 + " vectors of " + nx + " elements each with Dt="
			 + Dt + "... ");
		for (iy=0; iy<ny; iy++)
		    {
		    /* copy current trace to buffer */
		    for (ix=0; ix<nx; ix++)
			buf[ix] = this.vec[iy*nx + ix];
		    /* compute derivative within trace with a leapfrog finite-difference */
		    for (ix=1; ix<(nx-1); ix++)
			this.vec[iy*nx + ix] = (buf[ix + 1] - buf[ix - 1])/2F/Dt;
		    /* compute slope on edges with an Euler finite-difference */
		    /* left edge */
		    for (ix=0; ix<1; ix++)
			this.vec[iy*nx + ix] = (buf[ix + 1] - buf[ix])/Dt;
		    /* right edge */
		    for (ix=(nx-1); ix<nx; ix++)
			this.vec[iy*nx + ix] = (buf[ix] - buf[ix - 1])/Dt;
		    }
	  	buf = null;
	  	this.AmpUnits = "Differentiated " + this.AmpUnits;
		Noticeln("done.");
		}
	static void differentiatePanel(ViewmatAction vad, ViewmatFrame f,
		boolean inplace, String label)
		{
		float Dt;
		String units;
		if (f.vm.fvol == null)
			{
			Dt = f.vm.fp.getDUnitofDim(0);
			units = f.vm.fp.getUnitsofDim(0);
			}
		else
			{
			Dt = f.vm.fvol.getDUnitofDim(0);
			units = f.vm.fvol.getUnitsofDim(0);
			}
		if (Dt == 0)
			Dt = 1F;
		vad.expl = new TextArea(label + " of " + f.getTitle()
			+ (inplace ? " in-place\n" : " in new window\n")
			+ "\n"
			+ "The " + label + " method on class FltPlane data\n"
			+ "differentiates each trace separately in the time\n"
			+ "(or element) direction, applying the specified\n"
			+ "sample interval Dt.\n"
			+ "Parameters below:\n"
			+ "Dt is the time sample interval (nonzero float).",
			5, 35);
		vad.pp.add(vad.expl);
		vad.lab0 = new Label("Time Sample Interval Dt (nonzero float):");
		vad.pp.add(vad.lab0);
		vad.tf0 = new TextField("" + Dt, 5);
		vad.pp.add(vad.tf0);
		vad.lab1 = new Label("Dt units are " + units);
		vad.pp.add(vad.lab1);
		}
	public void dodifferentiate(ViewmatAction vad)
		{
		float Dt;
		String units;
		if (f.vm.fvol == null)
			Dt = f.vm.fp.getDUnitofDim(0);
		else
			Dt = f.vm.fvol.getDUnitofDim(0);
		if (Dt == 0)
			Dt = 1F;
		float htemp;
		try {htemp = Float.valueOf(vad.tf0.getText()).floatValue(); }
		catch (NumberFormatException nfe)
			{htemp = Dt; }
		if (htemp == 0F)
			htemp = Dt;
		Dt = htemp;
		this.differentiate(Dt);
		}

	/* Modified from Ira David Hale and Rick Ottolini 1980-81
	   for Java by J. Louie 1999 */
	public void dipfil(float DipCut, float Freq, boolean RejectLow)
		{
		int ip, np, ix,it,nx,nt;
		nx = this.vecs;
		nt = this.ne;
		np = this.getNMembofDim(2);
		if (np > 1)
			nx = this.getNMembofDim(1);
		boolean mode;
		mode = RejectLow;
		float rho,freq,alpha,pi,b,ac;
		rho = DipCut;
		freq = Freq;
		int ptm1,pt,qtm1,qt,rhs,temp;
		/* obtain space for arrays and initialize array pointers */
		float ptv[] = new float[nx*5];
		pt = 0;
		ptm1 = pt + nx;
		qt = ptm1 + nx;
		qtm1 = qt + nx;
		rhs = qtm1 + nx;
		/* calculate constants */
		pi = 3.14159265F;
		alpha = 4F * pi * freq * rho * rho;
		ac = -1F;
		b = alpha + 2F;
		/**************/
		/* dip filter */
		/**************/
		Notice("dipfil: dip-filtering " + np + " planes of " + nx
			 + " vectors of " + nt + " elements each with DipCut="
			 + DipCut + " Freq=" + Freq + " RejectLow="
			 + RejectLow + "... ");
		for (ip=0; ip<np; ip++)
		{
		for (it = 0; it < nt; it++)
			{
			/* read the present input time-slice, pt */
			for (ix=0; ix<nx; ix++)
				ptv[pt+ix] = this.vec[ip*nx*nt + ix*nt + it];
			/* compute the right-hand-side column vector
			   from qtm1, pt, and ptm1
			   (using zero-value boundary conditions) */
			ptv[rhs+0] = (alpha - 2F) * ptv[qtm1+0] + ptv[qtm1+1]
				+ alpha * (ptv[pt+0] - ptv[ptm1+0]);
			ptv[rhs+nx-1] = ptv[qtm1+nx-2] + (alpha - 2F) * ptv[qtm1+nx-1]
				+ alpha * (ptv[pt+nx-1] - ptv[ptm1+nx-1]);
			for (ix = 1; ix < nx-1; ix++)
				ptv[rhs+ix] = ptv[qtm1+ix-1] + (alpha - 2F) * ptv[qtm1+ix]
					+ ptv[qtm1+ix+1] + alpha * (ptv[pt+ix] - ptv[ptm1+ix]);
			/* solve the tridiagonal system for the present
			   high-dip-reject filtered time-slice, qt */
			FltPlane.tri(ac,b,ac, ptv, qt,rhs,qtm1,ptm1,nx);

			/* if low-dip-reject mode, write pt - qt */
			if (mode)
				{
				for (ix = 0; ix < nx; ix++)
					{
					ptv[qtm1+ix] = ptv[pt+ix] - ptv[qt+ix];
					this.vec[ip*nx*nt + ix*nt + it] = ptv[qtm1+ix];
					}
				}
			/* if high-dip-reject mode, write qt */
			else
				{
				for (ix=0; ix<nx; ix++)
					this.vec[ip*nx*nt + ix*nt + it] = ptv[qt+ix];
				}
			/* swap array pointers (effectively moves pt to ptm1
			   and qt to qtm1) */
			temp = ptm1; ptm1 = pt; pt = temp;
			temp = qtm1; qtm1 = qt; qt = temp;
	  		}
	  		}
	  	ptv = null;
	  	this.AmpUnits = this.AmpUnits + " after "
	  		+ (RejectLow ? "Low" : "High") + "-Dip Reject";
		Noticeln("done.");
		}
	/* Tridiagonal system solver (from Dave Hale, SEP, 1980) */
	/*	subroutine solves a tridiagonal system of equations
	*	For example:
	*
	*	| b   	c     0 | |x(0)|      |d(0)|
	*	| a     b     c | |x(1)|   =  |d(1)|
	*	| 0     a     b | |x(2)|      |d(2)|
	* The xv array is at least 4*n long, with x,d,e,f indexes into it. */
	public static void tri(float a, float b, float c, float xv[],
		int x, int d, int e, int f, int n)
		{
		int i;
		float num;
		xv[e+0] = c / b;
		xv[f+0] = xv[d+0] / b;
		for (i = 1; i < n; i++)
			{
			num = 1F / (b - a * xv[e+i-1]);
			xv[e+i] = c * num;
			xv[f+i] = (xv[d+i] - a * xv[f+i-1]) * num;
			}
		xv[x+n-1] = xv[f+n-1];
		for (i = n-2; i >= 0; i--)
			xv[x+i] = xv[f+i] - xv[e+i] * xv[x+i+1];
		}
	static void dipfilPanel(ViewmatAction vad, ViewmatFrame f,
		boolean inplace, String label)
		{
		float DipCut, Freq;
		boolean RejectLow;
		DipCut = 1F/f.vm.ve;
		Freq = 0.1F;
		RejectLow = false;
		vad.expl = new TextArea(label + " of " + f.getTitle()
			+ (inplace ? " in-place\n" : " in new window\n")
			+ "\n"
			+ "The " + label + " method on class FltPlane data\n"
			+ "irreversibly dip-filters across all vectors\n"
			+ "with Dave Hale's x-t domain method. Since it\n"
			+ "requires evenly spaced traces it ignores any trace headers.\n"
			+ "Parameters below:\n"
			+ "Dip Cut dip-cutoff (3db point) in samples/trace (pos. float).\n"
			+ "   (default is at 45 degrees based on vertical "
			+ "exaggeration of plot.)\n"
			+ "Frequency is frequency in cycles/sample at which "
			+ "a dip of rho is attenuated by 3db (Nyquist = .5) (pos. float).\n"
			+ "    (This value should be the dominate frequency of "
			+ "the phases most needing filtering, estimated from the data.)\n"
			+ "High-dip reject is the default; check Reject Low Dip "
			+ "for the reverse effect.",
			5, 35);
		vad.pp.add(vad.expl);
		vad.lab0 = new Label("Dip Cut (samples/trace, pos. float):");
		vad.pp.add(vad.lab0);
		vad.tf0 = new TextField("" + DipCut, 8);
		vad.pp.add(vad.tf0);
		vad.lab1 = new Label("Dom. Freq. (cycles/sample, >0, <0.5): ");
		vad.pp.add(vad.lab1);
		vad.tf1 = new TextField("" + Freq, 8);
		vad.pp.add(vad.tf1);
		vad.cb0 = new Checkbox("Reject Low Dip?");
		vad.pp.add(vad.cb0);
		vad.cb0.setState(RejectLow);
		vad.lab2 = new Label("(Reject high dips if not checked.)");
		vad.pp.add(vad.lab2);
		}
	public void dodipfil(ViewmatAction vad)
		{
		float DipCut, Freq;
		boolean RejectLow;
		DipCut = 1F/vad.f.vm.ve;
		Freq = 0.1F;
		RejectLow = false;
		float htemp;
		try {htemp = Float.valueOf(vad.tf0.getText()).floatValue(); }
		catch (NumberFormatException nfe)
			{htemp = DipCut; }
		if (htemp < 0F)
			htemp = -htemp;
		DipCut = htemp;
		try {htemp = Float.valueOf(vad.tf1.getText()).floatValue(); }
		catch (NumberFormatException nfe)
			{htemp = Freq; }
		if (htemp > 0.5F)
			htemp = Freq;
		if (htemp < 0F)
			htemp = -htemp;
		Freq = htemp;
		RejectLow = vad.cb0.getState();
		this.dipfil(DipCut, Freq, RejectLow);
		}

	static void fixCoordsPanel(ViewmatAction vad, ViewmatFrame f,
		boolean inplace, String label)
		{
		vad.noticeonly = true;
		vad.expl = new TextArea(label + " of " + f.getTitle() + "\n"
			+ "Always in-place.\n"
			+ "The " + label + " method on class FltPlane data\n"
			+ "will alter trace-header geometry values,\n"
			+ "and re-calculate all offsets. Offsets will be fully 3-D",
			5, 35);
		vad.pp.add(vad.expl);
		RgHead hd, headers[];
		if (f.vm.fvol == null)
			{
			vad.lab3 = new Label(f.vm.fp.getOffsets());
			headers = f.vm.fp.headers;
			vad.geogr = f.vm.fp.geogr;
			}
		else
			{
			vad.lab3 = new Label(f.vm.fvol.getOffsets());
			headers = f.vm.fvol.headers;
			vad.geogr = f.vm.fvol.geogr;
			}
		if (headers == null)
			{
			vad.lab0 = new Label("This FltPlane has no headers.");
			vad.pp.add(vad.lab0);
			return;
			}
		hd = new RgHead(headers[0]);
		vad.lab0 = new Label("Multiply Coordinates By:");
		vad.pp.add(vad.lab0);
		vad.tf0 = new TextField("1.0", 6);
		vad.pp.add(vad.tf0);
		vad.lab1 = new Label("Multiply Elevations By:");
		vad.pp.add(vad.lab1);
		vad.tf1 = new TextField("1.0", 6);
		vad.pp.add(vad.tf1);
		vad.lab2 = new Label("Present Offset Range:");
		vad.pp.add(vad.lab2);
		vad.pp.add(vad.lab3);
		vad.cb0 = new Checkbox("Coords will be Lat/Lon Degrees?");
		vad.pp.add(vad.cb0);
		vad.cb0.setState(vad.geogr);
		}
	public void dofixCoords(ViewmatAction vad)
		{
		double temp, lscl, coscl;
		int i;
		boolean geogr;
		if (this.headers == null)
			return;
		try {temp = Float.valueOf(vad.tf0.getText()).floatValue(); }
		catch (NumberFormatException nfe)
			{temp = 1.0; }
		coscl = temp;
		try {temp = Float.valueOf(vad.tf1.getText()).floatValue(); }
		catch (NumberFormatException nfe)
			{temp = 1.0; }
		lscl = temp;
		geogr = vad.cb0.getState();
		this.geogr = geogr;
		for (i=0; i<this.headers.length; i++)
			{
			this.headers[i].sx *= coscl;
			this.headers[i].sy *= coscl;
			this.headers[i].gx *= coscl;
			this.headers[i].gy *= coscl;
			this.headers[i].sz *= lscl;
			this.headers[i].gz *= lscl;
			this.headers[i].off = this.headers[i].calcOffset(geogr);
			}
		}

       	public void hann(float Portion, float Rise, boolean TaperTraces)
       		{
		int n, nt, x, nx;
		double hold;
		nt = this.ne;
		nx = this.vecs;
              	if (TaperTraces && nx < 4)
			{
			Errout("hann: NVecs=" + nx + " is < 4, cannot taper.");
			return;
			}
		else if (!TaperTraces && nt < 4)
			{
			Errout("hann: NElem=" + nt + " is < 4, cannot taper.");
			return;
			}
		Notice("FltPlane.hann: " + (100F*Portion) + "% tapering "
			+ (TaperTraces ? "across" : "along") + " traces with "
			+ 100F*Rise + "% raised cosine... ");
		if (TaperTraces)
			{
			for (x=0; x<nt; x++)
				{
				for(n=0; n<(int)(Portion*nx/2.0); n++)
					{
					hold = Math.cos(n*2.0*Math.PI
						/(double)(Portion*(nx-1)) - Math.PI);
					this.vec[n*nt+x] *= (float)(0.5 + Rise + (0.5 - Rise)*hold);
					}
				for(n=(int)(nx - Portion*nx/2.0); n<nx; n++)
					{
					hold = Math.cos((n-(int)((1F-Portion)*nx))*2.0*Math.PI
						/(double)(Portion*(nx-1)) - Math.PI);
					this.vec[n*nt+x] *= (float)(0.5 + Rise + (0.5 - Rise)*hold);
					}
				}
			}
		else
			{
			for (x=0; x<nx; x++)
				{
				for(n=0; n<(int)(Portion*nt/2.0); n++)
					{
					hold = Math.cos(n*2.0*Math.PI
						/(double)(Portion*(nt-1)) - Math.PI);
					this.vec[x*nt+n] *= (float)(0.5 + Rise + (0.5 - Rise)*hold);
					}
				for(n=(int)(nt - Portion*nt/2.0); n<nt; n++)
					{
					hold = Math.cos((n-(int)((1F-Portion)*nt))*2.0*Math.PI
						/(double)(Portion*(nt-1)) - Math.PI);
					this.vec[x*nt+n] *= (float)(0.5 + Rise + (0.5 - Rise)*hold);
					}
				}
			}
		Noticeln("done.");
		}
       	public void hann()
       		{
		hann(1F, 0.05F, false);
		}
	static void hannPanel(ViewmatAction vad, ViewmatFrame f,
		boolean inplace, String label)
		{
		vad.expl = new TextArea(label + " of " + f.getTitle()
			+ (inplace ? " in-place\n" : " in new window\n")
			+ "\n"
			+ "The " + label + " method on class FltPlane data\n"
			+ "tapers the element amplitudes at the ends\n"
			+ "of the traces, or across the side traces, by\n"
			+ "applying a raised cosine Hanning window.",
			5, 35);
		vad.pp.add(vad.expl);
		vad.lab0 = new Label("Taper Portion (float, >0.0, <=1.0):");
		vad.pp.add(vad.lab0);
		vad.tf0 = new TextField("1.0", 4);
		vad.pp.add(vad.tf0);
		vad.lab1 = new Label("Rise (float, >=0.0, <0.5):");
		vad.pp.add(vad.lab1);
		vad.tf1 = new TextField("0.05", 4);
		vad.pp.add(vad.tf1);
		vad.cb0 = new Checkbox("Taper Across Traces?");
		vad.pp.add(vad.cb0);
		vad.cb0.setState(false);
		}
	public void dohann(ViewmatAction vad)
		{
		float temp, portion, rise;
		portion = 1F;
		rise = 0.05F;
		try {temp = Float.valueOf(vad.tf0.getText()).floatValue(); }
		catch (NumberFormatException nfe)
			{
			Errout("hann: Cannot taper with portion of "
				+ vad.tf0.getText() + " - must be a positive float <= 1.0.");
			return;
			}
		if (temp <= 0F || temp > 1F)
			{
			Errout("hann: Cannot taper with portion of "
				+ vad.tf0.getText() + " - must be a positive float <= 1.0.");
			return;
			}
		portion = temp;
		try {temp = Float.valueOf(vad.tf1.getText()).floatValue(); }
		catch (NumberFormatException nfe)
			{
			Errout("hann: Cannot taper with rise of "
				+ vad.tf1.getText() + " - must be a positive float < 0.5.");
			return;
			}
		if (temp < 0F || temp >= 0.5F)
			{
			Errout("hann: Cannot taper with rise of "
				+ vad.tf1.getText() + " - must be a positive float < 0.5.");
			return;
			}
		rise = temp;
		this.hann(portion, rise, vad.cb0.getState());
		}
		
	public void mirror()
       		{
       		mirror(0, this.vecs-1);
       		}
	public void mirror(int v0, int vf)
       		{
       		float buf1[];
       		buf1 = new float[ne];
       		RgHead hdbuf = new RgHead();
		int i, j, itemp, nvm;
		if (v0 > vf)
			{
			itemp = v0;
			v0 = vf;
			vf = itemp;
			}
		if (v0 < 0)
			v0 = 0;
		if (vf > this.vecs-1)
			vf = this.vecs-1;
		nvm = vf-v0+1;
		Notice("FltPlane.mirror: reversing the order of " + nvm
			+ " vectors within " + this.vecs + " of " + this.ne + " elements... ");
		/*for (j=0; j<vecs/2; j++)*/
		for (j=v0; j<v0+(nvm/2); j++)
			{
			for (i=0; i<ne; i++)
				buf1[i] = this.vec[j*ne + i];
			for (i=0; i<ne; i++)
				/*this.vec[j*ne + i] = this.vec[(vecs-j-1)*ne + i];*/
				this.vec[j*ne + i] = this.vec[(vf-(j-v0))*ne + i];
			for (i=0; i<ne; i++)
				/*this.vec[(vecs-j-1)*ne + i] = buf1[i];*/
				this.vec[(vf-(j-v0))*ne + i] = buf1[i];
			}
		buf1 = null;
		/*for (j=0; headers != null && j<vecs/2; j++)*/
		for (j=v0; headers != null && j<v0+(nvm/2); j++)
			{
			hdbuf.copy(this.headers[j]);
			/*
			this.headers[j].copy(this.headers[vecs-j-1]);
			this.headers[vecs-j-1].copy(hdbuf);
			*/
			this.headers[j].copy(this.headers[vf-(j-v0)]);
			this.headers[vf-(j-v0)].copy(hdbuf);
			}
		if (nvm == vecs)
			{
			setUnit0ofDim(1, getUnit0ofDim(1) + vecs*getDUnitofDim(1));
			setDUnitofDim(1, -getDUnitofDim(1));
			}
		Noticeln("done.");
		}
	static void mirrorPanel(ViewmatAction vad, ViewmatFrame f,
		boolean inplace, String label)
		{
		int vf;
		vad.expl = new TextArea(label + " of " + f.getTitle()
			+ (inplace ? " in-place\n" : " in new window\n")
			+ "\n"
			+ "The " + label + " method on class FltPlane data\n"
			+ "mirror-images by reversing the vector order\n"
			+ "across the whole data set. A range of vector\n"
			+ "indices (first vector has index 0) can optionally\n"
			+ "limit the area of reversal. If present, header order\n"
			+ "is reversed as well.",
			5, 35);
		vad.pp.add(vad.expl);
		if (f.vm.fvol == null)
			vf = f.vm.fp.vecs - 1;
		else
			vf = f.vm.fvol.vecs - 1;
		vad.lab0 = new Label("Vector Range: Index");
		vad.pp.add(vad.lab0);
		vad.tf0 = new TextField("0", 4);
		vad.pp.add(vad.tf0);
		vad.lab1 = new Label("to");
		vad.pp.add(vad.lab1);
		vad.tf1 = new TextField("" + vf, 4);
		vad.pp.add(vad.tf1);
		}
	public void domirror(ViewmatAction vad)
		{
		int v0, vf, itemp, nx;
		v0 = 0;
		if (f.vm.fvol == null)
			nx = f.vm.fp.vecs;
		else
			nx = f.vm.fvol.vecs;
		vf = nx - 1;
		try {itemp = Integer.valueOf(vad.tf0.getText()).intValue(); }
		catch (NumberFormatException nfe)
			{itemp = v0; }
		v0 = itemp;
		try {itemp = Integer.valueOf(vad.tf1.getText()).intValue(); }
		catch (NumberFormatException nfe)
			{itemp = vf; }
		vf = itemp;
		if (v0 > vf)
			{
			itemp = v0;
			v0 = vf;
			vf = itemp;
			}
		if (v0 < 0)
			v0 = 0;
		if (vf > nx-1)
			vf = nx - 1;
		this.mirror(v0, vf);
		}
	
	public FltPlane pad(int pad)
		{
		int ne, nv;
		nv = this.vecs;
		ne = this.ne + pad;
		FltPlane fp = new FltPlane(nv, ne);
		fp.copyvals(this);
		fp.ne = ne;
		for (int k=0; k<nv; k++)
			for (int i=0; i<this.ne; i++)
				fp.vec[k*ne + i] = this.vec[k*this.ne + i];
		return fp;
		}
	static void padPanel(ViewmatAction vad, ViewmatFrame f,
		boolean inplace, String label)
		{
		vad.expl = new TextArea(label + " of " + f.getTitle()
			+ (inplace ? " in-place\n" : " in new window\n")
			+ "\n"
			+ "The " + label + " method on class FltPlane data\n"
			+ "appends the requested number of zero data\n"
			+ "samples to each vector.",
			5, 35);
		vad.pp.add(vad.expl);
		vad.lab0 = new Label("No. of Padding Samples (+Integer):");
		vad.pp.add(vad.lab0);
		vad.tf0 = new TextField("0", 6);
		vad.pp.add(vad.tf0);
		}
	public FltPlane dopad(ViewmatAction vad)
		{
		int temp, pad;
		try {temp = Integer.valueOf(vad.tf0.getText()).intValue(); }
		catch (NumberFormatException nfe)
			{temp = 0; }
		if (temp <= 0 || temp > 1e10)
			temp = 0;
		pad = temp;
		return this.pad(pad);
		}
		
	public void rev()
       		{
       		float buf1[];
       		buf1 = new float[ne];
		int i, j;
		Notice("FltPlane.rev: reversing the order of " + this.ne
			+ " elements in " + this.vecs + " vectors... ");
		for (j=0; j<vecs; j++)
			{
			for (i=0; i<ne; i++)
				buf1[ne-i-1] = this.vec[j*ne + i];
			for (i=0; i<ne; i++)
				this.vec[j*ne + i] = buf1[i];
			}
		buf1 = null;
		setUnit0ofDim(0, getUnit0ofDim(0) + ne*getDUnitofDim(0));
		setDUnitofDim(0, -getDUnitofDim(0));
		Noticeln("done.");
		}
	static void revPanel(ViewmatAction vad, ViewmatFrame f,
		boolean inplace, String label)
		{
		vad.expl = new TextArea(label + " of " + f.getTitle()
			+ (inplace ? " in-place\n" : " in new window\n")
			+ "\n"
			+ "The " + label + " method on class FltPlane data\n"
			+ "reverses the order of elements in each vector.",
			5, 35);
		vad.pp.add(vad.expl);
		}
	
	static void setHeaderPanel(ViewmatAction vad, ViewmatFrame f,
		boolean inplace, String label)
		{
		vad.noticeonly = true;
		vad.expl = new TextArea(label + " of " + f.getTitle() + "\n"
			+ "Always in-place.\n"
			+ "The " + label + " method on class FltPlane data\n"
			+ "can examine trace-header geometry values,\n"
			+ "and individually set them.",
			5, 35);
		vad.pp.add(vad.expl);
		RgHead hd, headers[];
		if (f.vm.fvol == null)
			headers = f.vm.fp.headers;
		else
			headers = f.vm.fvol.headers;
		if (headers == null)
			{
			vad.lab0 = new Label("This FltPlane has no headers.");
			vad.pp.add(vad.lab0);
			return;
			}
		hd = new RgHead(headers[0]);
		vad.lab0 = new Label("Header Index (int. 0-"
			+ (headers.length-1) + "):");
		vad.pp.add(vad.lab0);
		vad.tf0 = new TextField("0", 6);
		vad.pp.add(vad.tf0);
		vad.checkhead = new Button("Check Header");
		vad.pp.add(vad.checkhead);
		vad.checkhead.addActionListener(vad);
		vad.lab1 = new Label("Field Record No.:");
		vad.pp.add(vad.lab1);
		vad.tf1 = new TextField("" + hd.rec, 6);
		vad.pp.add(vad.tf1);
		vad.lab2 = new Label("Source Point No.:");
		vad.pp.add(vad.lab2);
		vad.tf2 = new TextField("" + hd.svp, 6);
		vad.pp.add(vad.tf2);
		vad.lab3 = new Label("Receiver Point No.:");
		vad.pp.add(vad.lab3);
		vad.tf3 = new TextField("" + hd.gvp, 6);
		vad.pp.add(vad.tf3);
		vad.lab4 = new Label("Source X Coord., m:");
		vad.pp.add(vad.lab4);
		vad.tf4 = new TextField(Viewmat.getSignif("" + hd.sx, 12), 12);
		vad.pp.add(vad.tf4);
		vad.lab5 = new Label("Source Y Coord., m:");
		vad.pp.add(vad.lab5);
		vad.tf5 = new TextField(Viewmat.getSignif("" + hd.sy, 12), 12);
		vad.pp.add(vad.tf5);
		vad.lab6 = new Label("Source Elevation, m:");
		vad.pp.add(vad.lab6);
		vad.tf6 = new TextField(Viewmat.getSignif("" + hd.sz), 6);
		vad.pp.add(vad.tf6);
		vad.lab7 = new Label("Receiver X Coord., m:");
		vad.pp.add(vad.lab7);
		vad.tf7 = new TextField(Viewmat.getSignif("" + hd.gx, 12), 12);
		vad.pp.add(vad.tf7);
		vad.lab8 = new Label("Receiver Y Coord., m:");
		vad.pp.add(vad.lab8);
		vad.tf8 = new TextField(Viewmat.getSignif("" + hd.gy, 12), 12);
		vad.pp.add(vad.tf8);
		vad.lab9 = new Label("Receiver Elevation, m:");
		vad.pp.add(vad.lab9);
		vad.tf9 = new TextField(Viewmat.getSignif("" + hd.gz), 6);
		vad.pp.add(vad.tf9);
		vad.lab10 = new Label("Offset, m:");
		vad.pp.add(vad.lab10);
		vad.tf10 = new TextField(Viewmat.getSignif("" + hd.off), 8);
		vad.pp.add(vad.tf10);
		vad.height = 500;
		}
	public void dosetHeader(ViewmatAction vad)
		{
		int dtemp;
		double temp;
		if (this.headers == null)
			return;
		int ind = 0;
		try {ind = Integer.valueOf(vad.tf0.getText()).intValue(); }
		catch (NumberFormatException nfe)
			{ind = -1; }
		if (ind < 0 || ind >= this.headers.length)
			{
			Errout("setHeader: Trace header index="
			+ vad.tf0.getText() + "\nnot between 0 and "
			+ (this.headers.length -1) + ", no values changed.");
			return;
			}
		RgHead hd = new RgHead(this.headers[ind]);
		try {dtemp = Integer.valueOf(vad.tf1.getText()).intValue(); }
		catch (NumberFormatException nfe)
			{dtemp = hd.rec; }
		if (ind < 0)
			dtemp = hd.rec;
		hd.rec = dtemp;
		try {dtemp = Integer.valueOf(vad.tf2.getText()).intValue(); }
		catch (NumberFormatException nfe)
			{dtemp = hd.svp; }
		hd.svp = dtemp;
		try {dtemp = Integer.valueOf(vad.tf3.getText()).intValue(); }
		catch (NumberFormatException nfe)
			{dtemp = hd.gvp; }
		hd.gvp = dtemp;
		try {temp = Float.valueOf(vad.tf4.getText()).floatValue(); }
		catch (NumberFormatException nfe)
			{temp = hd.sx; }
		hd.sx = temp;
		try {temp = Float.valueOf(vad.tf5.getText()).floatValue(); }
		catch (NumberFormatException nfe)
			{temp = hd.sy; }
		hd.sy = temp;
		try {temp = Float.valueOf(vad.tf6.getText()).floatValue(); }
		catch (NumberFormatException nfe)
			{temp = hd.sz; }
		hd.sz = temp;
		try {temp = Float.valueOf(vad.tf7.getText()).floatValue(); }
		catch (NumberFormatException nfe)
			{temp = hd.gx; }
		hd.gx = temp;
		try {temp = Float.valueOf(vad.tf8.getText()).floatValue(); }
		catch (NumberFormatException nfe)
			{temp = hd.gy; }
		hd.gy = temp;
		try {temp = Float.valueOf(vad.tf9.getText()).floatValue(); }
		catch (NumberFormatException nfe)
			{temp = hd.gz; }
		hd.gz = temp;
		try {temp = Float.valueOf(vad.tf10.getText()).floatValue(); }
		catch (NumberFormatException nfe)
			{temp = hd.off; }
		hd.off = temp;
		hd.allset = true;
		this.headers[ind].copy(hd);
		hd.print(System.out);
		}
	static void checkHeader(ViewmatAction vad)
		{
		RgHead hd, headers[];
		if (vad.f.vm.fvol == null)
			headers = vad.f.vm.fp.headers;
		else
			headers = vad.f.vm.fvol.headers;
		if (headers == null)
			{
			vad.lab0.setText("This FltPlane has no headers.");
			return;
			}
		int ind = 0;
		try {ind = Integer.valueOf(vad.tf0.getText()).intValue(); }
		catch (NumberFormatException nfe)
			{ind = -1; }
		if (ind < 0 || ind >= headers.length)
			{
			(vad.f.vm.fvol == null ? vad.f.vm.fp : vad.f.vm.fvol).Errout(
			"setHeader: Trace header index="
			+ vad.tf0.getText() + "\nnot between 0 and "
			+ (headers.length -1) + ", showing index 0.");
			vad.tf0.setText("0");
			ind = 0;
			}
		hd = new RgHead(headers[ind]);
		vad.tf1.setText("" + hd.rec);
		vad.tf2.setText("" + hd.svp);
		vad.tf3.setText("" + hd.gvp);
		vad.tf4.setText(Viewmat.getSignif("" + hd.sx));
		vad.tf5.setText(Viewmat.getSignif("" + hd.sy));
		vad.tf6.setText(Viewmat.getSignif("" + hd.sz));
		vad.tf7.setText(Viewmat.getSignif("" + hd.gx));
		vad.tf8.setText(Viewmat.getSignif("" + hd.gy));
		vad.tf9.setText(Viewmat.getSignif("" + hd.gz));
		vad.tf10.setText(Viewmat.getSignif("" + hd.off));
		}

	public RgFileHead makeRgFileHead()
		{
		RgFileHead fhd = new RgFileHead();
		fhd.ntrace = this.vecs;
		fhd.nt = this.ne;
	 	fhd.starttime = this.getUnit0ofDim(0);
		fhd.dt = this.getDUnitofDim(0);
		return fhd;	
		}
	public RgHead makeRgHead(int itrace)
		{
		RgHead hd = new RgHead();
		hd.rec = (int)(itrace/getNMembofDim(1)) + 1;	/* field record number */
		hd.svp = hd.rec;	/* source location number */
		hd.gvp = itrace - getNMembofDim(1)*(hd.rec-1) + 1;	/* receiver location number */
		hd.sx = getUnit0ofDim(2) + (hd.svp-1)*getDUnitofDim(2);	/* source x-coordinate, m */
		hd.sy = 0;		/* source y-coordinate, m */
		hd.sz = 0;		/* source z-coordinate, m */
		hd.gx = getUnit0ofDim(1) + (hd.gvp-1)*getDUnitofDim(1);	/* receiver x-coordinate, m */
		hd.gy = 0;		/* receiver y-coordinate, m */
		hd.gz = 0;		/* receiver z-coordinate, m */
		hd.off = hd.gx;			/* offset, m, may be signed */
		hd.allset = false;
		return hd;	
		}
	
	/* J. Louie, 2006 */
	public void shade(float SunAzim, float SunHeight, float Dx, float Dy)
		{
		int ix, iy, ip, nx, ny, np, planesamp;
		nx = this.ne;
		ny = this.vecs;
		np = this.getNMembofDim(2);
		if (np > 1)
			ny = this.getNMembofDim(1);
		float fdx, fdy, fdz, sdx, sdy, sdz, intens, mag;
		/* obtain space for buffer array */
		planesamp = nx*ny;
		float buf[] = new float[planesamp];
		Notice("shade: generating shaded-relief of " + np + " planes of " + ny
			 + " vectors of " + nx + " elements each with SunAzim="
			 + SunAzim + " SunHeight=" + SunHeight + " Dx="
			 + Dx + " Dy=" + Dy + "... ");
		SunAzim = SunAzim*(float)(Math.PI)/180F;
		SunHeight = SunHeight*(float)(Math.PI)/180F;
		/* compute vector to sun angle */
		sdz = (float)(Math.sin((double)(SunHeight)));
		mag = (float)(Math.sqrt((double)(1 - sdz*sdz)));
		sdx = (-1F)*mag*(float)(Math.sin((double)(SunAzim)));
		sdy = mag*(float)(Math.cos((double)(SunAzim)));
		for (ip=0; ip<np; ip++)
		{
		/* copy current plane to buffer */
		for (ix=0; ix<planesamp; ix++)
			buf[ix] = this.vec[ip*planesamp + ix];
		/* compute slope on interior with a leapfrog finite-difference */
		for (iy=1; iy<(ny-1); iy++)
		for (ix=1; ix<(nx-1); ix++)
			this.vec[ip*planesamp + iy*nx + ix] =
			getIntens(buf[iy*nx + ix + 1], buf[iy*nx + ix - 1],
			buf[(iy+1)*nx + ix], buf[(iy-1)*nx + ix],
			Dx, Dy, sdx, sdy, sdz, 2F);
		/* compute slope on edges with an Euler finite-difference */
		/* top edge */
		for (iy=0; iy<1; iy++)
		for (ix=0; ix<(nx-1); ix++)
			this.vec[ip*planesamp + iy*nx + ix] =
			getIntens((buf[iy*nx + ix + 1] + buf[(iy+1)*nx + ix + 1])/2F,
			(buf[iy*nx + ix] + buf[(iy+1)*nx + ix])/2F,
			(buf[(iy+1)*nx + ix] + buf[(iy+1)*nx + ix + 1])/2F,
			(buf[iy*nx + ix] + buf[iy*nx + ix + 1])/2F,
			Dx, Dy, sdx, sdy, sdz, 1F);
		/* left edge */
		for (iy=1; iy<ny; iy++)
		for (ix=0; ix<1; ix++)
			this.vec[ip*planesamp + iy*nx + ix] =
			getIntens((buf[iy*nx + ix + 1] + buf[(iy-1)*nx + ix + 1])/2F,
			(buf[iy*nx + ix] + buf[(iy-1)*nx + ix])/2F,
			(buf[iy*nx + ix] + buf[iy*nx + ix + 1])/2F,
			(buf[(iy-1)*nx + ix] + buf[(iy-1)*nx + ix + 1])/2F,
			Dx, Dy, sdx, sdy, sdz, 1F);
		/* bottom edge */
		for (iy=(ny-1); iy<ny; iy++)
		for (ix=1; ix<nx; ix++)
			this.vec[ip*planesamp + iy*nx + ix] =
			getIntens((buf[iy*nx + ix] + buf[(iy-1)*nx + ix])/2F,
			(buf[iy*nx + ix - 1] + buf[(iy-1)*nx + ix - 1])/2F,
			(buf[iy*nx + ix] + buf[iy*nx + ix - 1])/2F,
			(buf[(iy-1)*nx + ix] + buf[(iy-1)*nx + ix - 1])/2F,
			Dx, Dy, sdx, sdy, sdz, 1F);
		/* right edge */
		for (iy=0; iy<(ny-1); iy++)
		for (ix=(nx-1); ix<nx; ix++)
			this.vec[ip*planesamp + iy*nx + ix] =
			getIntens((buf[iy*nx + ix] + buf[(iy+1)*nx + ix])/2F,
			(buf[iy*nx + ix - 1] + buf[(iy+1)*nx + ix - 1])/2F,
			(buf[(iy+1)*nx + ix] + buf[(iy+1)*nx + ix - 1])/2F,
			(buf[iy*nx + ix] + buf[iy*nx + ix - 1])/2F,
			Dx, Dy, sdx, sdy, sdz, 1F);
		}
	  	buf = null;
	  	this.AmpUnits = "Shaded " + this.AmpUnits;
		Noticeln("done.");
		}
	static float getIntens(float xp1, float xm1, float yp1, float ym1, float dx, float dy,
		float sdx, float sdy, float sdz, float fac)
		{
		float fdx, fdy, fdz, mag, intens;
		/* downslope gradient uses negative of derivative;
		   sin() reduces to unit vector */
		fdx = (float)(Math.sin(Math.atan2((double)(xp1 - xm1),
			(double)(dx * -1F * fac))));
		/* Y-axis direction is down (south) in Viewmat;
		   change sign on dy to north */
		fdy = (float)(Math.sin(Math.atan2((double)(yp1 - ym1),
			(double)(dy*fac))));
		mag = fdx*fdx + fdy*fdy;
		fdz = (float)(Math.sqrt((double)(1 - mag)));
		/* compute intensity by dot product of vectors */
		intens = (fdx*sdx + fdy*sdy + fdz*sdz);
		return (intens<0 ? 0F : intens);
		}
	static void shadePanel(ViewmatAction vad, ViewmatFrame f,
		boolean inplace, String label)
		{
		float SunAzim, SunHeight, Dx, Dy;
		SunAzim = 315F;
		SunHeight = 45F;
		if (f.vm.rowsdown)
			{
			Dx = f.vm.fp.getDUnitofDim(1);
			Dy = f.vm.fp.getDUnitofDim(0);
			}
		else
			{
			Dx = f.vm.fp.getDUnitofDim(0);
			Dy = f.vm.fp.getDUnitofDim(1);
			}
		if (Dx == 0F)
			Dx = 1F;
		if (Dy == 0F)
			Dy = 1F;
		if (Dx < 0F)
			Dx = -Dx;
		if (Dy < 0F)
			Dy = -Dy;
		vad.expl = new TextArea(label + " of " + f.getTitle()
			+ (inplace ? " in-place\n" : " in new window\n")
			+ "\n"
			+ "The " + label + " method on class FltPlane data\n"
			+ "converts the plane into a shaded-relief map.\n"
			+ label + " ignores the Vert. Exagg. and assumes the data\n"
			+ "values have the same units as the sample and\n"
			+ "vector spacings (usually height and lengths).\n"
			+ "Parameters below:\n"
			+ "Sun Azimuth sun direction in degrees clockwise\n"
			+ "   from north- up the height of the screen, 0=N,\n"
			+ "   90=E, 180=S, 270=W (float)\n"
			+ "Sun Height is sun elevation in degrees above\n"
			+ "   the horizon, 0-90 (pos. float).\n"
			+ "Dx and Dy are the horizontal and vertical sample\n "
			+ "   spacings as seen on the screen.",
			5, 35);
		vad.pp.add(vad.expl);
		vad.lab0 = new Label("Sun Azimuth (degrees, float):");
		vad.pp.add(vad.lab0);
		vad.tf0 = new TextField("" + SunAzim, 5);
		vad.pp.add(vad.tf0);
		vad.lab1 = new Label("Sun Height (degrees, >0, <90):");
		vad.pp.add(vad.lab1);
		vad.tf1 = new TextField("" + SunHeight, 4);
		vad.pp.add(vad.tf1);
		vad.lab2 = new Label("Dx (pos. float):");
		vad.pp.add(vad.lab2);
		vad.tf2 = new TextField("" + Dx, 5);
		vad.pp.add(vad.tf2);
		vad.lab3 = new Label("Dy (pos. float):");
		vad.pp.add(vad.lab3);
		vad.tf3 = new TextField("" + Dy, 5);
		vad.pp.add(vad.tf3);
		}
	public void doshade(ViewmatAction vad)
		{
		float SunAzim, SunHeight, Dx, Dy;
		SunAzim = 315F;
		SunHeight = 45F;
		if (f.vm.fvol == null)
			{
			if (f.vm.rowsdown)
				{
				Dx = f.vm.fp.getDUnitofDim(1);
				Dy = f.vm.fp.getDUnitofDim(0);
				}
			else
				{
				Dx = f.vm.fp.getDUnitofDim(0);
				Dy = f.vm.fp.getDUnitofDim(1);
				}
			}
		else
			{
			if (f.vm.rowsdown)
				{
				Dx = f.vm.fvol.getDUnitofDim(1);
				Dy = f.vm.fvol.getDUnitofDim(0);
				}
			else
				{
				Dx = f.vm.fvol.getDUnitofDim(0);
				Dy = f.vm.fvol.getDUnitofDim(1);
				}
			}
		if (Dx == 0F)
			Dx = 1F;
		if (Dy == 0F)
			Dy = 1F;
		if (Dx < 0F)
			Dx = -Dx;
		if (Dy < 0F)
			Dy = -Dy;
		float htemp;
		try {htemp = Float.valueOf(vad.tf0.getText()).floatValue(); }
		catch (NumberFormatException nfe)
			{htemp = SunAzim; }
		SunAzim = htemp;
		try {htemp = Float.valueOf(vad.tf1.getText()).floatValue(); }
		catch (NumberFormatException nfe)
			{htemp = SunHeight; }
		if (htemp < 0F)
			htemp = -htemp;
		if (htemp > 90F)
			htemp = 90F;
		SunHeight = htemp;
		try {htemp = Float.valueOf(vad.tf2.getText()).floatValue(); }
		catch (NumberFormatException nfe)
			{htemp = Dx; }
		if (htemp < 0F)
			htemp = -htemp;
		if (htemp == 0F)
			htemp = 1F;
		Dx = htemp;
		try {htemp = Float.valueOf(vad.tf2.getText()).floatValue(); }
		catch (NumberFormatException nfe)
			{htemp = Dy; }
		if (htemp < 0F)
			htemp = -htemp;
		if (htemp == 0F)
			htemp = 1F;
		Dy = htemp;
		SunAzim = SunAzim%360F;
		if (SunAzim < 0F)
			SunAzim = 360F + SunAzim;
		if (f.vm.rowsdown)
			{
			if (SunAzim > 270F)
				SunAzim = 630F - SunAzim;
			else
				SunAzim = 270F - SunAzim;
			htemp = Dx;
			Dx = Dy;
			Dy = htemp;
			}
		this.shade(SunAzim, SunHeight, Dx, Dy);
		}
		
       	public FltPlane slant(float t0, float dt, float x0, float dx,
	float tau0, int ntau, float p0, int np, float dp, boolean scale)
		{
		int nt, noff;
		nt = this.ne;
		noff = this.vecs;
		float starttime;
		starttime = t0;
		int it, nit, taddr, iptdrop, ip, ix, itau0, scl, sclv[], pscl, ps, s, tr;
		float fhld, ppts[], drop, offset, a;
		int istarttime, ihld;
		if (headers == null)
			Notice("slant: slantstacking " + noff + " vectors of " + nt
  			+ " elements each with t0=" + t0 + " dt=" + dt
  			+ " x0=" + x0 + " dx=" + dx
  			+ " tau0=" + tau0 + " ntau=" + ntau
  			+ " p0=" + p0 + " np=" + np + " dp=" + dp
  			+ " scale=" + scale + "... ");
  		else
  			Notice("slant: slantstacking " + noff + "  labeled traces of " + nt
  			+ " samples each with t0=" + t0 + " dt=" + dt
  			+ " " + getOffsets()
  			+ " tau0=" + tau0 + " ntau=" + ntau
  			+ " p0=" + p0 + " np=" + np + " dp=" + dp
  			+ " scale=" + scale + "... ");
  		itau0 = (int)(tau0/dt);
		ppts = new float[np];
		tr = 0;	/* index of this.vec[0*nt + 0] */
		FltPlane sfp = new FltPlane(np, ntau);
		s = 0;	/* index of sfp.vec[0*ntau + 0] */
		scl = 0;	/* index of sclv[0*ntau + 0] */
		sclv = null;
		pscl = 0;
		if (scale)
			sclv = new int[np*ntau];
		/* find all p - values     */
		for (ip = 0; ip < np; ip++)
			ppts[ip] = p0 + ip * dp;
		/* stack each trace into tau - p wavefield */
		for(ix=0; ix<noff; ix++)
			{
			if (headers == null)
				offset = x0 + ix*dx;
			else
				offset = (float)(headers[ix].off);
			tr = ix*this.ne;
			/* slant stack, use linear interpolation */
			for(ip=0; ip<np; ip++)
				{
				drop = ppts[ip] * offset /* * (invert ? -1F : 1F)*/ ;
 				iptdrop = (int) (drop/dt);
 				a = (drop - ((float)(iptdrop)*dt))/dt;
 				istarttime = (int)(starttime/dt) - iptdrop;
 				if (istarttime+nt <= itau0 || istarttime >= itau0+ntau)
 					continue;
 				if (istarttime >= itau0)
 					{
 					ps = s + ip*ntau + istarttime-itau0;
 					if (scale)
 						pscl = scl + ip*ntau + istarttime-itau0;
 					taddr = 0;
 					nit = itau0+ntau >= istarttime+nt ?
 						nt-1 : itau0+ntau-istarttime-1;
 					}
 				else
 					{
 					ps = s + ip*ntau;
 					if (scale)
 						pscl = scl + ip*ntau;
 					taddr = itau0 - istarttime;
 					nit = itau0+ntau >= istarttime+nt ?
 						nt-(itau0-istarttime)-1 : ntau-1;
 					}
 				if (scale)
 					{
 					for(it=0; it<nit; it++)
 				         	{
 				 		sfp.vec[ps] += this.vec[tr+taddr]*(1-a)
 				 			+ this.vec[tr+taddr+1]*a;
 						sclv[pscl]++;
 				 		ps++;
 						pscl++;
 				 		taddr++;
 				         	}
 					}
 				else
 					{
 					for(it=0; it<nit; it++)
 				         	{
 				 		sfp.vec[ps] += this.vec[tr+taddr]*(1-a)
 				 			+ this.vec[tr+taddr+1]*a;
 				 		ps++;
 				 		taddr++;
 				         	}
 					}
				}
			}
		if (scale)
			{
			ps = s;
			pscl = scl;
			for (it=0; it<np*ntau; it++)
				{
				if (sclv[pscl] > 1)
					sfp.vec[ps] /= (float)(sclv[pscl]);
				ps++;
				pscl++;
				}
			}
		ppts = null;
		sfp.setUnitsofDim(0, "Intercept Time, s");
		sfp.setUnit0ofDim(0, tau0);
		sfp.setDUnitofDim(0, dt);
		sfp.setUnitsofDim(1, "Slowness, sec/meter");
		sfp.setUnit0ofDim(1, p0);
		sfp.setDUnitofDim(1, dp);
		sfp.setAmpUnits("Slantstacked " + this.getAmpUnits());
		Noticeln("Done.");
		return sfp;
		}
	static void slantPanel(ViewmatAction vad, ViewmatFrame f,
		boolean inplace, String label)
		{
		float t0, dt, x0, dx, tau0, p0, dp;
		int ntau, np;
		boolean scale;
		RgHead headers[];
		if (f.vm.fvol == null)
			{
			t0 = f.vm.fp.getUnit0ofDim(0);
			dt = f.vm.fp.getDUnitofDim(0);
			x0 = f.vm.fp.getUnit0ofDim(1);
			dx = f.vm.fp.getDUnitofDim(1);
			ntau = f.vm.fp.ne;
			np = f.vm.fp.vecs;
			headers = f.vm.fp.headers;
			}
		else
			{
			t0 = f.vm.fvol.getUnit0ofDim(0);
			dt = f.vm.fvol.getDUnitofDim(0);
			x0 = f.vm.fvol.getUnit0ofDim(1);
			dx = f.vm.fvol.getDUnitofDim(1);
			ntau = f.vm.fvol.ne;
			np = f.vm.fvol.vecs;
			headers = f.vm.fvol.headers;
			}
		tau0 = t0;
		p0 = 0F;
		dp = 0.01F/np; /* sec/meter */
		scale = false;
		vad.expl = new TextArea(label + " of " + f.getTitle()
			+ (inplace ? " in-place\n" : " in new window\n")
			+ "The " + label + " method on class FltPlane data\n"
			+ "computes the slantstack (or p-tau transform)\n"
			+ "across all vectors\n"
			+ "Parameters below:\n"
			+ "t0=0: data start time, s\n"
			+ "dt=0.004: time between samples, s\n"
			+ "If traces are labeled with headers, the offset is used;\n"
			+ "otherwise supply the following:\n"
			+ "    x0=0: distance of first vector, m\n"
			+ "    dx=1: distance between vectors, m\n"
			+ "ntau=nt: number of elements in intercept time for stack\n"
			+ "dtau=dt\n"
			+ "tau0=0: initial intercept time\n"
			+ "np=nx: number of slowness vectors\n"
			+ "p0=0: first p slowness, s/m\n"
			+ "dp=0.01/np: slowness interval, s/m\n"
			+ "scale=false: no scaling applied to slantstack\n"
			+ "   true: apply scaling by averaging values summed\n"
			+ "   into slantstack",
			5, 35);
		vad.pp.add(vad.expl);
		vad.lab0 = new Label("t0 (sec):");
		vad.pp.add(vad.lab0);
		vad.tf0 = new TextField("" + t0, 4);
		vad.pp.add(vad.tf0);
		vad.lab1 = new Label("dt (sec):");
		vad.pp.add(vad.lab1);
		vad.tf1 = new TextField("" + dt, 6);
		vad.pp.add(vad.tf1);
		if (headers == null)
			{
			vad.lab2 = new Label("x0 (meter):");
			vad.pp.add(vad.lab2);
			vad.tf2 = new TextField("" + x0, 4);
			vad.pp.add(vad.tf2);
			vad.lab3 = new Label("dx (meter):");
			vad.pp.add(vad.lab3);
			vad.tf3 = new TextField("" + dx, 4);
			vad.pp.add(vad.tf3);
			}
		else
			{
			vad.lab2 = new Label("Labeled Traces:");
			vad.pp.add(vad.lab2);
			if (f.vm.fvol == null)
				vad.lab3 = new Label(f.vm.fp.getOffsets());
			else
				vad.lab3 = new Label(f.vm.fvol.getOffsets());
			vad.pp.add(vad.lab3);
			}
		vad.lab4 = new Label("tau0 (sec):");
		vad.pp.add(vad.lab4);
		vad.tf4 = new TextField("" + tau0, 4);
		vad.pp.add(vad.tf4);
		vad.lab5 = new Label("p0 (s/m):");
		vad.pp.add(vad.lab5);
		vad.tf5 = new TextField("" + p0, 6);
		vad.pp.add(vad.tf5);
		vad.lab6 = new Label("dp (s/m):");
		vad.pp.add(vad.lab6);
		vad.tf6 = new TextField("" + dp, 6);
		vad.pp.add(vad.tf6);
		vad.lab7 = new Label("ntau (+int):");
		vad.pp.add(vad.lab7);
		vad.tf7 = new TextField("" + ntau, 4);
		vad.pp.add(vad.tf7);
		vad.lab8 = new Label("np (+int):");
		vad.pp.add(vad.lab8);
		vad.tf8 = new TextField("" + np, 4);
		vad.pp.add(vad.tf8);
		vad.cb0 = new Checkbox("scale?");
		vad.pp.add(vad.cb0);
		vad.cb0.setState(scale);
		vad.height = 400;
		}
	public FltPlane doslant(ViewmatAction vad)
		{
		float t0, dt, x0, dx, tau0, p0, dp;
		int ntau, np;
		boolean scale;
		if (f.vm.fvol == null)
			{
			t0 = f.vm.fp.getUnit0ofDim(0);
			dt = f.vm.fp.getDUnitofDim(0);
			x0 = f.vm.fp.getUnit0ofDim(1);
			dx = f.vm.fp.getDUnitofDim(1);
			ntau = f.vm.fp.ne;
			np = f.vm.fp.vecs;
			}
		else
			{
			t0 = f.vm.fvol.getUnit0ofDim(0);
			dt = f.vm.fvol.getDUnitofDim(0);
			x0 = f.vm.fvol.getUnit0ofDim(1);
			dx = f.vm.fvol.getDUnitofDim(1);
			ntau = f.vm.fvol.ne;
			np = f.vm.fvol.vecs;
			}
		tau0 = t0;
		p0 = 0F;
		dp = 0.01F/np; /* sec/meter */
		scale = false;
		float htemp;
		int temp;
		try {htemp = Float.valueOf(vad.tf0.getText()).floatValue(); }
		catch (NumberFormatException nfe)
			{htemp = t0; }
		t0 = htemp;
		try {htemp = Float.valueOf(vad.tf1.getText()).floatValue(); }
		catch (NumberFormatException nfe)
			{htemp = dt; }
		if (htemp < 0F)
			htemp = -htemp;
		dt = htemp;
		if (this.headers == null)
			{
			try {htemp = Float.valueOf(vad.tf2.getText()).floatValue(); }
			catch (NumberFormatException nfe)
				{htemp = x0; }
			x0 = htemp;
			try {htemp = Float.valueOf(vad.tf3.getText()).floatValue(); }
			catch (NumberFormatException nfe)
				{htemp = dx; }
			dx = htemp;
			}
		try {htemp = Float.valueOf(vad.tf4.getText()).floatValue(); }
		catch (NumberFormatException nfe)
			{htemp = tau0; }
		tau0 = htemp;
		try {htemp = Float.valueOf(vad.tf5.getText()).floatValue(); }
		catch (NumberFormatException nfe)
			{htemp = p0; }
		p0 = htemp;
		try {htemp = Float.valueOf(vad.tf6.getText()).floatValue(); }
		catch (NumberFormatException nfe)
			{htemp = dp; }
		dp = htemp;
		try {temp = Integer.valueOf(vad.tf7.getText()).intValue(); }
		catch (NumberFormatException nfe)
			{temp = ntau; }
		if (temp <= 0)
			temp = ntau;
		ntau = temp;
		try {temp = Integer.valueOf(vad.tf8.getText()).intValue(); }
		catch (NumberFormatException nfe)
			{temp = np; }
		if (temp <= 0)
			temp = np;
		np = temp;
		scale = vad.cb0.getState();
		return this.slant(t0, dt, x0, dx, tau0, ntau, p0, np, dp, scale);
		}
	
       	public void smooth(int xw, int tw, int norm)
       		{
		int nx, nt, np;
		nt = this.ne;
		nx = this.vecs;
		np = this.getNMembofDim(2);
		if (np > 1)
			nx = this.getNMembofDim(1);
		int p, x, t, x1, t1, tad, addr, count, nxtrd;
		int readp, flag[], xwd, next;
		float hold, avbuf[], buf[], qbuf[], max;
		if (xw <= 0 || tw <= 0)
			{
			Errout("smooth: xw=" + xw + " and tw=" + tw
				+ "; must be positive ints, no smoothing done");
			return;
			}
		if (xw > nx)
			xw = nx;
		if (tw > nt)
			tw = nt;
		Notice("smooth: applying " + xw + "-vector by " + tw +
			"-element kernel, norm=" + norm + " on " + np + " planes of "
			 + nx + " vectors of " + nt + " elements... ");
		this.setAmpUnits("" + xw + "x" + tw + "-Smoothed "
			+ this.getAmpUnits());
             		xw = xw/2;
		xwd = 2*xw + 1;
		tw = tw/2;
		if (norm < 0 || norm > 2)
			{
			Errout("smooth: norm type " + norm + " not 0, 1, or 2, abort");
			return;
			}
		buf = new float[xwd*nt];
		qbuf = new float[xwd*(2*tw+1)];
		avbuf = new float[nt];
		flag = new int[xwd];
		for (p=0; p<np; p++)
		{
		readp = 0;
		for (x=0; x<xwd; x++)
			flag[x] = 0;
		for(x1= xw; x1<xwd; x1++)
			{
			System.arraycopy(this.vec, p*nx*nt + readp, buf, x1*nt, nt);
			readp += nt;
			flag[x1] = 1;
			}
		next = xwd;
		nxtrd = (xwd-1)*nt;
		for (x=0; x<nx; x++)
			{
			if (x < nx-xw && x != 0)
				{
				System.arraycopy(this.vec, p*nx*nt + readp,
					buf, nxtrd, nt);
				readp += nt;
				flag[next] = 1;
				}
			else if (x != 0)
				flag[next] = 0;
			if (norm == 0)
				{
				for(t=0; t<nt; t++)
					{
					count = 0;
					max = 0F;
					for(x1=0; x1<xwd; x1++)
						{
						if (flag[x1] == 1)
							{
							for(t1= -tw; t1<=tw; t1++)
							   {
							   tad = t + t1;
							   if(tad>=0 && tad < nt)
							      {
							      addr = x1*nt + tad;
							      hold = buf[addr];
							      if (hold > max)
								{
							      	qbuf[count] = hold;
								max = hold;
							      	count++;
								}
							      }
							   }
							}
						}
					if (count > 2)
						avbuf[t] = qbuf[count/2];
					else if (t > 0 && max != 0)
						avbuf[t] = avbuf[t-1];
					else
						avbuf[t] = 0;
					}
				}
			else if (norm == 1)
				{
				for(t=0; t<nt; t++)
					{
					count = 0;
					for(x1=0; x1<xwd; x1++)
						{
						if (flag[x1] == 1)
							{
							for(t1= -tw; t1<=tw; t1++)
								{
								tad = t + t1;
								if(tad>=0 && tad < nt)
									{
									addr = x1*nt +
										tad;
									qbuf[count] =
									   buf[addr];
									count++;
									}
								}
							}
						}
					avbuf[t] = FltVec.quant(count/2, qbuf, count);
					}
				}
			else
				{
				for(t=0; t<nt; t++)
					{
					count = 0;
					hold = 0F;
					for(x1=0; x1<xwd; x1++)
						{
						if (flag[x1] == 1)
							{
							for(t1= -tw; t1<=tw; t1++)
								{
								tad = t + t1;
								if(tad>=0 && tad < nt)
									{
									addr = x1*nt +
										tad;
									hold +=
									   buf[addr];
									count++;
									}
								}
							}
						}
					if (count > 0)
						avbuf[t] = hold/count;
					else if (t > 0)
						avbuf[t] = avbuf[t-1];
					else
						avbuf[t] = 0F;
					}
				}
			nxtrd += nt;
			next++;
			if (next >= xwd)
				{
				nxtrd = 0;
				next = 0;
				}
			System.arraycopy(avbuf, 0, this.vec, p*nx*nt + x*nt, nt);
			readp = x*nt + nt;
			}
		} /* end of loop over planes */
		buf = null;
		qbuf = null;
		avbuf = null;
		flag = null;
		Noticeln("done.");
		}
       	public void smooth()
       		{
		smooth(1, 11, 0);
		}
	static void smoothPanel(ViewmatAction vad, ViewmatFrame f,
		boolean inplace, String label)
		{
		int xw, tw, norm;
		xw = 1;
		tw = 11;
		norm = 2;
		vad.expl = new TextArea(label + " of " + f.getTitle()
			+ (inplace ? " in-place\n" : " in new window\n")
			+ "The " + label + " method on class FltPlane data\n"
			+ "smooths the amplitudes using an averaging\n"
			+ "kernel of adjustable size.\n"
			+ "Parameters are:\n"
			+ "xw=1:	width of averaging kernel across vectors,\n"
			+ "	will be made odd\n"
			+ "tw=11	width of averaging kernel across elements\n"
			+ "	will be made odd\n"
			+ "norm=2		2: uses L-2 norm (average)\n"
			+ "	1: uses L-1 norm (median)\n"
			+ "	0: uses a faster scheme that often\n"
			+ "		finds the median.",
			5, 35);
		vad.pp.add(vad.expl);
		vad.lab0 = new Label("Kernel Vector Width (+ odd int):");
		vad.pp.add(vad.lab0);
		vad.tf0 = new TextField("" + xw, 4);
		vad.pp.add(vad.tf0);
		vad.lab1 = new Label("Kernel Element Length (+ odd int):");
		vad.pp.add(vad.lab1);
		vad.tf1 = new TextField("" + tw, 4);
		vad.pp.add(vad.tf1);
		vad.lab2 = new Label("Smoothing Operator:");
		vad.pp.add(vad.lab2);
		vad.ch0 = new Choice();
		vad.ch0.add("Fast Approx. Median");
		vad.ch0.add("L-1 Norm (Median)");
		vad.ch0.add("L-2 Norm (Average)");
		vad.pp.add(vad.ch0);
		vad.ch0.select(2);		
		}
	public void dosmooth(ViewmatAction vad)
		{
		int xw, tw, norm, temp;
		xw = 1;
		tw = 11;
		norm = 2;
		try {temp = Integer.valueOf(vad.tf0.getText()).intValue(); }
		catch (NumberFormatException nfe)
			{temp = xw; }
		if (temp == 0)
			temp = xw;
		if (temp < 0)
			temp = -temp;
		if (temp%2 == 0)
			temp++;
		xw = temp;
		norm = vad.ch0.getSelectedIndex();
		try {temp = Integer.valueOf(vad.tf1.getText()).intValue(); }
		catch (NumberFormatException nfe)
			{temp = tw; }
		if (temp == 0)
			temp = tw;
		if (temp < 0)
			temp = -temp;
		if (temp%2 == 0)
			temp++;
		tw = temp;
		norm = vad.ch0.getSelectedIndex();
		this.smooth(xw, tw, norm);
		}

	public void sort(int basis)
		{
		if (headers == null)
			{
			Errout("This FltPlane has no headers, sort aborted.");
			return;
			}
		if (basis < 0 || basis > 10)
			{
			Errout("Sort: basis=" + basis + " not between 0 and 10, aborted.");
			return;
			}
		Notice("Sorting " + vecs + " traces of " + ne
			+ " elements each by basis " + basis + " ...");
		RgHead tmphd = new RgHead();
		float tmp[] = new float[ne];
		quickSort(0, vecs-1, basis, tmphd, tmp);
		tmphd = null;
		tmp= null;
		Noticeln(" Done.");
		}
	public void quickSort(int left, int right, int basis, RgHead tmphd, float tmp[])
		{
		int i, last;
		if (left >= right)
			return;
		swap(left, (left+right)/2, tmphd, tmp);
		last = left;
		for (i=left+1; i<=right; i++)
			if (compareHead(headers[i], headers[left], basis) == -1)
				swap( ++last, i, tmphd, tmp);
		swap(last, left, tmphd, tmp);
		quickSort(left, last-1, basis, tmphd, tmp);
		quickSort(last+1, right, basis, tmphd, tmp);
		}
	public static int compareHead(RgHead s, RgHead t, int basis)
		{
		int shold, thold;
		double sdhold, tdhold, sxmid, symid, txmid, tymid;
		if (basis == 0)		/* Midpoint */
			{
			sxmid = (s.gx + s.sx)/2;
			symid = (s.gy + s.sy)/2;
			txmid = (t.gx + t.sx)/2;
			tymid = (t.gy + t.sy)/2;
			sdhold = sxmid*sxmid + symid*symid;
			tdhold = txmid*txmid + tymid*tymid;
			if (sdhold < tdhold)
				return -1;
			else if (sdhold == tdhold)
				return 0;
			else
				return 1;
			}
		else if (basis >= 1 && basis <= 3)
			{
			if (basis == 1)		/* Record */
				{
				shold = s.rec;
				thold = t.rec;
				}
			else if (basis == 2)		/* source location number */
				{
				shold = s.svp;
				thold = t.svp;
				}
			else				/* receiver location number */
				{
				shold = s.gvp;
				thold = t.gvp;
				}
			if (shold < thold)
				return -1;
			else if (shold == thold)
				return 0;
			else
				return 1;
			}
		else
			{
			if (basis == 4)		/* source x-coordinate */
				{
				sdhold = s.sx;
				tdhold = t.sx;
				}
			else if (basis == 5)		/* source y-coordinate */
				{
				sdhold = s.sy;
				tdhold = t.sy;
				}
			else if (basis == 6)		/* source z-coordinate */
				{
				sdhold = s.sz;
				tdhold = t.sz;
				}
			else if (basis == 7)		/* receiver x-coordinate */
				{
				sdhold = s.gx;
				tdhold = t.gx;
				}
			else if (basis == 8)		/* receiver y-coordinate */
				{
				sdhold = s.gy;
				tdhold = t.gy;
				}
			else if (basis == 9)		/* receiver z-coordinate */
				{
				sdhold = s.gz;
				tdhold = t.gz;
				}
			else					/* offset, m, may be signed */
				{
				sdhold = s.off;
				tdhold = t.off;
				}
			if (sdhold < tdhold)
				return -1;
			else if (sdhold == tdhold)
				return 0;
			else
				return 1;
			}
		}
	public void swap(int d1, int d2, RgHead tmphd, float tmp[])
		{
		int i;
		tmphd.copy(headers[d1]);
		headers[d1].copy(headers[d2]);
		headers[d2].copy(tmphd);
		for (i=0; i<ne; i++)
			tmp[i] = vec[d1*ne + i];
		for (i=0; i<ne; i++)
			vec[d1*ne + i] = vec[d2*ne + i];
		for (i=0; i<ne; i++)
			vec[d2*ne + i] = tmp[i];
		}
	static void sortPanel(ViewmatAction vad, ViewmatFrame f,
		boolean inplace, String label)
		{
		vad.expl = new TextArea(label + " of " + f.getTitle() + "\n"
			+ "Always in-place.\n"
			+ "The " + label + " method on class FltPlane data\n"
			+ "will sort all traces and headers\n"
			+ "according to the selected header value.",
			5, 35);
		vad.pp.add(vad.expl);
		RgHead hd, headers[];
		if (f.vm.fvol == null)
			{
			vad.lab2 = new Label(f.vm.fp.getOffsets());
			headers = f.vm.fp.headers;
			}
		else
			{
			vad.lab2 = new Label(f.vm.fvol.getOffsets());
			headers = f.vm.fvol.headers;
			}
		if (headers == null)
			{
			vad.lab0 = new Label("This FltPlane has no headers.");
			vad.pp.add(vad.lab0);
			return;
			}
		hd = new RgHead(headers[0]);
		vad.lab0 = new Label("Sort Traces by:");
		vad.pp.add(vad.lab0);
		vad.ch0 = new Choice();
		vad.ch0.add("Midpoint");
		vad.ch0.add("Field Record Number");
		vad.ch0.add("Source Location Number");
		vad.ch0.add("Receiver Location Number");
		vad.ch0.add("Source X-Coordinate");
		vad.ch0.add("Source Y-Coordinate");
		vad.ch0.add("Source Z-Coordinate");
		vad.ch0.add("Receiver X-Coordinate");
		vad.ch0.add("Receiver Y-Coordinate");
		vad.ch0.add("Receiver Z-Coordinate");
		vad.ch0.add("Offset");
		vad.pp.add(vad.ch0);
		vad.ch0.select(0);		
		vad.lab1 = new Label("Present Offset Range:");
		vad.pp.add(vad.lab1);
		vad.pp.add(vad.lab2);
		}
	public void dosort(ViewmatAction vad)
		{
		int basis;
		if (this.headers == null)
			return;
		basis = vad.ch0.getSelectedIndex();
		sort(basis);
		}

	public FltPlane sweep(int nx, int nt, float f0, float fe, float len,
		float phase)
		{
		return sweep(nx, nt, f0, fe, len, phase, 0, 0);
		}
	public FltPlane sweep(int nx, int nt, float f0, float fe, float len,
		float phase, int taper, int listen)
		{
		int i, j;
		double rphase, kf, freq, dt;
		rphase = Math.PI*phase/180;
		dt = len/nt;
		kf = (fe - f0)/len;
		Notice("Computing " + nx + " " + len + "-sec " + f0 + "-" + fe
			+ " Hz sweeps from " + phase + " degrees with "
			+ taper + "-point taper and " + listen + "-point listen... ");
		FltPlane fp = new FltPlane(nx, nt);
		for (j=0; j<nx; j++)
			for (i=0; i<nt; i++)
				{
				freq = f0 + (kf*i*dt);
				fp.setElem(j, i,
				(float)(Math.sin((Math.PI*freq)*(i*dt) + rphase)));
				}
		fp.setAmpUnits("" + f0 + "-" + fe + "-Hz Raw Sweep");
		fp.setUnit0ofDim(0, 0F);
		fp.setDUnitofDim(0, (float)(dt));
		fp.setUnitsofDim(0, "Time, sec");
		if (taper > 0)
			{
			fp.hann((float)(2*taper*dt/len), 0.05F, false);
			fp.setAmpUnits("" + taper + "-Point Tapered "
				+ f0 + "-" + fe + "-Hz Sweep");
			}
		FltPlane tfp;
		if (listen > 0)
			{
			tfp = fp.pad(listen);
			fp = null;
			}
		else
			tfp = fp;
		Noticeln("done.");
		return tfp;
		}
	static void sweepPanel(ViewmatAction vad, ViewmatFrame f,
		boolean inplace, String label)
		{
		int nx, nt;
		float f0=8F, fe=48F, len=10F, phase=0F, dt;
		if (f.vm.fvol == null)
			{
			nx = f.vm.fp.vecs;
			nt = f.vm.fp.ne;
			dt = f.vm.fp.getDUnitofDim(0);
			}
		else
			{
			nx = f.vm.fvol.vecs;
			nt = f.vm.fvol.ne;
			dt = f.vm.fvol.getDUnitofDim(0);
			}
		len = nt*dt;
		vad.expl = new TextArea(label + " of " + f.getTitle()
			+ (inplace ? " in-place\n" : " in new window\n")
			+ "\n"
			+ "The " + label + " method creates a new FltPlane object\n"
			+ "of one or more (identical) vibrator sweep\n"
			+ "traces, from the linear specifications below.",
			5, 35);
		vad.pp.add(vad.expl);
		vad.lab0 = new Label("Number of Traces (+int):");
		vad.pp.add(vad.lab0);
		vad.tf0 = new TextField("" + nx, 4);
		vad.pp.add(vad.tf0);
		vad.lab1 = new Label("Time Points per Sweep (+int):");
		vad.pp.add(vad.lab1);
		vad.tf1 = new TextField("" + nt, 5);
		vad.pp.add(vad.tf1);
		vad.lab2 = new Label("Start Frequency, Hz (+flt):");
		vad.pp.add(vad.lab2);
		vad.tf2 = new TextField("" + f0, 4);
		vad.pp.add(vad.tf2);
		vad.lab3 = new Label("End Frequency, Hz (+flt):");
		vad.pp.add(vad.lab3);
		vad.tf3 = new TextField("" + fe, 4);
		vad.pp.add(vad.tf3);
		vad.lab4 = new Label("Sweep Length, seconds (+flt):");
		vad.pp.add(vad.lab4);
		vad.tf4 = new TextField("" + len, 4);
		vad.pp.add(vad.tf4);
		vad.lab5 = new Label("Initial Phase, degrees (+/-flt):");
		vad.pp.add(vad.lab5);
		vad.tf5 = new TextField("" + phase, 4);
		vad.pp.add(vad.tf5);
		vad.lab6 = new Label("Sweep Taper, samples (+int):");
		vad.pp.add(vad.lab6);
		vad.tf6 = new TextField("0", 4);
		vad.pp.add(vad.tf6);
		vad.lab7 = new Label("Addl. Listen Time, samples (+int):");
		vad.pp.add(vad.lab7);
		vad.tf7 = new TextField("" + nt, 5);
		vad.pp.add(vad.tf7);
		vad.height = 400;
		}
	public FltPlane dosweep(ViewmatAction vad)
		{
		int nx, nt, taper, listen, temp;
		float f0=8F, fe=48F, len=10F, phase=0F, htemp;
		if (vad.f.vm.fvol == null)
			{
			nx = vad.f.vm.fp.vecs;
			nt = vad.f.vm.fp.ne;
			}
		else
			{
			nx = vad.f.vm.fvol.vecs;
			nt = vad.f.vm.fvol.ne;
			}
		try {temp = Integer.valueOf(vad.tf0.getText()).intValue(); }
		catch (NumberFormatException nfe)
			{temp = nx; }
		if (temp < 0)
			temp = -temp;
		if (temp == 0 || temp > 1e20)
			temp = nx;
		nx = temp;
		try {temp = Integer.valueOf(vad.tf1.getText()).intValue(); }
		catch (NumberFormatException nfe)
			{temp = nt; }
		if (temp < 0)
			temp = -temp;
		if (temp == 0 || temp > 1e20)
			temp = nt;
		nt = temp;
		try {htemp = Float.valueOf(vad.tf2.getText()).floatValue(); }
		catch (NumberFormatException nfe)
			{htemp = f0; }
		if (htemp < 0F)
			htemp = -htemp;
		f0 = htemp;
		try {htemp = Float.valueOf(vad.tf3.getText()).floatValue(); }
		catch (NumberFormatException nfe)
			{htemp = fe; }
		if (htemp < 0F)
			htemp = -htemp;
		fe = htemp;
		try {htemp = Float.valueOf(vad.tf4.getText()).floatValue(); }
		catch (NumberFormatException nfe)
			{htemp = len; }
		if (htemp < 0F)
			htemp = -htemp;
		if (htemp == 0F || htemp > 1e20F)
			htemp = len;
		len = htemp;
		try {htemp = Float.valueOf(vad.tf5.getText()).floatValue(); }
		catch (NumberFormatException nfe)
			{htemp = phase; }
		if (htemp < -1e20F || htemp > 1e20F)
			htemp = phase;
		phase = htemp;
		try {temp = Integer.valueOf(vad.tf6.getText()).intValue(); }
		catch (NumberFormatException nfe)
			{temp = 0; }
		if (temp < 0)
			temp = -temp;
		if (temp > nt)
			temp = 0;
		taper = temp;
		try {temp = Integer.valueOf(vad.tf7.getText()).intValue(); }
		catch (NumberFormatException nfe)
			{temp = nt; }
		if (temp < 0)
			temp = -temp;
		if (temp > 1e20)
			temp = nt;
		listen = temp;
		return this.sweep(nx, nt, f0, fe, len, phase, taper, listen);
		}
	static void sweepTrigPanel(ViewmatAction vad, ViewmatFrame f,
		boolean inplace, String label)
		{
		int nx, nt;
		float f0=100F, fe=500F, len=10F, phase=0F, dt;
		if (f.vm.fvol == null)
			{
			nx = f.vm.fp.vecs;
			nt = f.vm.fp.ne;
			dt = f.vm.fp.getDUnitofDim(0);
			}
		else
			{
			nx = f.vm.fvol.vecs;
			nt = f.vm.fvol.ne;
			dt = f.vm.fvol.getDUnitofDim(0);
			}
		nx /= 2;
		len = nt*dt;
		vad.expl = new TextArea(label + " of " + f.getTitle()
			+ (inplace ? " in-place\n" : " in new window\n")
			+ "\n"
			+ "The " + label + " method creates a new FltPlane object\n"
			+ "of one or more (identical) vibrator sweep\n"
			+ "traces, alternating with traces containing\n"
			+ "just a trigger pulse. This object can be written\n"
			+ "as a sound file and played to control an\n"
			+ "acoustic vibrator (left channel) and trigger a\n"
			+ "seismograph (right channel).",
			5, 35);
		vad.pp.add(vad.expl);
		vad.lab0 = new Label("Number of Stacks (+int):");
		vad.pp.add(vad.lab0);
		vad.tf0 = new TextField("" + nx, 4);
		vad.pp.add(vad.tf0);
		vad.lab1 = new Label("Recorder Reset Time, sec. (+flt):");
		vad.pp.add(vad.lab1);
		vad.tf1 = new TextField("0.5", 4);
		vad.pp.add(vad.tf1);
		vad.lab2 = new Label("Start Frequency, Hz (+flt):");
		vad.pp.add(vad.lab2);
		vad.tf2 = new TextField("" + f0, 4);
		vad.pp.add(vad.tf2);
		vad.lab3 = new Label("End Frequency, Hz (+flt):");
		vad.pp.add(vad.lab3);
		vad.tf3 = new TextField("" + fe, 4);
		vad.pp.add(vad.tf3);
		vad.lab4 = new Label("Sweep Length, seconds (+flt):");
		vad.pp.add(vad.lab4);
		vad.tf4 = new TextField("" + ((len-0.5)/2), 4);
		vad.pp.add(vad.tf4);
		vad.lab5 = new Label("Trigger Length, seconds (+flt):");
		vad.pp.add(vad.lab5);
		vad.tf5 = new TextField("0.05", 4);
		vad.pp.add(vad.tf5);
		vad.lab6 = new Label("Sweep Taper, seconds (+flt):");
		vad.pp.add(vad.lab6);
		vad.tf6 = new TextField("" + ((len-0.5)/20), 5);
		vad.pp.add(vad.tf6);
		vad.lab7 = new Label("Addl. Listen Time, seconds (+flt):");
		vad.pp.add(vad.lab7);
		vad.tf7 = new TextField("" + ((len-0.5)/2), 4);
		vad.pp.add(vad.tf7);
		vad.height = 400;
		}
	public FltPlane dosweepTrig(ViewmatAction vad)
		{
		int nx, nt, taper, listen, reset, trig, temp;
		float f0=8F, fe=48F, len=10F, ftaper, flisten, phase=0F, dt;
		float ftrig=0.02F, freset=0.5F, htemp;
		if (vad.f.vm.fvol == null)
			{
			nx = vad.f.vm.fp.vecs;
			nt = vad.f.vm.fp.ne;
			dt = f.vm.fp.getDUnitofDim(0);
			}
		else
			{
			nx = vad.f.vm.fvol.vecs;
			nt = vad.f.vm.fvol.ne;
			dt = f.vm.fvol.getDUnitofDim(0);
			}
		nx /= 2;
		len = (nx*dt - 0.5F)/2F;
		flisten = len;
		ftaper = len/20F;
		try {temp = Integer.valueOf(vad.tf0.getText()).intValue(); }
		catch (NumberFormatException nfe)
			{temp = nx; }
		if (temp < 0)
			temp = -temp;
		if (temp == 0 || temp > 1e20)
			temp = nx;
		nx = temp;
		try {htemp = Float.valueOf(vad.tf1.getText()).floatValue(); }
		catch (NumberFormatException nfe)
			{htemp = freset; }
		if (htemp < 0)
			htemp = -htemp;
		if (temp > 1000)
			htemp = freset;
		freset = htemp;
		try {htemp = Float.valueOf(vad.tf2.getText()).floatValue(); }
		catch (NumberFormatException nfe)
			{htemp = f0; }
		if (htemp < 0F)
			htemp = -htemp;
		f0 = htemp;
		try {htemp = Float.valueOf(vad.tf3.getText()).floatValue(); }
		catch (NumberFormatException nfe)
			{htemp = fe; }
		if (htemp < 0F)
			htemp = -htemp;
		if (htemp == f0 && f0 > 0F)
			htemp = 4F*f0;
		else if (htemp == f0 && f0 == 0F)
			htemp = 500F;
		fe = htemp;
		if (fe > f0)
			dt = 1/fe/2;
		else
			dt = 1/f0/2;
		reset = (int)(freset/dt);
		try {htemp = Float.valueOf(vad.tf4.getText()).floatValue(); }
		catch (NumberFormatException nfe)
			{htemp = len; }
		if (htemp < 0F)
			htemp = -htemp;
		if (htemp == 0F || htemp > 1e9F)
			htemp = len;
		len = htemp;
		nt = (int)(len/dt);
		try {htemp = Float.valueOf(vad.tf5.getText()).floatValue(); }
		catch (NumberFormatException nfe)
			{htemp = ftrig; }
		if (htemp < 0F)
			htemp = -htemp;
		if (htemp == 0F || htemp > 1e9F)
			htemp = ftrig;
		ftrig = htemp;
		trig = (int)(ftrig/dt);
		try {htemp = Float.valueOf(vad.tf6.getText()).floatValue(); }
		catch (NumberFormatException nfe)
			{htemp = ftaper; }
		if (htemp < 0)
			htemp = -htemp;
		if (htemp > len/2F)
			htemp = ftaper;
		ftaper = htemp;
		taper = (int)(ftaper/dt);
		try {htemp = Float.valueOf(vad.tf7.getText()).floatValue(); }
		catch (NumberFormatException nfe)
			{htemp = flisten; }
		if (temp < 0)
			htemp = -htemp;
		if (temp > 1000F)
			htemp = len;
		flisten = htemp;
		listen = (int)(flisten/dt);
		FltPlane swp = this.sweep(1, nt, f0, fe, len, phase, taper, listen);
		FltPlane swtr = new FltPlane(2*nx, reset+swp.ne);
		swtr.copyvals(swp);
		swtr.vecs = 2*nx;
		swtr.ne = reset+swp.ne;
		for (int k=0; k<swtr.vecs; k++)
			{
			if (k%2 == 0)
				{
				for (int t=0; t<swp.ne; t++)
					swtr.vec[k*swtr.ne + reset + t] = swp.vec[t];
				}
			else
				{
				for (int t=0; t<trig; t++)
					swtr.vec[k*swtr.ne + reset + t] = 1F;
				}
			}
		swp.vec = null;
		swp = null;
		return swtr;
		}
		
	static void traceditPanel(ViewmatAction vad, ViewmatFrame f,
		boolean inplace, String label)
		{
		vad.expl = new TextArea(label + " of " + f.getTitle()
			+ (inplace ? " in-place\n" : " in new window\n")
			+ "\n"
			+ "The " + label + " method on class FltPlane data\n"
			+ "multiplies the factor supplied by each trace\n"
			+ "having a pick; optionally by each trace not picked.\n"
			+ "A multiplier of zero achieves editing;\n"
			+ "a multiplier of -1.0 does sign reversal.",
			5, 35);
		vad.pp.add(vad.expl);
		vad.lab0 = new Label("Edit:");
		vad.pp.add(vad.lab0);
		vad.ch0 = new Choice();
		vad.ch0.add("Picked Traces");
		vad.ch0.add("Traces Not Picked");
		vad.pp.add(vad.ch0);
		vad.ch0.select(0);		
		vad.lab1 = new Label("Multiplier:");
		vad.pp.add(vad.lab1);
		vad.tf0 = new TextField("0.0", 4);
		vad.pp.add(vad.tf0);
		}
	public void dotracedit(ViewmatAction vad)
		{
		int npicked;
		boolean picked;
		float htemp, mult;
		if (vad.ch0.getSelectedIndex() == 1)
			picked = false;
		else
			picked = true;
		mult = 0F;
		try {htemp = Float.valueOf(vad.tf0.getText()).floatValue(); }
		catch (NumberFormatException nfe)
			{htemp = mult; }
		mult = htemp;
		npicked = ViewmatPicks.getNPicked(this);
		if (npicked <= 0)
			this.Errout("There are no valid picks of this data set.\n"
			+ "Check the text in the Pick Window.\n"
			+ "The multiplier "  + mult + " will be applied to "
			+ (picked ? "none" : "all") + " of the " + this.vecs + " traces.");
		else if (npicked >= this.vecs)
			this.Errout("All traces in this data set have picks.\n"
			+ "Check the text in the Pick Window.\n"
			+ "The multiplier "  + mult + " will be applied to "
			+ (picked ? "all" : "none") + " of the " + this.vecs + " traces.");
		ViewmatPicks.tracedit(this, picked, mult);
		}
	
	public void readRGFile(String name, boolean oldrg)
		{
		int i, j;
		FileInputStream fis = null;
		BufferedInputStream bis = null;
		DataInputStream dis = null;
		try {fis = new FileInputStream(name); }
		catch(FileNotFoundException fnf)
			{
			Errout("RG file " + name + " not found: " + fnf.toString());
			return;
			}
		bis = new BufferedInputStream(fis);
		dis = new DataInputStream(bis);
		OldRGFileHead ofhd = new OldRGFileHead();
		OldRGTraceHead othd = new OldRGTraceHead();
		RgFileHead fhd = new RgFileHead();
		RgHead thd = new RgHead();
		headers = new RgHead[this.vecs];
		if (oldrg)
			{
			try {ofhd.read(dis); }
			catch(IOException ioe)
				{
				Errout("Could not read 12-byte RG file header from\n"
				+ name + " : " + ioe);
				return;
				}
			fhd.copyOldRGFileHead(ofhd);
			}
		else
			{
			try {fhd.read(dis); }
			catch(IOException ioe)
				{
				Errout("Could not read 16-byte RG file header from\n"
				+ name + " : " + ioe);
				return;
				}
			}
		if (fhd.isValid() != true)
			{
			Errout("File " + name + "\ndoes not appear to have an RG file header:\n"
			+ fhd);
			return;
			}
		if (fhd.ntrace < headers.length)
			{
			Errout("File " + name
			+ "\ndoes not declare enough traces in the RG file header;"
			+ headers.length + " needed:\n" + fhd);
			return;
			}
		if (fhd.nt != ne)
			{
			Errout("File " + name
			+ "\ndeclares a different number of samples per trace in the RG file header;"
			+ ne + " needed:\n" + fhd);
			return;
			}
		else if (fhd.ntrace > headers.length)
			{
			Noticeln("Warning: file " + name
			+ "\ndeclares more traces in the RG file header than the "
			+ headers.length + " now being read:\n" + fhd);
			}
		Noticeln("readRGFile: reading " + vecs + " traces of " + ne
			+ " samples each from RG file " + name + " ... ");
		for (j=0; j<vecs; j++)
			{
			if (oldrg)
				{
				try {othd.read(dis); }
				catch(IOException ioe)
					{
					Errout("Could not read (old-format) header from trace "
					+ j + " of RG file\n" + name);
					return;
					}
				}
			else
				{
				try {thd.read(dis); }
				catch(IOException ioe)
					{
					Errout("Could not read header from trace "
					+ j + " of RG file\n" + name);
					return;
					}
				}
			for (i=0; i<ne; i++)
				{
				try {vec[j*ne + i] = dis.readFloat(); }
				catch(IOException ioe)
					{
					Errout("Could not read "
					+ (SEGYFLOATBYTES*ne) + " bytes from trace "
					+ j + " of RG file\n" + name);
					return;
					}
				}
			if (oldrg)
				thd.copyOldRG(othd);
			headers[j] = new RgHead(thd);
			}
		setUnit0ofDim(0, fhd.starttime);
		if (!oldrg)
			{
			setDUnitofDim(0, fhd.dt);
			setUnitsofDim(0, "Time, sec");
			}
		setUnit0ofDim(1, 0);
		setUnitsofDim(1, "Trace Sequence");
		setDUnitofDim(1, 1);
		setUnit0ofDim(2, 0);
		setUnitsofDim(2, "Plane Index");
		setDUnitofDim(2, 1);

		try {fis.close(); }
		catch(IOException ioe)
			{
			Errout("Could not close RG file " + name + " : " + ioe.toString());
			return;
			}
		Noticeln("readRGFile done.");
		}
			
	public void viewinFrame
	(String title, boolean RowsDown, float VertExagg,
	RgRGB[] ColorTable, boolean PositiveOnly, float Clip)
		{
		Noticeln("viewinFrame: displaying " + this.vec.length
			+ "-element plane in new frame... ");
		Viewmat vm = new Viewmat(this, title, RowsDown, VertExagg,
			ColorTable, PositiveOnly, Clip);
		ViewmatFrame f = new ViewmatFrame(title, vm);
		FltPlane fp;
		if (RowsDown)
			fp = this.demult();
		else
			fp = this;
		int ipix[] = new int[fp.vecs*fp.ne];
		fp.makeIntImage(ipix, ColorTable, PositiveOnly, Clip);
		MemoryImageSource mis = 
			new MemoryImageSource(fp.ne, fp.vecs, ipix, 0, fp.ne);
		Image im = f.getToolkit().createImage(mis);
		vm.makeScale(f);
		f.props = new ViewmatProps(f, vm);
		f.picks = new ViewmatPicks(f, vm);
		f.geom = new ViewmatGeom(f, vm);
		if (RowsDown)
			fp = null;
		ipix = null;
		ScrollPane sp = new ScrollPane();
		FltPlaneCanvas fpc = new FltPlaneCanvas(vm, im);
		Color ltgray = new Color(220, 220, 220);
		fpc.setBackground(ltgray);
		sp.setSize(vm.fw, vm.fh);
		sp.add(fpc);
		sp.doLayout();
		f.setSize(vm.fw, vm.fh);
		f.add(sp);
		f.setBackground(ltgray);
		vm.f = f;
		vm.sp = sp;
		f.setNextLocation();
		f.show();
		this.f = f;
		Noticeln("viewinFrame done.");
		}
	public void viewinFrame
	(String dir, String title, boolean RowsDown, float VertExagg,
	RgRGB[] ColorTable, boolean PositiveOnly, float Clip)
		{
		viewinFrame(title, RowsDown, VertExagg, ColorTable, PositiveOnly, Clip);
		this.f.fd.setDirectory(dir);
		}
	public void replotinFrame(ViewmatFrame f)
		{
		Noticeln("replotinFrame: redisplaying " + this.vec.length
			+ "-element plane... ");
		FltPlane fp;
		if (f.vm.rowsdown)
			fp = this.demult();
		else
			fp = this;
		int ipix[] = new int[fp.vecs*fp.ne];
		fp.makeIntImage(ipix, f.vm.ctab, f.vm.positive, f.vm.clip);
		MemoryImageSource mis = 
			new MemoryImageSource(fp.ne, fp.vecs, ipix, 0, fp.ne);
		Image im = f.getToolkit().createImage(mis);
		mis = null;
		if (f.vm.cvs.img != null)
			f.vm.cvs.img = null;
		f.vm.cvs.img = im;
		f.vm.makeScale(f);
		if (f.vm.rowsdown)
			fp = null;
		ipix = null;
		this.f = f;
		Noticeln("replotinFrame done.");
		}

	public Canvas putinApplet
	(Applet panel, String title, boolean RowsDown, float VertExagg,
	RgRGB[] ColorTable, boolean PositiveOnly, float Clip)
		{
		Noticeln("putinApplet: displaying " + this.vec.length
			+ "-element plane in new frame... ");
		FltPlane fp;
		if (RowsDown)
			fp = this.demult();
		else
			fp = this;
		int ipix[] = new int[fp.vecs*fp.ne];
		fp.makeIntImage(ipix, ColorTable, PositiveOnly, Clip);
		MemoryImageSource mis = 
			new MemoryImageSource(fp.ne, fp.vecs, ipix, 0, fp.ne);
		Image im = panel.getToolkit().createImage(mis);
		mis = null;
		if (RowsDown)
			fp = null;
		ipix = null;
		Viewmat vm = new Viewmat(this, title, RowsDown, VertExagg,
			ColorTable, PositiveOnly, Clip, panel);
		FltPlaneCanvas fpc = new FltPlaneCanvas(vm, im);
		panel.add(fpc);
		this.f = null;
		Noticeln("putinApplet done.");
		return fpc;
		}
	
	public void readSEGYFile(String path, long addresses[], int samptype)
		{
		int i, t, bytes, ibuf;
		short sbuf, sabuf;
		byte buf[];
		RandomAccessFile raf;
		ByteArrayInputStream bais;
		DataInputStream dis;
		if (this.headers == null || this.headers.length < 1
			|| addresses == null || addresses.length < 1
			|| samptype < 0 || this.vec.length < 1
			|| addresses[0] < SEGYTraceHead.SEGY_HEAD_SIZE
			|| addresses.length != this.vecs)
			{
			Errout("Cannot read a SEG-Y file that does not scan consistently,\n"
				+ "yielding headers attached to the FltPlane or FltVol object.\n"
				+ "Likely cause is an incorrect tape header block and/or\n"
				+ "traces not sorted by FFID. Try opening a single FFID.\n");
			return;
			}
		Noticeln("readSEGYFile: reading " + addresses.length + " traces of "
			+ this.ne + " samples each from " + path);
		try
			{
			raf = new RandomAccessFile(path, "r");
			}
		catch(IOException ioe)
			{
			Errout("Cannot open file " + path
				+ "\nfor random read access: " + ioe);
			return;
			}
		catch(SecurityException se)
			{
			Errout("Read access to file " + path
				+ "\nnot permitted: " + se);
			return;
			}
		if (samptype == 3) /* 2-byte integer */
			bytes = 2*this.ne;
		else
			bytes = 4*this.ne;
		buf = new byte[bytes];
		bais = new ByteArrayInputStream(buf);
		dis = new DataInputStream(bais);
		for (i=0; i<addresses.length; i++)
			{
			try
				{
				raf.seek(addresses[i]);
				}
			catch(IOException ioe)
				{
				Errout("Cannot seek in file " + path
					+ "\nto trace at " + addresses[i]
					+ " bytes: " + ioe);
				return;
				}
			try
				{
				raf.readFully(buf);
				}
			catch(EOFException eofe)
				{
				Errout("Hit end of file " + path
					+ "\nwhile reading SEG-Y trace at " + addresses[i]
					+ " bytes, i=" + i + ": " + eofe);
				return;
				}
			catch(IOException ioe)
				{
				Errout("IO Exception reading file " + path
					+ "\nat " + addresses[i]
					+ " bytes for SEG-Y trace, i=" + i + ": " + ioe);
				return;
				}
			bais.reset();
			try
				{
				if (samptype == 2) /* 4-byte integer */
					{
					for (t=0; t<this.ne; t++)
						this.vec[i*this.ne + t] = (float)(dis.readInt());
					}
				else if (samptype == 3) /* 2-byte integer */
					{
					for (t=0; t<this.ne; t++)
						this.vec[i*this.ne + t] = (float)(dis.readShort());
					}
				else if (samptype == 4) /* 4-byte integer with gain code */
					{
					for (t=0; t<this.ne; t++)
						this.vec[i*this.ne + t]
							= (float)(dis.readShort() * dis.readShort());
					}
				else if (samptype == 0) /* 4-byte IEEE/Sun/Java Float */
					{
					for (t=0; t<this.ne; t++)
						this.vec[i*this.ne + t] = dis.readFloat();
					}
				else /* 4-byte IBM Float */
					{
					for (t=0; t<this.ne; t++)
						{
						ibuf = dis.readInt();
						this.vec[i*this.ne + t]
							= SEGYTraceHead.intBitsIBMToFloat(ibuf);
						/*
						//ibuf = (buf[4*t] << 24) | (buf[4*t+1] << 16)
						//	+ (buf[4*t+2] << 8) + buf[4*t+3];
						ibuf = (buf[4*t+1] << 24) | (buf[4*t] << 16)
							+ (buf[4*t+3] << 8) + buf[4*t+2];
						this.vec[i*this.ne + t]
							= SEGYTraceHead.intBitsIBMToFloat(ibuf);
						*/
						}
					}
				}
			catch(IOException ioe)
				{
				Errout("Internal Error: Could not read trace from memory buffer.");
				return;
				}

			if (i==0 || i==1 || i==9 || i==19 || (i+1)%100==0)
				Noticeln("trace " + (i+1) + " of "
				+ addresses.length + " read.");
			}
		try
			{
			raf.close();
			}
		catch(IOException ioe)
			{
			Errout("Could not close file " + path
				+ "\nafter random read access.");
			}
		Noticeln("readSEGYFile Done.");
		return;
		}

	public void createBinaryFile(int readtype, int samptype, boolean oldrg, String name)
		{
		int i, j, bytes, ibmbits;
		FileOutputStream fos = null;
		BufferedOutputStream bos = null;
		DataOutputStream dos = null;
		try {fos = new FileOutputStream(name); }
		catch(IOException ioe)
			{
			Errout("Can't create file " + name + ", data not saved:");
			Errout(ioe.toString());
			return;
			}
		RgHead thead[];
		RgFileHead fhd = null;
		OldRGTraceHead ohd = null;
		OldRGFileHead ofhd = null;
		SEGYTraceHead shd = null;
		SEGYFileHead sfhd = null;
		if (headers == null && (readtype == 1 || readtype == 2))
			{
			thead = new RgHead[this.vecs];
			for (i=0; i<this.vecs; i++)
				thead[i] = new RgHead(i, this);
			}
		else
			thead = headers;
		Notice("createBinaryFile: writing " + vecs + " vectors of " + ne
			+ " elements each to file " + name + "... ");
		bos = new BufferedOutputStream(fos);
		dos = new DataOutputStream(bos);
		if (readtype == 2)
			{
			/* RG */
			fhd = new RgFileHead(this);
			try
				{
				if (oldrg)
					{
					ofhd = new OldRGFileHead(fhd);
					ofhd.write(dos);
					ohd = new OldRGTraceHead();
					}
				else
					fhd.write(dos);
				for (j=0; j<this.vecs; j++)
					{
					if (oldrg)
						{
						ohd.copyRgHead(thead[j]);
						ohd.write(dos);
						}
					else
						thead[j].write(dos);
					for (i=0; i<this.ne; i++)
						dos.writeFloat(vec[j*ne + i]);
					}
				}
			catch(IOException ioe)
				{
				Errout("Could not write " + vec.length + " samples to Rg file "
					+ name + "\nData not saved.");
				return;
				}
			}
		else if (readtype == 1)
			{
			/* SEG-Y */
			fhd = new RgFileHead(this);
			sfhd = new SEGYFileHead();
			sfhd.copyRgFileHead(fhd);
			shd = new SEGYTraceHead();
			try
				{
				sfhd.write(dos);
				for (j=0; j<this.vecs; j++)
					{
					if (this.geogr)
						shd.copyRgHead(thead[j], fhd, j, 1, 1/3600, true);
					else
						shd.copyRgHead(thead[j], fhd, j, 1, 1, false);
					shd.write(dos);
					if (samptype == 2) /* 4-byte int */
						for (i=0; i<this.ne; i++)
							dos.writeInt((int)(vec[j*ne + i]));
					else if (samptype == 1) /* 4-byte IBM float */
						for (i=0; i<this.ne; i++)
							{
							ibmbits = shd.floatToIntBitsIBM(vec[j*ne + i]);
							dos.writeInt(ibmbits);
							}
					else /* 4-byte IEEE/Java float */
						for (i=0; i<this.ne; i++)
							dos.writeFloat(vec[j*ne + i]);
					}
				}
			catch(IOException ioe)
				{
				Errout("Could not write " + vec.length + " samples to SEG-Y file "
					+ name + "\nData not saved.");
				return;
				}
			}
		else
			{
			/* Raw Float */
			for (i=0; i<vec.length; i++)
				{
				try {dos.writeFloat(vec[i]); }
				catch(IOException ioe)
					{
					Errout("Could not write "
					+ (SEGYFLOATBYTES*vec.length) + " bytes to binary file "
					+ name);
					return;
					}
				}
			}
		try
			{
			dos.flush();
			bos.flush();
			fos.close();
			}
		catch(IOException ioe)
			{
			Errout(ioe.toString());
			return;
			}
		Noticeln("done.");
		}
	
	public void appendBinaryFile(int readtype, int samptype, boolean oldrg, String name)
		{
		int i, j, ibmbits, bytes;
		RandomAccessFile raf = null;
		Notice("appendBinaryFile: appending " + vecs + " vectors of "
			+ ne + " elements each to file " + name + "... ");
		try
			{
			raf = new RandomAccessFile(name, "rw");
			raf.seek(raf.length());
			}
		catch(Exception e)
			{
			Errout("Could not seek end of file " + name + ", data not saved.");
			Errout(e.toString());
			return;
			}
		RgHead thead[];
		RgFileHead fhd = null;
		OldRGTraceHead ohd = null;
		OldRGFileHead ofhd = null;
		SEGYTraceHead shd = null;
		SEGYFileHead sfhd = null;
		if (headers == null && (readtype == 1 || readtype == 2))
			{
			thead = new RgHead[this.vecs];
			for (i=0; i<this.vecs; i++)
				thead[i] = new RgHead(i, this);
			}
		else
			thead = headers;
		ByteArrayOutputStream baos = null;
		DataOutputStream dos = null;
		ByteArrayInputStream bais = null;
		DataInputStream dis = null;
		if (readtype == 2)
			{
			/* RG */
			if (oldrg)
				bytes = this.vecs *
				(OldRGTraceHead.OLDRGTRACEHEADBYTES + this.ne*SEGYFLOATBYTES);
			else
				bytes = this.vecs *
				(RgHead.RGHEADBYTES + this.ne*SEGYFLOATBYTES);
			baos = new ByteArrayOutputStream(bytes);
			dos = new DataOutputStream(baos);
			try
				{
				for (j=0; j<this.vecs; j++)
					{
					if (oldrg)
						{
						ohd.copyRgHead(thead[j]);
						ohd.write(dos);
						}
					else
						thead[j].write(dos);
					for (i=0; i<this.ne; i++)
						dos.writeFloat(vec[j*ne + i]);
					}
				dos.flush();
				}
			catch(IOException ioe)
				{
				Errout("Could not buffer "
				+ bytes + " bytes of RG traces prior to writing file " + name + ":\n"
				+ ioe.toString());
				return;
				}
			}
		else if (readtype == 1)
			{
			/* SEG-Y */
			fhd = new RgFileHead(this);
			shd = new SEGYTraceHead();
			bytes = this.vecs *
				(SEGYTraceHead.SEGY_HEAD_SIZE + this.ne*SEGYFLOATBYTES);
			baos = new ByteArrayOutputStream(bytes);
			dos = new DataOutputStream(baos);
			try
				{
				for (j=0; j<this.vecs; j++)
					{
					if (this.geogr)
						shd.copyRgHead(thead[j], fhd, j, 1, 1/3600, true);
					else
						shd.copyRgHead(thead[j], fhd, j, 1, 1, false);
					shd.write(dos);
					if (samptype == 2) /* 4-byte int */
						for (i=0; i<this.ne; i++)
							dos.writeInt((int)(vec[j*ne + i]));
					else if (samptype == 1) /* 4-byte IBM float */
						for (i=0; i<this.ne; i++)
							{
							ibmbits = shd.floatToIntBitsIBM(vec[j*ne + i]);
							dos.writeInt(ibmbits);
							}
					else /* 4-byte IEEE/Java float */
						for (i=0; i<this.ne; i++)
							dos.writeFloat(vec[j*ne + i]);
					}
				dos.flush();
				}
			catch(IOException ioe)
				{
				Errout("Could not buffer "
				+ bytes + " bytes of SEG-Y traces prior to writing file " + name + ":\n"
				+ ioe.toString());
				return;
				}
			}
		else
			{
			/* Raw Float */
			bytes = vec.length*SEGYFLOATBYTES;
			baos = new ByteArrayOutputStream(bytes);
			dos = new DataOutputStream(baos);
			try
				{
				for (i=0; i<vec.length; i++)
					dos.writeFloat(vec[i]);
				dos.flush();
				}
			catch(IOException ioe)
				{
				Errout("Could not buffer "
				+ bytes + " bytes of raw float prior to writing file " + name + ":\n"
				+ ioe.toString());
				return;
				}
			}
		/* Now append the buffered data to the file */
		try
			{
			raf.write(baos.toByteArray(), 0, bytes);
			raf.close();
			}
		catch(Exception e)
			{
			Errout("Could not append " + bytes + " bytes to file " + name + ":\n"
				+ e.toString());
			return;
			}
		/* Read and alter the file header if RG or SEG-Y format */
		byte hdbuf[];
		if (readtype == 2) /* RG */
			{
			if (oldrg)
				bytes = OldRGFileHead.OLDRGFILEHEADBYTES;
			else
				bytes = RgFileHead.RGFILEHEADBYTES;
			hdbuf = new byte[bytes];
			try
				{
				raf.seek(0);
				raf.read(hdbuf, 0, bytes);
				raf.close();
				}
			catch(Exception e)
				{
				Errout("Could not read " + bytes + " file header bytes from file "
				+ name + ":\n" + e.toString());
				return;
				}
			bais = new ByteArrayInputStream(hdbuf);
			dis = new DataInputStream(bais);
			baos = new ByteArrayOutputStream(bytes);
			dos = new DataOutputStream(baos);
			try
				{
				if (oldrg)
					{
					ofhd = new OldRGFileHead();
					ofhd.read(dis);
					ofhd.ntrace += this.vecs;
					ofhd.write(dos);
					}
				else
					{
					fhd = new RgFileHead();
					fhd.read(dis);
					fhd.ntrace += this.vecs;
					fhd.write(dos);
					}
				dos.flush();
				}
			catch(IOException ioe)
				{
				Errout("Could not buffer "
				+ bytes + " bytes of header prior to updating file " + name + ":\n"
				+ ioe.toString());
				return;
				}
			}
		else if (readtype == 1) /* SEG-Y */
			{
			sfhd = new SEGYFileHead();
			bytes = SEGYTraceHead.SEGY_THEAD_SIZE;
			hdbuf = new byte[bytes];
			try
				{
				raf.seek(0);
				raf.read(hdbuf, 0, bytes);
				raf.close();
				}
			catch(Exception e)
				{
				Errout("Could not read " + bytes + " file header bytes from file "
				+ name + ":\n" + e.toString());
				return;
				}
			bais = new ByteArrayInputStream(hdbuf);
			dis = new DataInputStream(bais);
			baos = new ByteArrayOutputStream(bytes);
			dos = new DataOutputStream(baos);
			try
				{
				sfhd.read(dis);
				/* SEG-Y file header does not specify number of traces
				   or records in file */
				sfhd.write(dos);
				dos.flush();
				}
			catch(IOException ioe)
				{
				Errout("Could not buffer "
				+ bytes + " bytes of header prior to updating file " + name + ":\n"
				+ ioe.toString());
				return;
				}
			}
		else /* Raw Float */
			bytes = 0;
		/* Write buffered file header */
		try
			{
			if (bytes > 0)
				{
				raf.seek(0);
				raf.write(baos.toByteArray(), 0, bytes);
				}
			raf.close();
			}
		catch(Exception e)
			{
			Errout("Could not write " + bytes + " file header bytes to file " + name + ":\n"
				+ e.toString());
			return;
			}
		Noticeln("done.");
		}
	
	public String getOffsets()
		{
		float min, max;
		if (headers == null)
			return "Vector0=" + Viewmat.getSignif("" + getUnit0ofDim(1))
			+ " " + getUnitsofDim(1) + " Vector" + (vecs-1) + "="
			+ Viewmat.getSignif("" + (getUnit0ofDim(1) + getDUnitofDim(1)*(vecs-1)))
			+ " " + getUnitsofDim(1);
		else
			{
			min = (float)(headers[0].off);
			max	= min;
			for (int i=1; i<headers.length; i++)
				{
				if ((float)(headers[i].off) > max)
					max = (float)(headers[i].off);
				if ((float)(headers[i].off) < min)
					min = (float)(headers[i].off);
				}
			return "Min. Offset=" + Viewmat.getSignif("" + min)
			+ " m, Max. Offset=" + Viewmat.getSignif("" + max) + " m";
			}
		}
	public void setElem(int Vec, int Elem, float val)
		{
		this.vec[Vec*this.ne + Elem] = val;
		}
	public float getElem(int Vec, int Elem)
		{
		return this.vec[Vec*this.ne + Elem];
		}
	public void windowof(FltPlane fp, int v0, int dv, int e0, int de)
		{
		int i, j;
		Notice("windowof: windowing " + this.ne
			+ " elements and " + this.vecs + " vectors from plane, with v0="
			+ v0 + " dv=" + dv + " e0=" + e0 + " de=" + de + "... ");
		for (j=0; j<this.vecs; j++)
			for (i=0; i<this.ne; i++)
				this.vec[j*this.ne+i] =
					fp.vec[(fp.ne*(v0+(j*dv))) + (e0+(i*de))];
		if (fp.headers != null)
			{
			this.headers = new RgHead[this.vecs];
			for (j=0; j<this.vecs; j++)
				this.headers[j] = new RgHead(
					fp.headers[v0+(j*dv)]);
			}
		this.AmpUnits = new String(fp.AmpUnits);
		this.Amp0 = fp.Amp0;
		this.AmpFac = fp.AmpFac;
		this.ElemUnits = new String(fp.ElemUnits);
		this.Elem0 = fp.Elem0 + fp.DElem*e0;
		this.DElem = fp.DElem*de;
		this.VecUnits = new String(fp.VecUnits);
		this.Vec0 = fp.Vec0 + fp.DVec*v0;
		this.DVec = fp.DVec*dv;
		this.f = fp.f;
		this.geogr = fp.geogr;
		Noticeln("done.");
		}
	static void windowPanel(ViewmatAction vad, ViewmatFrame f,
		boolean inplace, String label)
		{
		int temp, v0, nv, dv, e0, ne, de, tnv, tne;
		if (f.vm.fvol == null)
			{
			ne = f.vm.fp.ne;
			nv = f.vm.fp.vecs;
			}
		else
			{
			ne = f.vm.fvol.ne;
			nv = f.vm.fvol.vecs;
			}
		tnv = nv;
		tne = ne;
		v0 = 0;
		dv = 1;
		e0 = 0;
		de = 1;
		vad.expl = new TextArea(label + " of " + f.getTitle()
			+ (inplace ? " in-place\n" : " in new window\n")
			+ "The " + label + " method on class FltPlane data\n"
			+ "windows out and/or decimates vectors and elements.\n"
			+ "Parameters below:\n"
			+ "   v0=0		index of the first vector in each plane to be copied\n"
			+ "   nv=all	the number of vectors to be copied\n"
			+ "   dv=1		increment between input vectors\n"
			+ "   e0=0		index of the first element of each vector to be copied\n"
			+ "   ne=all	the number of elements from each vector to be copied\n"
			+ "   de=1		increment between input elements",
			5, 35);
		vad