algorithmlp.java,v

包含了模式识别中常用的一些分类器设计算法

head	1.15;
access;
symbols;
locks; strict;
comment	@# @;


1.15
date	2005.06.10.18.20.43;	author rirwin;	state Exp;
branches;
next	1.14;

1.14
date	2005.05.23.19.14.44;	author rirwin;	state Exp;
branches;
next	1.13;

1.13
date	2005.03.16.23.10.03;	author patil;	state Exp;
branches;
next	1.12;

1.12
date	2005.01.19.21.24.28;	author patil;	state Exp;
branches;
next	1.11;

1.11
date	2005.01.06.22.39.22;	author patil;	state Exp;
branches;
next	1.10;

1.10
date	2005.01.06.21.41.22;	author patil;	state Exp;
branches;
next	1.9;

1.9
date	2005.01.05.19.14.31;	author patil;	state Exp;
branches;
next	1.8;

1.8
date	2004.12.31.23.51.52;	author patil;	state Exp;
branches;
next	1.7;

1.7
date	2004.12.31.17.21.52;	author patil;	state Exp;
branches;
next	1.6;

1.6
date	2004.12.30.16.37.56;	author patil;	state Exp;
branches;
next	1.5;

1.5
date	2004.12.28.23.14.54;	author patil;	state Exp;
branches;
next	1.4;

1.4
date	2004.12.28.22.48.50;	author patil;	state Exp;
branches;
next	1.3;

1.3
date	2004.12.28.01.16.56;	author patil;	state Exp;
branches;
next	1.2;

1.2
date	2004.12.28.01.07.10;	author patil;	state Exp;
branches;
next	1.1;

1.1
date	2004.12.28.00.04.32;	author patil;	state Exp;
branches;
next	;


desc
@This is the file, i am working on.
@


1.15
log
@Establishing RCS version.
@
text
@/**
 * AlgorithmLP.java v6.0 Last Edited by: Ryan Irwin 05/23/2005
 * Nishant Aggarwal, Jun-Won Suh Created: 12/15/04
 *
 * Description: Linear Prediction algorithm. Determines the estimate of 
 * the data points based on the points given by the user. 
 * The appraoch is data interpolation [ based on cubic interpolation ],
 * Autocorrelation coefficients and Linear Predictor Coefficients [based
 * on Levinson Durbin Algorithm]
 */


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

 
import java.awt.Graphics;
import javax.swing.JApplet; // import class Algorithm

public class AlgorithmLP extends Algorithm
{

    //-----------------------------------------------------------------
    //
    // static data members
    //
    //-----------------------------------------------------------------
    int lporder;
    int iporder;
    int scale;

    //-----------------------------------------------------------------
    //
    // primitive data members
    //
    //-----------------------------------------------------------------
    int output_canvas_d[][];   

    //-----------------------------------------------------------------
    //
    // instance data members
    //
    //-----------------------------------------------------------------
    String algo_id = "AlgorithmLP"; 
    Vector<MyPoint> support_vectors_d;
    Vector<MyPoint> decision_regions_d;

    // for original data
    //
    Vector<MyPoint> set1_d = new Vector<MyPoint>(40, 20);
    Vector<MyPoint> set2_d = new Vector<MyPoint>(40, 20);
    Vector<MyPoint> set3_d = new Vector<MyPoint>(40, 20);
    Vector<MyPoint> set4_d = new Vector<MyPoint>(40, 20);

    // for interpolation function
    //
    Vector<MyPoint> iset1 = new Vector<MyPoint>(40, 20); 
    Vector<MyPoint> iset2 = new Vector<MyPoint>(40, 20); 
    Vector<MyPoint> iset3 = new Vector<MyPoint>(40, 20); 
    Vector<MyPoint> iset4 = new Vector<MyPoint>(40, 20); 

    // vector for mean-subtracted [zero-mean] data
    //
    Vector<MyPoint> mset1 = new Vector<MyPoint>(40, 20); 
    Vector<MyPoint> mset2 = new Vector<MyPoint>(40, 20); 
    Vector<MyPoint> mset3 = new Vector<MyPoint>(40, 20); 
    Vector<MyPoint> mset4 = new Vector<MyPoint>(40, 20); 

    // for display purpose
    //
    Vector<MyPoint> display_set1 = new Vector<MyPoint>(40, 20); 
    Vector<MyPoint> display_set2 = new Vector<MyPoint>(40, 20); 
    Vector<MyPoint> display_set3 = new Vector<MyPoint>(40, 20); 
    Vector<MyPoint> display_set4 = new Vector<MyPoint>(40, 20); 

    // to store autoCorrelation coefficient
   //
    double auto_co_1[];
    double auto_co_2[];
    double auto_co_3[];
    double auto_co_4[];

    // to store the average values for each class
    //
    double average1;
    double average2;
    double average3;
    double average4;

    // to store LP coefficient
    //
    double final_lpc_1[]; 
    double final_lpc_2[];
    double final_lpc_3[];
    double final_lpc_4[];

    // to store residual energy 
    //
    double estimate_err_1 = 0;	
    double estimate_err_2 = 0;	
    double estimate_err_3 = 0;
    double estimate_err_4 = 0; 

    // to store actual error energy
    //
    double actual_err_1 = 0;
    double actual_err_2 = 0;
    double actual_err_3 = 0;
    double actual_err_4 = 0;


    // to store the reflection coefficients
    //
    double ref_coeff_1[];
    double ref_coeff_2[];
    double ref_coeff_3[]; 
    double ref_coeff_4[];

    // to store the final results
    //
    Vector<MyPoint> y_estimate1 = new Vector<MyPoint>(40, 20); 
    Vector<MyPoint> y_estimate2 = new Vector<MyPoint>(40, 20); 
    Vector<MyPoint> y_estimate3 = new Vector<MyPoint>(40, 20); 
    Vector<MyPoint> y_estimate4 = new Vector<MyPoint>(40, 20); 

    //---------------------------------------------------------------
    //
    // class methods
    //
    //---------------------------------------------------------------


    /**
     * 
     * Implements 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 if sets of data are valid
     *
     */
    public boolean initialize()
    {
	DisplayArea disp_area_d = new DisplayArea();
	point_means_d           = new Vector<MyPoint>();
	decision_regions_d      = new Vector<MyPoint>();
	support_vectors_d       = new Vector<MyPoint>();
	description_d           = new Vector<String>();

	step_count  = 3;
	lporder    = Classify.main_menu_d.lporder;
	iporder    = Classify.main_menu_d.iporder;
	scale      = lporder * iporder;

	// Add the process description for the LP algorithm
	//
	if (description_d.size() == 0)
	{
	    String str = new String("   0.  Checking for the Data Validity.");
	    description_d.addElement(str);
	    
	    str = new String("   1.  Displaying the Input Data Points.");
	    description_d.addElement(str);
	    
	    str = new String("   2.  Computing LP Parameters.");
	    description_d.addElement(str);
	    
	    str = new String("   3.  Displaying the Linear Predicted Signal");
	    description_d.addElement(str);

	}

	// 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;	

	int max1 = set2_d.size();
	if (set1_d.size() > set2_d.size())
	    max1 = set1_d.size();

	int max2 = set4_d.size();
	if (set3_d.size() > set4_d.size())
	    max2 = set3_d.size();
	else
	    max2 = set4_d.size();

	if (max2 > max1)
	    max1 = max2;

	if (max1 > scale)
	    scale = max1;

	step_index_d = 0;

	if((checkdata_LP(set1_d) == true) && (checkdata_LP(set2_d) == true) 
	   && (checkdata_LP(set3_d) == true) && (checkdata_LP(set4_d) == true))
	{
	    pro_box_d.appendMessage((String)description_d.get(step_index_d));
	    pro_box_d.appendMessage("         Data points valid");
	    return true;	
	}
	else
        {
	    pro_box_d.appendMessage("\n" + "Invalid data");
	    pro_box_d.appendMessage("Clear and enter valid data" + "\n");
	    return false;
	}
    }

    /**
    * 
    * Validates the class entered by user for Linear Prediction  
    *
    * @@param    lp
    * @@return   true if data is Vector lp is valid. It is invalid
    *           if the size of lp is 1 or any element is larger than the
    *           the previous element
    * 
    */
    public boolean checkdata_LP(Vector lp)
    {
	if ( lp.size() == 1) 
	    return false;
	else
	   for(int i = 0; i <= lp.size() - 1 ; i++ )
	       for(int j = i + 1; j <= lp.size() - 1 ; j++ )
		   // amplitudes should be in time progression
		   //
		   if ( (((MyPoint)lp.elementAt(i)).x == 
			 ((MyPoint)lp.elementAt(j)).x) || 
			(((MyPoint)lp.elementAt(i)).x > 
			 ((MyPoint)lp.elementAt(j)).x) )
		       return false;

	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()
    {
	if (step_index_d == 1)
	{
	    disableControl();
	    step1();
	    enableControl();
	}
	if (step_index_d == 2)
	{
	    disableControl();
	    step2();
	    enableControl(); 
	}
	if (step_index_d == 3)
	{
	    disableControl();
	    step3(); 
	    enableControl(); 
       }
	
	// exit gracefully
	//
	return;
    }
    
    /**
     *
     * Displays data sets from input box in output box, clears the data
     * points from the Vector fro input data, zero-mean data,
     * does interpolation, and then finds mean of the interpolated data
     * interpolates the zero-mean data, displays the result
     *
     * @@return   True
     *
     */
    boolean step1()
    {
	// set up progress bar
	//
	pro_box_d.setProgressMin(0);
	pro_box_d.setProgressMax(1);
	pro_box_d.setProgressCurr(0);

	output_panel_d.disp_area_d.output_points_d.removeAllElements();
	output_panel_d.disp_area_d.type_d.removeAllElements();
	output_panel_d.disp_area_d.color_d.removeAllElements();
	
      	// Display original data
	// size of the point made four times bigger
	// 
       if(set1_d.size() > 0 )
       {
	   display_set1.removeAllElements();
	   iset1.removeAllElements();
	   mset1.removeAllElements();

	   interpol(set1_d, display_set1);
	   average1 = mean(display_set1, mset1);
	   interpol(mset1, iset1);

	   output_panel_d.addOutput(set1_d, (Classify.PTYPE_INPUT * 4), 
				    data_points_d.color_dset1);
       }

       if(set2_d.size() > 0 )
       {
	   display_set2.removeAllElements();
	   iset2.removeAllElements();  
	   mset2.removeAllElements();

	   interpol(set2_d, display_set2);
	   average2 = mean(display_set2, mset2);
	   interpol(mset2, iset2);   
	  
	   output_panel_d.addOutput(set2_d, (Classify.PTYPE_INPUT * 4), 
				    data_points_d.color_dset2);
       }
       
       if(set3_d.size() > 0 )
       {
	   display_set3.removeAllElements();
	   iset3.removeAllElements();
	   mset3.removeAllElements();

	   interpol(set3_d, display_set3);
	   average3 = mean(display_set3, mset3);
	   interpol(mset3, iset3);

	   output_panel_d.addOutput(set3_d, (Classify.PTYPE_INPUT * 4),