algorithmed.java,v

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

1.9
log
@Javadoc comments are up to standard.
@
text
@d37 1
a37 1
    Vector support_vectors_d;
d42 1
a42 1
    Vector decision_regions_d;
d58 4
a61 4
	decision_regions_d = new Vector();
	point_means_d = new Vector();
	support_vectors_d = new Vector();
	description_d = new Vector();
d87 9
a95 4
	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();
d101 1
a101 1
	// append message to process box
d104 1
@


1.8
log
@*** empty log message ***
@
text
@d4 2
a5 1
//                          Last Edited :  Sanjay Patil
d24 3
d29 3
d33 4
d38 4
d49 1
a49 1
     * @@return  boolean
d108 1
a108 1
     * @@return  boolean
d147 1
a147 1
     * @@return  boolean
d180 1
a180 1
     * @@return  boolean
@


1.7
log
@*** empty log message ***
@
text
@d2 3
a4 2
// AlgorithmED.java V6.0 03/15/2005
// Created Phil Trasatti, Edited Daniel May. Last Edited Sanjay Patil
@


1.6
log
@few more finer changes to the comments to comply with the Java Documentation
style. Further more, all the changes are consistent with the previous file.
@
text
@d18 1
a18 2
 * Inherits base class Algorithm. class implements the euclidean distance
 * algorithm.
@


1.5
log
@rectified a spelling mistake for ompute as Compute.
@
text
@d1 9
a9 10
/**
* AlgorithmED.java V6.0 03/15/2005
*
* Author: Phil Trasatti, last edited : Daniel May Created: 7/15/03
*
* Class: AlgorithmED
* 
* Description: Euclidean Distance algoritm.  Inherits base class Algorithm
* Determines the line of discrimination between data sets.
*/
d17 4
a20 1

a22 13

    //-----------------------------------------------------------------
    //
    // static data members
    //
    //-----------------------------------------------------------------

    //-----------------------------------------------------------------
    //
    // primitive data members
    //
    //-----------------------------------------------------------------

a24 6
    //-----------------------------------------------------------------
    //
    // instance data members
    //
    //-----------------------------------------------------------------
        
d28 1
a28 3
	  
     // class methods

a29 1
     *
a34 1
     *
d87 1
a87 2
	return true;
	
a90 1
     *
a93 1
     *
a128 1
     *
a132 1
     * 
d151 2
a152 1
	output_panel_d.addOutput(support_vectors_d, Classify.PTYPE_INPUT, Color.black);
a162 1
     *
a165 1
     * 
a193 1
    *
a195 1
    *
a229 1
    *
a230 1
    *
d337 2
a338 1
		    dist = MathUtil.distance(pixel.x, pixel.y, point.x, point.y);
d374 1
a374 3
     *
     * Computes and displays the classification errors for each set   
     *
d378 1
a378 1
	//Debug
d413 13
a425 14
	    {
		
		MyPoint point = (MyPoint)set1_d.elementAt(i);
		samples1++;
		if ((point.x > scale.xmin && point.x < scale.xmax)
		    && (point.y > scale.ymin && point.y < scale.ymax))
		    {
			if (output_canvas_d[(int)((point.x - scale.xmin) / 
                            incrementX)][(int)((point.y - scale.ymin) / 
                            incrementY)] != 0)
			    {
				incorrect1++;
			    }
		    }
d427 1
d430 1
a430 1
	    {
d432 17
a448 17
		error = ((double)incorrect1 / (double)samples1) * 100.0;
		
		text =
		    new String(
			       "       Results for class 0:\n"
			       + "          Total number of samples: "
			       + samples1
			       + "\n"
			       + "          Misclassified samples: "
			       + incorrect1
			       + "\n"
			       + "          Classification error: "
			       + MathUtil.setDecimal(error, 2)
			       + "%");
		
		pro_box_d.appendMessage(text);
	    }
d453 13
a465 14
	    {
		
		MyPoint point = (MyPoint)set2_d.elementAt(i);
		samples2++;
		if ((point.x > scale.xmin && point.x < scale.xmax)
		    && (point.y > scale.ymin && point.y < scale.ymax))
		    {
			if (output_canvas_d[(int)((point.x - scale.xmin) / 
                            incrementX)][(int)((point.y - scale.ymin) / 
                            incrementY)] != 1)
			    {
				incorrect2++;
			    }
		    }
d467 1
d470 19
a488 19
	    {
		
		error = ((double)incorrect2 / (double)samples2) * 100.0;
		
		text =
		    new String(
			       "       Results for class 1:\n"
			       + "          Total number of samples: "
			       + samples2
			       + "\n"
			       + "          Misclassified samples: "
			       + incorrect2
			       + "\n"
			       + "          Classification error: "
			       + MathUtil.setDecimal(error, 2)
			       + "%");
		
		pro_box_d.appendMessage(text);
	    }
d493 13
a505 14
	    {
		
		MyPoint point = (MyPoint)set3_d.elementAt(i);
		samples3++;
		if ((point.x > scale.xmin && point.x < scale.xmax)
		    && (point.y > scale.ymin && point.y < scale.ymax))
		    {
			if (output_canvas_d[(int)((point.x - scale.xmin) / 
                            incrementX)][(int)((point.y - scale.ymin) / 
                            incrementY)] != 2)
			    {
				incorrect3++;
			    }
		    }
d507 1
d510 19
a528 19
	    {
		
		error = ((double)incorrect3 / (double)samples3) * 100.0;
		
		text =
		    new String(
			       "       Results for class 2:\n"
			       + "          Total number of samples: "
			       + samples3
			       + "\n"
			       + "          Misclassified samples: "
			       + incorrect3
			       + "\n"
			       + "          Classification error: "
			       + MathUtil.setDecimal(error, 2)
			       + "%");
		
		pro_box_d.appendMessage(text);
	    }
d533 13
a545 14
	    {
		
		MyPoint point = (MyPoint)set4_d.elementAt(i);
		samples4++;
		if ((point.x > scale.xmin && point.x < scale.xmax)
		    && (point.y > scale.ymin && point.y < scale.ymax))
		    {
			if (output_canvas_d[(int)((point.x - scale.xmin) / 
                            incrementX)][(int)((point.y - scale.ymin) / 
                            incrementY)] != 3)
			    {
				incorrect4++;
			    }
		    }
d547 1
d550 19
a568 19
	    {
		
		error = ((double)incorrect4 / (double)samples4) * 100.0;
		
		text =
		    new String(
			       "       Results for class 3:\n"
			       + "          Total number of samples: "
			       + samples4
			       + "\n"
			       + "          Misclassified samples: "
			       + incorrect4
			       + "\n"
			       + "          Classification error: "
			       + MathUtil.setDecimal(error, 2)
			       + "%");
		
		pro_box_d.appendMessage(text);
	    }
@


1.4
log
@Thinks this will be the final version for Java Documentation.
For the parameters passed and returned are none, that line is omitted.
@
text
@d405 1
a405 1
     * omputes and displays the classification errors for each set   
@


1.3
log
@changed comments as per Java Documentation.
Refer http://java.sun.com/j2se/javadoc/writingdoccomments/index.html
@
text
@d2 1
a2 1
* AlgorithmED.java
d4 1
a4 5
* Created: 7/15/03
*
* Author: Phil Trasatti
* 
* Last Edited by: Daniel May
d46 7
a52 1
    /**
d54 1
a54 1
     * class methods
a56 12

    /** 
    * method: initialize
    *
    * @@param   none
    * @@return  boolean
    *
    * description:  
    * overrides the initialize() method in the base class.  initializes
    * member data and prepares for execution of first step.  this method
    * "resets" the algorithm.
    */
d60 2
a61 1
	//System.out.println(algo_id + ": initialize()");
d71 1
d88 1
d92 1
d99 1
d103 1
d107 1
d113 6
a118 9
    * method: step1
    *
    * @@param   none
    * @@return  boolean
    *
    * description:  
    * displays data sets from input box in output box.
    * 
    */
d122 2
a123 1
	//System.out.println(algo_id + " : step1()");
d126 1
d134 1
d145 1
d153 7
a159 10
    * method: step2
    *
    * @@param   none
    * @@return  boolean
    *
    * description:  
    * computes the means of each data set and displays the means graphically
    * and numerically
    * 
    */
d163 2
a164 1
	//System.out.println(algo_id + " : step2()");
d167 1
d169 1
d171 1
a171 1
	//----
d176 1
a176 1
	//----
d188 6
a193 9
    * method: step3
    *
    * @@param   none
    * @@return  boolean
    *
    * description:   
    * Computes the Decision Regions and the associated errors. 
    * 
    */    
d197 2
a198 1
	//System.out.println(algo_id + " : step3()");
d201 1
a201 1
	//----
d209 3
a211 2
	//----
	output_panel_d.addOutput( decision_regions_d, Classify.PTYPE_INPUT, new Color(255, 200, 0));
d216 1
a216 1
	
a220 1
    * method: run
d222 2
a223 2
    * @@param   none
    * @@return  none
a224 3
    * description: 
    * implementation of the run function from the Runnable interface.
    * determines what the current step is and calls the appropriate method.
d229 2
a230 1
	//System.out.println(algo_id + " : run()");
a258 4
    * method: computeDecisionRegions
    *
    * @@param   none
    * @@return  none
d260 1
a260 2
    * description:
    * computes the line of discrimination    
d266 3
a268 1
	//System.out.println(algo_id +": computeDecisionRegions()");
d270 1
a270 1

d275 1
d301 1
a301 1

a339 1
				
a346 1
				
a353 1
				
d393 2
a394 1
		    if (associated != output_canvas_d[i][j - 1] || associated != output_canvas_d[i - 1][j])
d404 4
a407 9
    * method: computeErrors
    *
    * @@param   none
    * @@return  none
    *
    * description:
    * computes and displays the classification errors for each set   
    *
    */   
d411 2
a412 1
	//System.out.println(algo_id +": computeErrors()");
d430 2
a431 1
	DisplayScale scale = output_panel_d.disp_area_d.getDisplayScale();	
d433 1
d437 1
a437 1
	double incrementY = (scale.ymax-scale.ymin)/outputHeight;
d439 1
a439 1
	double incrementX = (scale.xmax-scale.xmin)/outputWidth;
d452 3
a454 1
			if (output_canvas_d[(int)((point.x-scale.xmin)/incrementX)][(int)((point.y-scale.ymin)/incrementY)] != 0)
d492 3
a494 1
			if (output_canvas_d[(int)((point.x-scale.xmin)/incrementX)][(int)((point.y-scale.ymin)/incrementY)] != 1)
d532 3
a534 1
			if (output_canvas_d[(int)((point.x-scale.xmin)/incrementX)][(int)((point.y-scale.ymin)/incrementY)] != 2)
d572 3
a574 1
			if (output_canvas_d[(int)((point.x-scale.xmin)/incrementX)][(int)((point.y-scale.ymin)/incrementY)] != 3)
d604 1
a604 1
	samples = samples1 + samples2 + samples3 + samples4;
d606 1
a606 1
	error = ((double)incorrect / (double)samples) * 100.0;
d622 1
a622 4
	
    }    
    
    
@


1.2
log
@All the debug statements commented out.
End of the sequence will be now "Algorithm Complete"
@
text
@d1 14
a14 14
//----------------------------------------------------------------------
// AlgorithmED.java
//
// Created: 7/15/03
//
// Author: Phil Trasatti
// 
// Last Edited by: Daniel May
//
// Class: AlgorithmED
// 
// Description: Euclidean Distance algoritm.  Inherits base class Algorithm
// Determines the line of discrimination between data sets.
//---------------------------------------------------------------------
d50 17
a66 18
    //---------------------------------------------------------------
    //
    // class methods
    //
    //---------------------------------------------------------------


    //---------------------------------------------------------------
    // method: initialize
    //
    // arguments: none
    // return   : boolean
    //
    // description:  
    // overrides the initialize() method in the base class.  initializes
    // member data and prepares for execution of first step.  this method
    // "resets" the algorithm.
    //---------------------------------------------------------------
d115 10
a124 10
    //---------------------------------------------------------------
    // method: step1
    //
    // arguments: none
    // return   : boolean
    //
    // description:  
    // displays data sets from input box in output box.
    // 
    //---------------------------------------------------------------
d154 11
a164 11
    //---------------------------------------------------------------
    // method: step2
    //
    // arguments: none
    // return   : boolean
    //
    // description:  
    // computes the means of each data set and displays the means graphically
    // and numerically
    // 
    //---------------------------------------------------------------
d189 10
a198 10
    //---------------------------------------------------------------
    // method: step3
    //
    // arguments: none
    // return   : boolean
    //
    // description:   
    // Computes the Decision Regions and the associated errors. 
    // 
    //---------------------------------------------------------------    
d223 10
a232 10
    //---------------------------------------------------------------
    // method: run
    //
    // arguments: none
    // return   : none
    //
    // description: 
    // implementation of the run function from the Runnable interface.
    // determines what the current step is and calls the appropriate method.
    //--------------------------------------------------------------- 
d264 10
a273 10
    // --------------------------------------------------------------
    // method: computeDecisionRegions
    //
    // arguments: none
    // return   : none
    //
    // description:
    // computes the line of discrimination    
    //
    //--------------------------------------------------------------
d412 11
a422 10
    //--------------------------------------------------------------
    // method: computeErrors
    //
    // arguments: none
    // return   : none
    //
    // description:
    // computes and displays the classification errors for each set   
    //
    //--------------------------------------------------------------   
@


1.1
log
@Initial revision
@
text
@d71 1
a71 1
	System.out.println(algo_id + ": initialize()");
d129 1
a129 1
	System.out.println(algo_id + " : step1()");
d169 1
a169 1
	System.out.println(algo_id + " : step2()");
d203 1
a203 1
	System.out.println(algo_id + " : step3()");
d237 1
a237 1
	System.out.println(algo_id + " : run()");
d257 1
a257 1
		pro_box_d.appendMessage("   Step Sequence Complete");
d278 1
a278 1
	System.out.println(algo_id +": computeDecisionRegions()");
d426 1
a426 1
	System.out.println(algo_id +": computeErrors()");
@