//******************************************************************************
// StringArt.java:	Applet
//
//******************************************************************************
import java.applet.*;
import java.awt.*;

//==============================================================================
// Main Class for applet StringArt
//
//	The String art applet demonstrates the incremental sinusoidal 
//	calculation given by linear prediction theory. Apparently
//	sinusoids are very predictable, requiring the calculation of
//	only two points using the Math.cos() routine.
//
//
//	Consider the sinusoid
//
//		x  = A cos [ p - n w ]
//		 n 
//
//	where
//	
//		A = amplitude
//		p = initial phase
//		w = frequency
//		n = integer from 0 to N-1
//
//  Starting with the two points:
//
//		x  = A cos [ p - w ]
//		 0
//
//		x  = A cos [ p - 2w ]
//		 1
//
//
// The remaining points can be calculated with
//
//		x  = 2*cos[ w ] ( x    - x    )
//		 n				   n-1	  n-2
//
// Note that 2*cos[ w ] may be calculated beforehand.
//
//==============================================================================
public class StringArt extends Applet implements Runnable
{
	// THREAD SUPPORT:
	//		m_StringArt	is the Thread object for the applet
	//--------------------------------------------------------------------------
	Thread	 m_StringArt = null;


	// StringArt Class Constructor
	//--------------------------------------------------------------------------
	public StringArt()
	{
	}

	// APPLET INFO SUPPORT:
	//		The getAppletInfo() method returns a string describing the applet's
	// author, copyright date, or miscellaneous information.
    //--------------------------------------------------------------------------
	public String getAppletInfo()
	{
		return "Name: StringArt\r\n" +
		       "Author: Michael Svihura\r\n" +
		       "Created with Microsoft Visual J++ Version 1.0";
	}


	// The init() method is called by the AWT when an applet is first loaded or
	// reloaded.
    //--------------------------------------------------------------------------
	public void init()
	{
		Dimension dim = size();
		nWidth  = dim.width;
		nHeight = dim.height;

		int i;
		lineEndPointParams = new CurveParameter[4];
		for ( i=0;i<4;i++ ) lineEndPointParams[i] = new CurveParameter();
		lineEndPointValues = new CurveValue[4];
		for ( i=0;i<4;i++ ) lineEndPointValues[i] = new CurveValue();
		l1x = new double[ 2*nLines ];
		l1y = new double[ 2*nLines ];
		l2x = new double[ 2*nLines ];
		l2y = new double[ 2*nLines ];
		SetRainbowScale();
	}

	// destroy() is called when when you applet is terminating 
	// and being unloaded.
	//-------------------------------------------------------------------------
	public void destroy()
	{
		
	}

	// Compute a rainbow-like colormap
	//--------------------------------------------------------------------------
	private void SetRainbowScale()
	{
		int		    i;
		double	    x;

		for ( i = 0; i < nLines*2; i++ ) 
		{
			x = (double)( i ) /
				(double)( nLines*2 ) * 2.0 * Math.PI;
			R[i] = (int)((Math.cos(x + 0.0) + 1.0) * 127.0);
			G[i] = (int)((Math.cos(x + 2.094395) + 1.0) * 127.0);
			B[i] = (int)((Math.cos(x - 2.094395) + 1.0) * 127.0);
		}

	}

	// Helper routine to convert a line point into an integer value.
	// For speed, this is implemented as a final static method.
	//--------------------------------------------------------------------------
	private final static int ToPoint( double x, int iRes )
	{
		return (int)(( x + 1.0 ) / 2.0 * (double)(iRes - iRes/10) + iRes/20 );
	}

	// StringArt Paint Handler
	//--------------------------------------------------------------------------
	public void paint(Graphics g)
	{
		Dimension dim = size();
		g.setColor( new Color( 0, 0, 0 ) );
		g.fillRect( 0, 0, nWidth, nHeight );

		int i;
		for ( i = 0; i<nCalcLines; i++ )
		{
			g.setColor( new Color( R[i], G[i], B[i] ) );
			g.drawLine( ToPoint( l1x[i], nWidth ), ToPoint( l1y[i], nHeight ),
						ToPoint( l2x[i], nWidth ), ToPoint( l2y[i], nHeight ) );
		}

		bRepaintAll = false;
	}

	// Override the update method to avoid painful screen flicker.
	//--------------------------------------------------------------------------
	public void update( Graphics g )
	{
		if ( bRepaintAll )
		{
			paint( g );
		}
		else
		{
			// Just draw the last point.
			g.setColor( new Color( R[nCalcLines-1], G[nCalcLines-1], B[nCalcLines-1] ) );
			g.drawLine( ToPoint( l1x[nCalcLines-1], nWidth ), ToPoint( l1y[nCalcLines-1], nHeight ),
						ToPoint( l2x[nCalcLines-1], nWidth ), ToPoint( l2y[nCalcLines-1], nHeight ) );
		}
	}

	//		The start() method is called when the page containing the applet
	// first appears on the screen. 
	//--------------------------------------------------------------------------
	public void start()
	{
		if (m_StringArt == null)
		{
			m_StringArt = new Thread(this);
			m_StringArt.start();
		}
	}
	
	//		The stop() method is called when the page containing the applet is
	// no longer on the screen. 
	//--------------------------------------------------------------------------
	public void stop()
	{
		if (m_StringArt != null)
		{
			m_StringArt.stop();
			m_StringArt = null;
		}
	}

	private void InitParam( CurveParameter param, int x )
	{
		param.Randomize();
		x = 5;
	}

	// THREAD SUPPORT
	//		The run() method is called when the applet's thread is started. 
	//--------------------------------------------------------------------------
	public void run()
	{
		while (true)
		{
			int i;
			// initialize the curves
			for ( i = 0; i<4; i++ )
			{
				//lineEndPointParams[i].Randomize();
				InitParam( lineEndPointParams[i], i );
				lineEndPointParams[i].ToValue( lineEndPointValues[i], nLines );
				lineEndPointValues[i].Init();
			}
			nCalcLines = 0;

			try
			{
				// Compute all the lines, but leave a little delay
				// between the drawing of each line.
				for ( nCalcLines = 0; nCalcLines < 2*nLines; nCalcLines++ )
				{
					if ( nCalcLines == 0 ) bRepaintAll = true;
					else bRepaintAll = false;
					l1x[nCalcLines] = lineEndPointValues[0].ComputeValue();
					l1y[nCalcLines] = lineEndPointValues[1].ComputeValue();
					l2x[nCalcLines] = lineEndPointValues[2].ComputeValue();
					l2y[nCalcLines] = lineEndPointValues[3].ComputeValue();
					repaint();
					Thread.sleep(10);
				}

				// Done drawing the lines, so let's snooze for 
				// a little while
				Thread.sleep(3000);
			}
			catch (InterruptedException e)
			{
				stop();
			}

		}
	}

	CurveParameter[]	lineEndPointParams;
	CurveValue[]		lineEndPointValues;

	double[]	l1x;
	double[]	l1y;
	double[]	l2x;
	double[]	l2y;

	static final int	nLines = 250;

	int[] R = new int[ 2 * nLines ];
	int[] G = new int[ 2 * nLines ];
	int[] B = new int[ 2 * nLines ];

	private int			nCalcLines;
	private boolean		bRepaintAll = true;


	int nWidth	= 320;
	int	nHeight = 240;
}

//==============================================================================
//
// Class to store the current curve values. The x,y values for the endpoints
// of the line are stored in instances of this class.
//
//==============================================================================
class CurveValue
{
	public double	ampl;	// Current amplitude
	public double	omega;	// Current frequency
	public double	phi;	// Current phase
	public double	cos_omega2;	// 2 * cos( omega );

	public double	x1;		// Previous curve values.
	public double	x2;

	final void Init()
	{
		cos_omega2 = 2.0 * Math.cos( omega );
		x1 = ampl * Math.cos( phi - omega );
		x2 = ampl * Math.cos( phi - ( 2.0 * omega ) );
	}

	final double ComputeValue()
	{
		double value;

		value = cos_omega2 * x1 - x2;
		x2 = x1;
		x1 = value;
		return value;
	}
}

//==============================================================================
//
// Class to store the curve parameters. There is a parameter for the (x,y)
// coordinate for the endpoints of the line (i.e. 4 parameters ).
//
//==============================================================================
class CurveParameter
{
	public double ampl;		// Amplitude of the curve
	public double omega;	// Frequency of the curve
	public double phase;	// Phase of the curve.

	// Convert the initial curve parameter into an initial curve
	// value.
	final void ToValue( CurveValue cv, int iLines )
	{
		cv.ampl  = ampl;
		cv.omega = 4.0 * Math.PI * omega / (double)iLines;
		cv.phi   = phase * Math.PI / 180.0;
	}

	// Store the choices for the random parameters for the curves.
	static final double random_ampl[] = { 1.0, 1.0, 1.0, 1.0, 1.0 };
	static final double random_omega[] = 
			{ -2.00, -1.75, -1.50, -1.25,
			  -1.00, -0.75, -0.50, -0.25,
			   0.25,  0.50,  0.75,  1.00,
			   1.25,  1.50,  1.75,  2.00, 2.00 };
	static final double random_phase[] = 
			{ 0.0, 45.0, 90.0, 135.0, 180.0, 180.0 };

	final void Randomize()
	{
		ampl  = random_ampl[ (int)(Math.random()*random_ampl.length) ];
		omega = random_omega[ (int)(Math.random()*random_omega.length) ];
		phase = random_phase[ (int)(Math.random()*random_phase.length) ];
	}
}