//--------------------------------------------------------------------------
// AlgorithmLBG.java 6.0 03/15/2005
// Created       : Phil Trasatti     Edited : Daniel May
//                                   Edited : Sanjay Patil
//                              Last Edited : Ryan Irwin
//
// Description   : Describes the LDAPCA algorithm
// Remarks       : Code unchanged since created. Created 07/15/2003
//--------------------------------------------------------------------------


//----------------------
// import java packages
//----------------------
import java.util.*;
import java.awt.*;

/**
 * Implements the combined LDA and PCA algorithm. The LDA is implemented
 * first and then PCA is implemented.
 */
public class AlgorithmLDAPCA extends Algorithm
{
    // Public Data Members
    //
    Vector<MyPoint> decision_regions_d;
    Vector<MyPoint> support_vectors_d;
    int output_canvas_d[][];
    
    // declare local Matrix objects
    // covariance matrix for CLDA
    Matrix W;
    Matrix LDA;
    Matrix CLDA; 
    Matrix B;
    Matrix S;
    Matrix invW;
    
    // for PCA declare
    //
    Matrix trans_matrix_d = new Matrix();
    Matrix cov_matrix_d = new Matrix();
    
    // declare LDA Class objects
    //  AlgorithmLDA ldaobject = new AlgorithmLDA();
    
    /**
     * Overrides the initialize() method in the base class. Initializes
     * member data and prepares for execution of first step. This method
     * "resets" the algorithm.
     *
     * @return   Returns true
     */
    public boolean initialize()
    {
	algo_id = "AlgorithmLDAPCA";
	    
 	// Debug
	// System.out.println(algo_id + " initialize()");
	
	step_count = 4;
	point_means_d = new Vector<MyPoint>();
	decision_regions_d = new Vector<MyPoint>();
	support_vectors_d = new Vector<MyPoint>();
	description_d = new Vector<String>();

	// for PCA 
	//
	trans_matrix_d = new Matrix();
	cov_matrix_d = new Matrix();
   
	// Initialize local Matrix objects
	//
	W = new Matrix();
	LDA = new Matrix();
	CLDA = new Matrix();
	B = new Matrix();
	S = new Matrix();
	invW = new Matrix();

	// Initialize LDA class object
	// ldaobject = new Algorithm();
	    
	// Add the process description for the LDA algorithm
	//
	if (description_d.size() == 0)
 	{
	    String str = new String("   0. Initialize the original data.");
	    description_d.addElement(str);
		
	    str = new String("   1. Displaying the original data.");
	    description_d.addElement(str);
		
	    str = new String("   2. Computing the means and covariance for LDA.");
	    description_d.addElement(str);
		
	    str = new String("   3. Computing the means and covaricance for PCA followed by LDA algorithm.");
	    description_d.addElement(str);

	    str = new String("   4. Computing the decision regions based on the LDA followed by PCA class independent principal component analysis algorithm.");
	    description_d.addElement(str);
	}

	// append message to process box
	//
	pro_box_d.appendMessage("Class Independent LDA Analysis:" + "\n");
	    
	// set the data points for this algorithm
	//
	//	set1_d = (Vector)data_points_d.dset1.clone();
	//	set2_d = (Vector)data_points_d.dset2.clone();
	//	set3_d = (Vector)data_points_d.dset3.clone();
	//	set4_d = (Vector)data_points_d.dset4.clone();
	//
	set1_d = data_points_d.dset1;
	set2_d = data_points_d.dset2;
	set3_d = data_points_d.dset3;
	set4_d = data_points_d.dset4;
   
	// set the step index
	//
	step_index_d = 0;
    
	// append message to process box
	//
	pro_box_d.appendMessage((String)description_d.get(step_index_d));
	    
	// exit initialize
	//
	return true;
    }

    /**
    * Implementation of the run function from the Runnable interface.
    * Determines what the current step is and calls the appropriate method.
    */    
    public void run()
    {
	// Debug
	//
	// System.out.println(algo_id + " run()");
	
	if (step_index_d == 1)
        {
	    disableControl();
	    step1();
	    enableControl();
	}
	
	else if (step_index_d == 2)
	{
	    disableControl();
	    step2(); 
	    enableControl();
	}
	
	else if (step_index_d == 3)
	{
	    disableControl();
	    step3();
	    enableControl(); 
	}
	
	else if (step_index_d == 4)
	{
	    disableControl();
	    step4();
	    pro_box_d.appendMessage("   Algorithm Complete");
	    enableControl(); 
	}
	return;
    }
    
    /**
    * Displays data sets from input box in output box.
    *
    * @return Returns true
    */
    boolean step1()
    {
	// Debug
	//
	// System.out.println(algo_id + " step1()");
	
	pro_box_d.setProgressMin(0);
	pro_box_d.setProgressMax(20);
	pro_box_d.setProgressCurr(0);
	
	// append message to process box
	//
	output_panel_d.addOutput(set1_d, Classify.PTYPE_INPUT, 
				 data_points_d.color_dset1);
	output_panel_d.addOutput(set2_d, Classify.PTYPE_INPUT,
				 data_points_d.color_dset2);
	output_panel_d.addOutput(set3_d, Classify.PTYPE_INPUT,
				 data_points_d.color_dset3);
	output_panel_d.addOutput(set4_d, Classify.PTYPE_INPUT, 
				 data_points_d.color_dset4);
	
	// step 1 completed
	//
	pro_box_d.setProgressCurr(20);
	output_panel_d.repaint();
	
	return true;
    }

    /**
     * Calculates the within class and between class scatter matrix,
     * transforms the data sets ans displays the mean graphically
     * and numerically
     *
     * @return Returns true
     */
    boolean step2()
    {
	// Debug
	//
	// System.out.println(algo_id + " step2()");
	
	pro_box_d.setProgressMin(0);
	pro_box_d.setProgressMax(20);
	pro_box_d.setProgressCurr(0);
	
	computeMeans();
	
	// determine the within class scatter matrix
	//
	withinClass(W);
	
	// determine the between class scatter matrix
	//
	betweenClass(B);
	
	// determine the ratio of the between class scatter matrix
	// to the within class scatter matrix
	//
	W.invertMatrix(invW);
	invW.multMatrix(B, S);
	
	// transform the samples from all data sets
	//
	transformLDA(data_points_d, S);
	
	displayMatrices();
	
	// display means
	//
	output_panel_d.addOutput(point_means_d, Classify.PTYPE_OUTPUT_LARGE, 
				 Color.black);
	    
	// display support vectors
	//
	output_panel_d.addOutput(support_vectors_d, Classify.PTYPE_INPUT, 
				 Color.black );
	
	// display support vectors
	//
	pro_box_d.setProgressCurr(20);
	output_panel_d.repaint();
	
	return true;
    }

    /**
     * Transforms the data set using PCA and computes mean on the transformed
     * data. Displays the transformed Matrices.
     *
     * @return Returns true
     */
    boolean step3()
    {
	// Debug
	//
	// System.out.println(algo_id + ": step3()");
	
	    
	pro_box_d.setProgressMin(0);
	pro_box_d.setProgressMax(20);
	pro_box_d.setProgressCurr(0);
	    
	// append message to process box
	//
	transformPCA();
	printMatrices();
	computeMeans();
	    
	// display means
	//
	output_panel_d.addOutput(point_means_d, 
				 Classify.PTYPE_OUTPUT_LARGE, Color.black);
	    
	// display support vectors
	//
	output_panel_d.addOutput(support_vectors_d, 
				 Classify.PTYPE_INPUT, Color.cyan);
	    
	// display support vectors
	//
	pro_box_d.setProgressCurr(20);
	output_panel_d.repaint();
	    
	// exit gracefully
	//
	return true;
    }

    /**
     * Computes the decision regions and totals the data points in error,
     * as well displays the decision region
     *
     * @return Returns true
     */
     boolean step4()
    {
	// Debug
	//
	// System.out.println(algo_id + ": step4()");
	    
	pro_box_d.setProgressMin(0);
	pro_box_d.setProgressMax(20);
	pro_box_d.setProgressCurr(0);
	    
	// compute the decision regisions
	//
	computeDecisionRegions();
	    
	// compute errors
	//
	computeErrors();
	    
	// display support vectors
	//
	output_panel_d.addOutput(decision_regions_d, 
				 Classify.PTYPE_INPUT, new Color(255, 200, 0));
	    
	output_panel_d.repaint();
	    
	// exit gracefully
	//
	return true;
    }
    
    /**
     * Determines the within class scatter matrix
     *
     * @param   M Matrix for within class scatter matrix
     * @see     Matrix
     */
   public void withinClass(Matrix M)
    {

	// declare local variables
	//
	int size = 0;
	double x[] = null;
	double y[] = null;
	    
	DisplayScale scale = output_panel_d.disp_area_d.getDisplayScale();

	// declare the covariance object
	//
	Covariance cov = new Covariance();
	    
	// declare local matrices
	//
	Matrix M1 = new Matrix();
	Matrix M2 = new Matrix();
	Matrix M3 = new Matrix();
	Matrix M4 = new Matrix();
	    
	// compute the propabilities of each data set
	//
	double maxsamples = set1_d.size() + set2_d.size() 
	                  + set3_d.size() + set4_d.size();
	    
	double p1 = set1_d.size() / maxsamples;
	double p2 = set2_d.size() / maxsamples;
	double p3 = set3_d.size() / maxsamples;
	double p4 = set4_d.size() / maxsamples;
	    
	// get the first data set size
	//
	size = set1_d.size();
	    
	    // initialize arrays to store the samples
	    //
	x = new double[size];
	y = new double[size];
	    
	    // set up the initial random vectors i.e., the vectors of
	    // X and Y coordinate points form the display
	    //
	for (int i = 0; i < size; i++)
	{
	    MyPoint p = (MyPoint)set1_d.elementAt(i);
	    x[i] = p.x;
	    y[i] = p.y;
	}
	
	// compute the covariance matrix of the first data set
	//
	M1.row = M1.col = 2;
	M1.Elem = new double[2][2];
	M1.resetMatrix();
	
	if (size > 0)
	{
	    M1.Elem = cov.computeCovariance(x, y);
	}
	
	// get the second data set size
	//
	size = set2_d.size();
	
	// initialize arrays to store the samples
	//
	x = new double[size];
	y = new double[size];
	
	// set up the initial random vectors i.e., the vectors of
	// X and Y coordinate points form the display
	//
	for (int i = 0; i < size; i++)
	{
	    MyPoint p = (MyPoint)set2_d.elementAt(i);
	    x[i] = p.x;
	    y[i] = p.y;
	}
	
	// compute the covariance matrix of the second data set
	//
	M2.row = M2.col = 2;
	M2.Elem = new double[2][2];
	M2.resetMatrix();
	
	if (size > 0)
	{
	    M2.Elem = cov.computeCovariance(x, y);
	}
	
	// get the third data set size
	//
	size = set3_d.size();
	
	// initialize arrays to store the samples
	//
	x = new double[size];
	y = new double[size];
	
	// set up the initial random vectors i.e., the vectors of
	// X and Y coordinate points form the display
	//
	for (int i = 0; i < size; i++)
	{
	    MyPoint p = (MyPoint)set3_d.elementAt(i);
	    x[i] = p.x;
	    y[i] = p.y;
	}
	
	// compute the covariance matrix of the third data set
	//
	M3.row = M3.col = 2;
	M3.Elem = new double[2][2];
	M3.resetMatrix();
	    
	if (size > 0)
	{
	    M3.Elem = cov.computeCovariance(x, y);
	}
	    
	// get the fourth data set size
	//
	size = set4_d.size();
	    
	// initialize arrays to store the samples
	//
	x = new double[size];
	y = new double[size];
	    
	// set up the initial random vectors i.e., the vectors of
	// X and Y coordinate points form the display
	//
	for (int i = 0; i < size; i++)
	{
	    MyPoint p = (MyPoint)set4_d.elementAt(i);
	    x[i] = p.x;
	    y[i] = p.y;
	}
	    
	// compute the covariance matrix of the fourth data set
	//
	M4.row = M4.col = 2;
	M4.Elem = new double[2][2];
	M4.resetMatrix();
	    
	if (size > 0)
        {
	    M4.Elem = cov.computeCovariance(x, y);
	}
	    
	// compute the within class scatter matrix
	//
	M.row = M.col = 2;
	M.Elem = new double[2][2];
	M.resetMatrix();
	M.addMatrix(M1);
	M.addMatrix(M2);
	M.addMatrix(M3);
	M.addMatrix(M4);
	CLDA = M;
    }
    
    /**    
     * Determines the between class scatter matrix for
     * the class independent linear discrimination algorithm
     *
     * @param   M Matrix for storing between class scatter matrix
     * @see     Matrix
     */
    public void betweenClass(Matrix M)
    {
	
	// declare local variables
	//
	int capacity = 0;
	int size = 0;
	
	double xmean = 0.0;
	double ymean = 0.0;
	
	double xmean1 = 0.0;
	double ymean1 = 0.0;
	double xmean2 = 0.0;
	double ymean2 = 0.0;
	double xmean3 = 0.0;
	double ymean3 = 0.0;
	double xmean4 = 0.0;
	double ymean4 = 0.0;
	
	// declare local matrices
	//
	Matrix M1 = new Matrix();
	Matrix T1 = new Matrix();
	Matrix M2 = new Matrix();
	Matrix T2 = new Matrix();
	Matrix M3 = new Matrix();
	Matrix T3 = new Matrix();
	Matrix M4 = new Matrix();
	Matrix T4 = new Matrix();
	
	// declare the covariance object
	//
	Covariance cov = new Covariance();
		
	// declare the initial random variables
	//
	double transpose[][] = new double[2][1];
	double mean[][] = new double[1][2];
	
	// compute the propabilities of each data set
	//
	double maxsamples = set1_d.size() + set2_d.size()