algorithmpf.java,v

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

head	1.4;
access;
symbols;
locks
	rirwin:1.4; strict;
comment	@# @;


1.4
date	2005.06.10.15.48.39;	author rirwin;	state Exp;
branches;
next	1.3;

1.3
date	2005.06.10.14.55.05;	author rirwin;	state Exp;
branches;
next	1.2;

1.2
date	2005.06.08.21.43.24;	author rirwin;	state Exp;
branches;
next	1.1;

1.1
date	2005.06.06.18.52.58;	author rirwin;	state Exp;
branches;
next	;


desc
@initial version of AlgorithmPF.java.
@


1.4
log
@Made scrollbar scroll down upon initializing.
@
text
@/**
 * AlgorithmPF.java v6.0 
 * Created by: Ryan Irwin 05/24/2005
 * 
 * Description: Particle Filtering
 *
 *
 *
 *
 *
 **************** UNDER CONSTRUCTION*****************
 *
 */


/****************************************************
	// first observation
	//
	initialObsn = 1200;
	estimateObsn = 0;
	
1	 newState = stateGain * currentState;

2	 varErrorNew = varErrorInitial * stateGain * stateGain + varStateNoise;
	 estimateObsn = measureGain * newState;

3	 kalmanGain = measureGain * varErrorNew ;
	 kalmanGain = kalmanGain / 
	          ( measureGain * measureGain * varErrorNew + varMeasureNoise);

4	 newerState =
	          newState + kalmanGain * (obsnSequence[index] - estimateObsn);

5	double a = 0;
  	 a = ( 1 - kalmanGain * measureGain) * ( 1 - kalmanGain * measureGain);

	varErrorNewer =
                   varErrorNew * a + varMeasureNoise * kalmanGain * kalmanGain;
	
	varErrorNewer = varErrorInitial;
	currentState = newerState; 

*******************************************************/




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

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

public class AlgorithmPF extends Algorithm
{

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

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

    //-----------------------------------------------------------------
    //
    // instance data members
    //
    //-----------------------------------------------------------------
    String algo_id = "AlgorithmPF"; 
    Vector<MyPoint> support_vectors_d;
    Vector<MyPoint> decision_regions_d;
  
    // for original data
    //
    Vector<MyPoint> set_1_d = new Vector<MyPoint>(40, 20);
    Vector<MyPoint> set_2_d = new Vector<MyPoint>(40, 20);
    Vector<MyPoint> set_3_d = new Vector<MyPoint>(40, 20);
    Vector<MyPoint> set_4_d = new Vector<MyPoint>(40, 20);

    // for interpolation function
    //
    Vector<MyPoint> iset_1_d = new Vector<MyPoint>(40, 20); 
    Vector<MyPoint> iset_2_d = new Vector<MyPoint>(40, 20); 
    Vector<MyPoint> iset_3_d = new Vector<MyPoint>(40, 20); 
    Vector<MyPoint> iset_4_d = new Vector<MyPoint>(40, 20); 

    // vector for mean-subtracted [zero-mean] data
    //
    Vector<MyPoint> mset_1_d = new Vector<MyPoint>(40, 20); 
    Vector<MyPoint> mset_2_d = new Vector<MyPoint>(40, 20); 
    Vector<MyPoint> mset_3_d = new Vector<MyPoint>(40, 20); 
    Vector<MyPoint> mset_4_d = new Vector<MyPoint>(40, 20); 

    // for display purpose
    //
    Vector<MyPoint> display_set_1_d = new Vector<MyPoint>(40, 20); 
    Vector<MyPoint> display_set_2_d = new Vector<MyPoint>(40, 20); 
    Vector<MyPoint> display_set_3_d = new Vector<MyPoint>(40, 20); 
    Vector<MyPoint> display_set_4_d = 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 PF coefficient
    //
    double final_pfc_1[]; 
    double final_pfc_2[];
    double final_pfc_3[];
    double final_pfc_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[];

    /*********************
    New for PF
    *********************/

    // estimate observation for each set
    //
    double est_obsn_1_d;
    double est_obsn_2_d;
    double est_obsn_3_d;
    double est_obsn_4_d;


    // current state for each set
    //
    double curr_state_1_d;
    double curr_state_2_d;
    double curr_state_3_d;
    double curr_state_4_d;


    // new state for each set
    //
    double new_state_1_d;
    double new_state_2_d;
    double new_state_3_d;
    double new_state_4_d;


    // newer state for each set
    //
    double newer_state_1_d;
    double newer_state_2_d;
    double newer_state_3_d;
    double newer_state_4_d;


    // kalman gain for each set
    //
    double kalman_gain_1_d;
    double kalman_gain_2_d;
    double kalman_gain_3_d;
    double kalman_gain_4_d;


    // current error for each set
    //
    double curr_error_1_d;
    double curr_error_2_d;
    double curr_error_3_d;
    double curr_error_4_d;


    // new error for each set
    //
    double new_error_1_d;
    double new_error_2_d;
    double new_error_3_d;
    double new_error_4_d;


    // newer error for each set
    //
    double newer_error_1_d;
    double newer_error_2_d;
    double newer_error_3_d;
    double newer_error_4_d;


    double meas_gain;
    double state_gain;
    double var_meas_noise;
    double var_state_noise;

    // to store the final results NOT NEW
    //
    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 = 6;
	pforder    = Classify.main_menu_d.pforder;
	iporder    = Classify.main_menu_d.iporder;
	meas_gain  = Classify.main_menu_d.meas_gain;
	state_gain = Classify.main_menu_d.state_gain;
	var_meas_noise  = Classify.main_menu_d.var_meas_noise;
	var_state_noise = Classify.main_menu_d.var_state_noise;


	scale      = pforder * iporder;

	curr_state_1_d = 0; 
	curr_state_2_d = 0;
	curr_state_3_d = 0;
	curr_state_4_d = 0;
   
	curr_error_1_d = 0;
	curr_error_2_d = 0;
	curr_error_3_d = 0;
	curr_error_4_d = 0;


	// Add the process description for the PF algorithm
	//
	if (description_d.size() == 0)
	{

	    /***************
            UNDER CONSTRUCTION
	    *****************/

	   //String str = new String("   0.  Checking for the Data Validity.");

	    String str = new String("\n**** Under Construction **** \n" +
				    "\nKalman Filter implementation \n" +
				    "\nInitial Settings:" +
				    "\nMeasurement Gain: " + meas_gain +
				    "\nState Gain:       " + state_gain +
				    "\nVariance of Measurement Noise" +
				         var_meas_noise +
				    "\nVariance of State Noise" +
				         var_state_noise + "\n" +
				    "\n0.  Checking for the Data Validity\n");
	    description_d.addElement(str);
	    
	    str = new String("   1.  Displaying the Input Data Points");
	    description_d.addElement(str);
	    
	    str = new String("   2.  State estimate extrapolation");
	    description_d.addElement(str);
	    
	    str = new String("   3.  Error covariance extrapolation");
	    description_d.addElement(str);
 
	    str = new String("   4.  Innovation process \n Kalman Gain computation");
	    description_d.addElement(str);

	    str = new String("   5.  State estimate observational update");
	    description_d.addElement(str);

	    str = new String("   6.  Error covariance update \n Displaying 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();
	//
	set_1_d = data_points_d.dset1;
	set_2_d = data_points_d.dset2;
	set_3_d = data_points_d.dset3;
	set_4_d = data_points_d.dset4;

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

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

	if (max2 > max1)
	    max1 = max2;

	if (max1 > scale)
	    scale = max1;

	step_index_d = 0;

	if((checkdata_PF(set_1_d) == true) && (checkdata_PF(set_2_d) == true) 
	   && (checkdata_PF(set_3_d) == true) && (checkdata_PF(set_4_d) == true))
	{
	    pro_box_d.appendMessage((String)description_d.get(step_index_d));
	    pro_box_d.appendMessage("         Data points valid");

	    pro_box_d.scrollPane.getVerticalScrollBar().setValue(1000000);

	    return true;	
	}
	else
        {
	    pro_box_d.appendMessage("\n" + "Invalid data");
	    pro_box_d.appendMessage("Clear and enter valid data" + "\n");

	    pro_box_d.scrollPane.getVerticalScrollBar().setValue(1000000);

	    return false;
	}
    }

    /**
    * 
    * Validates the class entered by user for Partical Filtering  
    *
    * @@param    pf
    * @@return   true if data is Vector pf is valid. It is invalid
    *           if the size of pf is 1 or any element is larger than the
    *           the previous element
    * 
    */
    public boolean checkdata_PF(Vector<MyPoint> pf)
    {
	if ( pf.size() == 1) {

	    return false;
	}
	else {

	    for(int i = 0; i <= pf.size() - 1 ; i++ ) {

		for(int j = i + 1; j <= pf.size() - 1 ; j++ ) {

		   // amplitudes should be in time progression
		   //
		   if ( (((MyPoint)pf.elementAt(i)).x == 
			 ((MyPoint)pf.elementAt(j)).x) || 
			(((MyPoint)pf.elementAt(i)).x > 
			 ((MyPoint)pf.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(); 
	}
	if (step_index_d == 4)
	{
	    disableControl();
	    step4(); 
	    enableControl(); 
	}
	if (step_index_d == 5)
	{
	    disableControl();
	    step5(); 
	    enableControl(); 
	}
	if (step_index_d == 6)
	{
	    disableControl();
	    step6(); 
	    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(set_1_d.size() > 0 )
       {
	   display_set_1_d.removeAllElements();
	   iset_1_d.removeAllElements();
	   mset_1_d.removeAllElements();

	   interpol(set_1_d, display_set_1_d);
	   average1 = mean(display_set_1_d, mset_1_d);
	   interpol(mset_1_d, iset_1_d);

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

       if(set_2_d.size() > 0 )
       {
	   display_set_2_d.removeAllElements();
	   iset_2_d.removeAllElements();  
	   mset_2_d.removeAllElements();

	   interpol(set_2_d, display_set_2_d);
	   average2 = mean(display_set_2_d, mset_2_d);
	   interpol(mset_2_d, iset_2_d);   
	  
	   output_panel_d.addOutput(set_2_d, (Classify.PTYPE_INPUT * 4), 
				    data_points_d.color_dset2);
       }
       
       if(set_3_d.size() > 0 )
       {
	   display_set_3_d.removeAllElements();
	   iset_3_d.removeAllElements();
	   mset_3_d.removeAllElements();

	   interpol(set_3_d, display_set_3_d);
	   average3 = mean(display_set_3_d, mset_3_d);
	   interpol(mset_3_d, iset_3_d);

	   output_panel_d.addOutput(set_3_d, (Classify.PTYPE_INPUT * 4), 
				    data_points_d.color_dset3);
       }
       
       if(set_4_d.size() > 0 )
       {	
	   display_set_4_d.removeAllElements();
	   iset_4_d.removeAllElements();
	   mset_4_d.removeAllElements();

	   interpol(set_4_d, display_set_4_d);
	   average4 = mean(display_set_4_d, mset_4_d);
	   interpol(mset_4_d, iset_4_d);
   
	   output_panel_d.addOutput(set_4_d, (Classify.PTYPE_INPUT * 4), 
				    data_points_d.color_dset4);
       }

	pro_box_d.setProgressCurr(1);
	output_panel_d.repaint();
	return true;
    }

   /**
    *
    *
    * @@return    true
    *
    */
    boolean step2()
    {
	


	return true;
    }   
 
   /**
    *
    *
    * @@return    true
    *
    */
    boolean step3()
    {



	return true;
    }    

   /**
    *
    *