关于JAVA指纹识别的源码！怎么会是这样的？

前些天在有一个在看J2ME程序开发的时候，无意中想到了手机指纹识别技术，于是就想有没有手机用Java可以实现的代码呢！在网上找了很长时间，看到了一写源码。贴出来大家共同讨论一下，这个是什么意思？

下面是其中的一个类

import java.applet.*;
import java.awt.*;
import java.awt.image.*;
import java.net.*;
import java.util.*;
import java.io.*;
import java.lang.Math;

/**
 * Open is an algorithm to open a binary image using a 3x3 kernel using
 * erosion followed by dilation.
 *
 * @author Simon Horne.
 */
public class Open extends Thread {

  /**
   * Default no-arg constructor.
   */
  public Open() {
  }

  /**
   * Method to open a binary image by eroding and then dilating the image
   * using the specified kernel.
   */
  public static BinaryFast open_image(BinaryFast b, int [] kernel,
          int iterations){
    int i=0;
      b = Erode.erode_image(b, kernel, iterations);
      b = Dilate.dilate_image(b, kernel, iterations);
    return b;
  }

}

第二个类：

import java.applet.*;
import java.awt.*;
import java.awt.image.*;
import java.net.*;
import java.util.*;
import java.io.*;

/**
 *ImageXor is an algorithm to apply logical XOR/XNOR between two images
 *@author:Judy Robertson, SELLIC OnLine
 *@author:Neil Brown, DAI
 *@author:Timothy Sharman
 *@see code.iface.imagexor
 */

public class ImageXor extends Thread{

  //the width of the input images in pixels
  private int i1_w;
  private int i2_w;

  //the width and height of the output image

  private int d_w;
  private int d_h;
  private int[] dest_1d;
  private boolean is_colored;
 

  /**
   *Constructs a new Image Xor
   *@param firstwidth The width of the iorst input image
   *@param secondwidth The width of the second input image
   */

  public ImageXor(int firstwidth, int secondwidth){
     i1_w = firstwidth;
     i2_w = secondwidth;
  }

  /**
   *Applies the image XOR operator on the specified image arrays, with the specified offset and scale value
   *@param src1_1d The first source image as a pixel array
   *@param src2_1d The second source image as a pixel array
   *@param XNOR Boolean to indicate wether we should XNOR rather than XOR
   *@param width width of the destination image in pixels
   *@param height height of the destination image in pixels
   *@param oset The offset value
   *@param scale The scale value
   *@return A pixel array containing the X(N)OR of the two input images
   */

  //Bob's image xor algorithm..
  /*a) assume the image is grey level (hence RR=GG=BB)
        b) use value &0x000000ff to get the BB value
        c) do this for both input images
        d) apply the operation (eg XOR)
        e) add oset and then scale
        f) clip to lie from 0 to 255. Call this value 0xCD
        g) create int value 0xffCDCDCD
 */

  public int [] doXor(int [] src1_1d, int [] src2_1d, boolean XNOR,
        int width, int height, float oset, float scale){
   
    int place1 = -1;
    int place2 = -1;
    int src1rgb = 0;
    int src2rgb = 0;
    int result = 0;
    //Get size of image and make 1d_arrays
    d_w = width;
    d_h = height;
   
    dest_1d = new int[d_w*d_h];
   
    boolean firstwider = false;
    boolean secondwider = false;
    int wrap;
   
    if (i1_w > d_w){
      wrap =   ((i1_w + 1) - d_w);
      firstwider = true;
    } else if (i2_w > d_w){
      wrap =    ((i2_w + 1) - d_w);
      secondwider = true;
     
    } else {
      wrap = 0;
    }
   
    //if you know there is no wrap around, you can save yourself some time
   
    if (wrap == 0) {
      for (int i=0; i< dest_1d. length ; i++){
 src2rgb = src2_1d[i] & 0x000000ff;
 src1rgb = src1_1d[i] & 0x000000ff;
 
 /* Due to Java not having unsigned ints, the ~ will always give a
    negative result. As we a dealing with only the bottom 8 bits of
    the int, I will just mask out the bottom bits. Neil.
    */
 if (XNOR) {
   result = (int) ((scale * (float)(~(src1rgb ^ src2rgb) & 0xff))+oset);
 } else {
   result = (int) ((scale * (float) ( src1rgb ^ src2rgb )) + oset);
 }
 //clip to 0 ... 256
 if (result < 0){
   result = 0;
 } else if  (result > 255){
   result = 255;
 }
 
 //create an int value for dest_1d
 dest_1d[i ] =  0xff000000 | (result + (result << 16) + (result << 8));
 
      }
     
      return dest_1d;
     
    }
    else {
     
      for (int i=0; i< dest_1d. length ; i++){
 
 //we might need to skip out some pixels which aren't in the overlap area
 
 if ((i %d_w  ) == 0 ) {
   if ( i == 0 ){
     place1 = 0;
     place2 = 0;
   } else if (secondwider) {
     place2 = place2 + wrap;
     place1 ++;
   } else {
     place1 = place1 + wrap;
     place2 ++;
   }
 } else{
   place2 ++;
   place1 ++;
 }
 
 src2rgb = src2_1d[place2] & 0x000000ff;
 src1rgb = src1_1d[place1] & 0x000000ff;
 
 /* Due to Java not having unsigned ints, the ~ will always give a
    negative result. As we a dealing with only the bottom 8 bits of
    the int, I will just mask out the bottom bits. Neil.
    */
 if (XNOR) {
   result = (int) ((scale * (float) (~(src1rgb ^ src2rgb) & 0xff))+ oset);
 } else {
   result = (int) ((scale * (float) ( src1rgb ^ src2rgb )) + oset);
 }
 
 //clip to 0 ... 256
 if (result < 0){
   result = 0;
 } else if  (result > 255){
   result = 255;
 }
 
 //create an int value for dest_1d
 dest_1d[i ] =  0xff000000 | (result + (result << 16) + (result << 8));
      }
      return dest_1d;
    }
  }
 
  /**
   *XORs the specified input image by the constant, also adds offset
   *
   *@param src1_1d The input pixel array
   *@param constant The constant value to AND every pixel in the input array by
   *@param XNOR Boolean to indicate wether we should XNOR rather than XOR
   *@param width width of the destination image in pixels
   *@param height height of the destination image in pixels
   *@param oset The offset value
   *@param scale The scale value
   *@return A pixel array with the constant value X(N)ORed with every pixel in the input array
   */

  public int [] doXor(int [] src1_1d, int constant, boolean XNOR,
        int width, int height, float oset, float scale ){
   
    //Get size of image and make 1d_arrays
    d_w = width;
    d_h = height;
   
    dest_1d = new int[d_w*d_h];
   
    int src1rgb;
    int result = 0;
   
    /* Due to Java not having unsigned ints, the ~ will always give a
       negative result. As we a dealing with only the bottom 8 bits of
       the int, I will just mask out the bottom bits. Neil.
       */
    //now do the XOR on the input image
   
    for (int i=0; i< src1_1d. length; i++){
      src1rgb = src1_1d[i] & 0x000000ff;
      if(XNOR) {
 result = (int) (( scale * ((float) (~(src1rgb ^ constant) &0xff))) + oset);
      } else {
 result = (int) (( scale * ((float) ( src1rgb ^ constant ))) + oset);
      }
      if (result > 255){
 result = 255;
      }
      if (result < 0){
 result = 0;
      }
      dest_1d[i] =  0xff000000 | (result + (result << 16) + (result << 8));
    }
    return dest_1d;
   
  }
 
 
}
从导入的包可以看出，没有什么特殊的类啊！上面是什么意思？有很多的关键词不理解也没有见到过！有明白这个是做什么的源码的不！提供大家讨论！