snp.java

SNP算法: 基于背景缩减和阴影检测的统计方法,适用于室内检测.

package bin;

import java.lang.Math;

import java.io.File;
import java.io.FileOutputStream;

import java.awt.image.*;
import java.awt.Image;
import java.awt.image.BufferedImage;
import java.awt.Rectangle;

import com.sun.image.codec.jpeg.JPEGCodec;                  
import com.sun.image.codec.jpeg.JPEGImageEncoder;

/******************************************************************************
 *SNP(基于统计的背景消除算法):	该算法的主要功能是对室内环境条件下的人的阴影检*																		  	
 *测和背景消除,实现将运动前景,运动对象阴影,静态背景三者的分离. 				  * 	
 *版本号:1.0																  *	
 *作者:happyjay(段俊杰)													      *	
 *程序接口:a.保存图像接口;b.分布曲线接口;c.二值图(原图)接口;d.去阴影接口;e.图 *
 *像膨胀接口																  *
 *本程序主接口为SNPProcess(),主要用来进行SNP算法处理         		          *	
 ******************************************************************************/
public class SNP
{
	/*输入学习图片数*/
	static int sampleImageNum = 0;

	/*是否保存图像*/
	boolean saved = false;
	
	/*是否需要画出分布图*/
	boolean paintpic = false;
	
	/*是否需要二值显示*/
	boolean binaryvalue = false;
	
	/*是否需要去阴影*/
	boolean subshadow = false;
	
	/*是否需要膨胀处理*/
	boolean wantpengzhang = false;
	
	/*计算每帧光线强度总和*/
	boolean totalalpha = false;
	
	/*计算Y分量*/
	boolean gety = false;
	
	/*是否使用滑杆*/
	boolean useslider = false;
	
	/*阈值设置*/
	float slidervalue = 3.0f;
	float slidervalue2 = -3.0f;
	
	/*输入图象宽度,高度,面积域 */
    int w=0;			
	int h=0;			
	int w_h=0;	
	
	/*输入源图象*/
	Image src = null;
	
	/*抓取图像参数*/
	PixelGrabber grabber = null;
	ColorModel model = null;
	
	/*存取图像象素数组*/
	int pixels[];
	
	boolean boolpixel[];
		
	/*r,g,b值存放数组，存放图象RGB值*/
	float r[];
    float g[];
    float b[];
    
    /*为求Y分量，将RGB存储在同一个数组*/
    int []rgb;
    	    
    /*r,g,b期望值存放数组*/
    float ur[];							
    float ug[];							
    float ub[];	
    
    /*各帧r,g,b方差值存放数组*/	
    float sr[];							
    float sg[];							
    float sb[];
    
    /*二值化数组,用于二值化处理*/
    boolean binary[];
    boolean binarytemp[];
    
    /*亮度失真*/
    float ma[];
    
    /*象素点亮度偏移量数组α[]*/				
    float α[];							
    
    /*规格化亮度偏移量和色度偏移量存放数组*/						
    float α_[];
    
    /*暂存数组(提高计算效率)*/
    float A[];
    float B[];
    float C[];
    float D[];
    
    /*各个象素点的期望值的方差和*/
    float tempr[];
    float tempg[];
    float tempb[];
    
    /*光线强度总和*/
    float tempalpha;
    
	/*存储上次光线强度和*/
	float lastalpha;
	
	/*当前帧与上一帧的光线强度差异*/
	float deltaalpha;
	
    /*各个象素点的亮度失真和色度失真的方差和*/
    float tempx[];
    float tempy[];	
    
    /*α和cd的最大最小值*/
    float max_α_;																	
    float min_α_;								
    
    /*α和CD的分布曲线数组*/								
	int a_map[];							
		
	/*坐标系中原点值(即纵坐标最大值时横坐标的值)*/
	float Max_map;
	int originX;
	
	/*最大最小规格化值出现的点的位置*/
	int max_location = 0;
	int min_location = 0;
	

   /****************************************************/
   /*设置检测区域*/
   public void setDetectArea(Rectangle rec)
   {
   		int startX = (int)rec.getX();
   		int startY = (int)rec.getY();
   		int endX = startX + (int)rec.getWidth();
   		int endY = startY + (int)rec.getHeight();
   		
   		if(startX < 0) startX = 0;
   		if(startY < 0) startY = 0;
   		if(endX > w) endX = w;
   		if(endY > h) endY = h;
   		
   		for(int y = startY; y < endY; y++)
   			for(int x = startX; x < endX; x++)
   			{
   				boolpixel[y * w + x] = true;
   			}
   }
   
   /*默认区域*/
   public void setDefaultArea()
   {
   		for(int y = 0; y < h; y++)
   			for(int x = 0; x < w; x++)
   			{
   				boolpixel[y * w + x] = true;
   			}
   }
   /*设置阈值*/
   public void setSlidervalue(float slidervalue)
   {
   		this.slidervalue = slidervalue;
   }
   
   /*获取阈值*/
   public float getSlidervalue()
   {
   		return this.slidervalue;
   }
   
    /*设置阴影阈值*/
   public void setSlidervalue2(float slidervalue2)
   {
   		this.slidervalue2 = slidervalue2;
   }
   
   /*获取阴影阈值*/
   public float getSlidervalue2()
   {
   		return this.slidervalue2;
   }
   
   /*设置是否要计算totalalpha的值*/
    public void setTotalalpha(boolean totalalpha)
    {
    	this.totalalpha = totalalpha;
    }
    
    /*得到当前输出的值*/
    public float getTempalpha()
    {
    	return this.tempalpha;
    }
    
   /*设置是否需要二值输出,默认为原图输出*/
    public void setBinaryvalue(boolean binaryvalue)
    {
    	this.binaryvalue = binaryvalue;
    }
    
    /*得到当前输出的状态*/
    public boolean getBinaryvalue()
    {
    	return this.binaryvalue;
    }
    
    /*设置是否需要膨胀处理*/
    public void setPengzhang(boolean wantpengzhang)
    {
    	this.wantpengzhang = wantpengzhang;
    }
    
    /*获得膨胀状态*/
    public boolean getPengzhang()
    {
    	return this.wantpengzhang;
    }
    
    /*设置是否需要保存处理后的图像*/
    public void setSaved(boolean saved)
    {
   	   this.saved = saved;
    } 
    
    /*获得保存状态*/
    public boolean getSaved()
    {
    	return this.saved;
    }
    
    /*设置是否需要画出分布曲线*/
    public void setPic(boolean paintpic)
    {
    	this.paintpic = paintpic;
    }
    
    /*获得分布曲线状态参数*/
    public boolean getPic()
    {
    	return this.paintpic;
    }
    
    /*设置是否计算Y分量*/
    public void setY(boolean gety)
    {
    	this.gety = gety;
    }
    
    public void setUseSlider(boolean useslider)
    {
    	this.useslider = useslider;
    }
    
    public boolean getUseSlider()
    {
    	return this.useslider;
    }
    /***************************************************/
    /**
	 *以下构造函数,初始化数据
	 **/
	public SNP(BufferedImage inImage) throws Exception
	{
		/*输入初始图像，进行宽度和高度初始化*/
		src = inImage;
		w = src.getWidth(null);
		h = src.getHeight(null);
		w_h = w * h;

		boolpixel = new boolean[w_h];
		
		/*r,g,b值存放数组，存放图象RGB值*/
		r = new float[w_h];
	    g = new float[w_h];
	    b = new float[w_h];
	    
	    /*申请3个浮点空间存放每个象素点的RGB值*/	
	    rgb = new int[3];
	        
	    /*r,g,b期望值存放数组*/
	    ur = new float[w_h];							
	    ug = new float[w_h];							
	    ub = new float[w_h];	
	    
	    /*各帧r,g,b方差值存放数组*/	
	    sr = new float[w_h];							
	    sg = new float[w_h];							
	    sb = new float[w_h];
	    
	    /*二值化数组初始化*/
	    binary = new boolean[w_h];
	    binarytemp = new boolean[w_h];
	    
	    /*记录期望值方差和初始化*/
	    tempr = new float[w_h];
	    tempg = new float[w_h];
	    tempb = new float[w_h];
	    
	    /*记录亮度失真和色度失真的和*/
	    tempx = new float[w_h];
    	tempy = new float[w_h]; 
    	
	    
	    /*亮度失真和色度失真*/
	    ma = new float[w_h];
	    
	    /*象素点亮度偏移量数组α[]和色度偏移量数组cd[]*/				
	    α = new float[w_h];							
	    
	    /*初始化预先存储数组*/
	    A = new float[w_h];
	    B = new float[w_h];
	    C = new float[w_h];
	    D = new float[w_h];
	    
	    /*规格化亮度偏移量和色度偏移量存放数组*/						
	    α_ = new float[w_h];							
	    	    
	    /*初始化图形参数*/
	    a_map = new int[10000];
	    
	    /*初始化坐标原点值*/
	    Max_map = 0.0f;
		originX = 0;
	}
	
	/***************************************************/
	/**
	 *SNP处理函数,参数为输入处理图像
	 **/
	public BufferedImage SNPProcess(BufferedImage inImage) 
									throws Exception					 
	{
		
		RGBToYUV rgbtoyuv = new RGBToYUV();
		
		/*输入模板图片数增加1*/
		sampleImageNum++;
       
        /*初始化每帧光线强度的和*/
        tempalpha = 0;
        
        System.out.println(sampleImageNum + "SNPProcess");
        long t0 = System.currentTimeMillis();
        
        /*输入视频图像*/
        src = inImage;
		w = src.getWidth(null);
		h = src.getHeight(null);
		w_h = w * h;
		
		/*存取图像象素数组*/
		int pixels[] = new int[w_h];
		
		/**
	     *以下读入模版图片，将图像的所有象素存入pixels数组 
	     **/  
	    grabber = new PixelGrabber(src, 0, 0, w, h, pixels, 0, w);
	    try
		  {
		      grabber.grabPixels();
		  }catch(InterruptedException e)
	     {
	     	e.printStackTrace();