snp.java

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

	     }
	    /*获取图片默认颜色模型*/
	     model = grabber.getColorModel();
	     
	/***************************************************************************/
	    /**
	     *前奏：记录所有象素点的R,G,B值
	     **/
	     for(int y=0;y<h;y++)
	     	for(int x=0;x<w;x++){
	     		int pixel = pixels[y * w + x];
	     		r[y * w + x] = model.getRed(pixel);
	     		g[y * w + x] = model.getGreen(pixel);
	     		b[y * w + x] = model.getBlue(pixel);
	     		rgb[0] = (int)r[y * w + x];
	     		rgb[1] = (int)g[y * w + x];
	     		rgb[2] = (int)b[y * w + x];
	     	}
     	
   /****************************************************************************/
        
	
		/*计算参照背景每个象素点的期望值*/
	    for(int y=0;y<h;y++)
	    	for(int x=0;x<w;x++){
	    		ur[y * w + x] = (float)(ur[y * w + x]*(sampleImageNum-1)+r[y * w + x])
	    						/(float)sampleImageNum;
	    		ug[y * w + x] = (float)(ug[y * w + x]*(sampleImageNum-1)+g[y * w + x])
	    						/(float)sampleImageNum;
	    		ub[y * w + x] = (float)(ub[y * w + x]*(sampleImageNum-1)+b[y * w + x])
	    						/(float)sampleImageNum;
	    	}
	    

	    /*计算参照背景每个象素点的方差值*/
    	for(int y=0;y<h;y++)
	    	for(int x=0;x<w;x++){
	    	   if(boolpixel[y * w + x])
	    	   {
			       tempr[y * w + x] = tempr[y * w + x] + (r[y * w + x]-ur[y * w + x])*
			       		 (r[y * w + x]-ur[y * w + x]);
			       tempg[y * w + x] = tempg[y * w + x] + (g[y * w + x]-ug[y * w + x])*
			       		 (g[y * w + x]-ug[y * w + x]);
			       tempb[y * w + x] = tempb[y * w + x] + (b[y * w + x]-ub[y * w + x])*
			       		 (b[y * w + x]-ub[y * w + x]);
			       		 
			       /*如果只有当前一帧，则直接进行各值初始化*/
			       if(sampleImageNum==1)
			       {
				    	sr[y * w + x] = 0.0001f;    
				    	sg[y * w + x] = 0.0001f;
				    	sb[y * w + x] = 0.0001f;
				    	α[y * w + x] = 1.0f;
				    	ma[y * w + x] = 1.0f;
			       }/*end if*/
			       else/*否则*/
			       {
				       /*学习图像的每个象素点的标准差,如果方差为0，则设定最小值*/
						if(tempr[y * w + x]==0)
						{
							tempr[y * w + x] = 0.0001f;
							sr[y * w + x] = 0.0001f;
						}else{
							sr[y * w + x] = (float)Math.sqrt(tempr[y * w + x]
											/(sampleImageNum-1.0f));
						}
						if(tempg[y * w + x]==0)
						{
							tempg[y * w + x] = 0.0001f;
							sg[y * w + x] = 0.0001f;
						}else{
							sg[y * w + x] = (float)Math.sqrt(tempg[y * w + x]
											/(sampleImageNum-1.0f));
						}
						if(tempb[y * w + x]==0)
						{
							tempb[y * w + x] = 0.0001f;
							sb[y * w + x] = 0.0001f;
						}else{
							sb[y * w + x] = (float)Math.sqrt(tempb[y * w + x]
											/(sampleImageNum-1.0f));
						}
						
						/*计算暂存数组*/
						A[y * w + x] = (ur[y * w + x]/sr[y * w + x]) 
									* (ur[y * w + x]/sr[y * w + x]) 
									+ (ug[y * w + x]/sg[y * w + x]) 
									* (ug[y * w + x]/sg[y * w + x]) 
									+ (ub[y * w + x]/sb[y * w + x]) 
									* (ub[y * w + x]/sb[y * w + x]);
						B[y * w + x] = ur[y * w + x]/(A[y * w + x] 
									  * (sr[y * w + x] * sr[y * w + x]));				
						C[y * w + x] = ug[y * w + x]/(A[y * w + x] 
									  * (sg[y * w + x] * sg[y * w + x]));
						D[y * w + x] = ub[y * w + x]/(A[y * w + x] 
									  * (sb[y * w + x] * sb[y * w + x]));
						
					    /*计算学习图像每个象素点的亮度偏移量和色度偏移量*/
	
						α[y * w + x] = r[y * w + x] * B[y * w + x] 
										+ g[y * w + x] * C[y * w + x] 
										+ b[y * w + x] * D[y * w + x];	
										
					
						tempalpha = tempalpha + α[y * w + x];
						
										   	  
				        /*计算每个象素点的亮度失真算和色度失真*/
				   		tempx[y * w + x] = tempx[y * w + x] 
				   						  + (α[y * w + x]-1)*(α[y * w + x]-1);
			    
			        	
			        	if(tempx[y * w + x]==0)
						    {
						    	tempx[y * w + x] = 0.0000001f;
						    	ma[y * w + x] = 0.0001f;
						    }
						else 
						    {
						    	ma[y * w + x]=(float)Math.sqrt(tempx[y * w + x]
						    				  /(sampleImageNum));
						    }
						 
			        	/*计算训练帧数的规格化亮度和色度值*/
			        	
			        	α_[y * w + x] = (α[y * w + x] - 1.0f)/ma[y * w + x];
	    	   
	    	   				/*计算当前图像色度和亮度偏移量的最大最小值*/
				    	if(α_[y * w + x]>max_α_)
				    	{
				    		max_α_ = α_[y * w + x];
				    		max_location = y * w + x;
				    	}		
				    
				    	if(α_[y * w + x]<min_α_)
				    	{
				    		min_α_ = α_[y * w + x];
				    		min_location = y * w + x;
				    	}	
	
			    	}/*end else(1<sampleImagenum<studyImageNum)*/
		    	}/*end if*/
		    	else
		    	{
		    		α_[y * w + x] = 1.0f;
		    	}	  
		  	} /*end for*/  		  	
		
	/*	if(sampleImageNum == 8)
		    for(int i = 0; i <100; i++)
		    {
		    	System.out.print(sampleImageNum + ": " + "Y: " + r[i] + " " + g[i] + " " + b[i] + " ");
		    	System.out.print("U: " + ur[i] + " " + ug[i] + " " + ub[i] + " ");
		    	System.out.print("S: " + sr[i] + " " + sg[i] + " " + sb[i] + " ");
		    	System.out.println();
		    	System.out.print("A: " + α[i] + " A_" + α_[i]  + " " + ma[i] + " tempx" + tempx[i] + " " );
				System.out.print("sr:" + sr[i] + " sg:" + sg[i] + " sb:" + sb[i]+ " ");
				System.out.println();
		    }		
					
		 /*查看计算的最大最小值*/  
		 /*
	     System.out.println("max_α_ = "+max_α_+"\t\tmin_α_ = "+min_α_);	
	     System.out.println("max_location= "+max_location+"\t\tmin_location= "+min_location);
	     */
		 
		 if(gety)
		 {
		 	System.out.println("当前的Y分量为: " + RGBToYUV.gety(rgb));
		 }
		 
		 /**
		  *α_分布曲线的描绘和观测
		  **/
		  if(paintpic)
		  {
		  	    /*描绘训练之后α_分布曲线的（见图α_分布曲线.jpg)*/
				/*横坐标放大倍数*/
				float p=10.0f;
				/*纵坐标放大倍数*/
				float t=1.0f;	
				
				/*横坐标α_ 范围*/ 
				int temp=(int)Math.ceil(10*p);   
		              
				for(int i=0;i<temp;i++){
					/*初始化分布曲线图像*/	
					a_map[i]=0;
														
					int mina=(int)Math.ceil((-5)*p);
					
					for(int j=0;j<w_h;j++){
						if(Math.ceil(α_[j]*p)==i+mina)
							a_map[i]=a_map[i]+1;
							/*获取原点坐标值*/
							if(Max_map<a_map[i])
							{
								Max_map=a_map[i];
								originX=i;	
							}/*end if*/						
					}/*end for*/
				}/*end for*/	
				
			    BufferedImage α_tag_ = new BufferedImage(300,300,BufferedImage.TYPE_INT_RGB);												
				for(int i=0;i<temp;i++){
				    α_tag_.setRGB((int)((float)i/(float)temp*300),(int)((1-(float)a_map[i]/
					(float)w_h*t)*300-1),16777215);												
				}
				FileOutputStream α_out_=new FileOutputStream("display/α_分布曲线.jpg");
				JPEGImageEncoder α_encoder_ = JPEGCodec.createJPEGEncoder(α_out_);
				α_encoder_.encode(α_tag_);
				α_out_.close();
		  }
		  
		 /*输出每帧光线强度的和*/
		 if(totalalpha)
		 {
		 	rgbtoyuv.createtables();
		 	System.out.println("currentalpha" + this.getTempalpha());
		 }
		 
 		

	
		/*返回并保存处理结果*/	  																    
		BufferedImage tag = new BufferedImage(w,h,BufferedImage.TYPE_INT_RGB);													
		tag.getGraphics().drawImage(src,0,0,w,h,null);
		
		/**
		 *二值化输出,因需要膨胀,将背景设为false,前景true
		 **/
		if(binaryvalue)
		{
			for(int y=0;y<h;y++)
			    for(int x=0;x<w;x++){
			    	
			    	/*阈值，进行边界选择*/
				    float t_a1 = 1 + 2.58f*(α[y*w+x]);
				    float t_a2 = 1 - 2.58f*α[y*w+x] * slidervalue ;
			    	
			    	
			        if((α_[y * w + x]<t_a2)||(α_[y * w + x]>t_a1))
			    	{
			    		binary[y*w+x] = true;
			    	}
			   		//原始背景（和背景图象中相同像素具有相似的光亮度和色度）设置白色
			    	else {
			    		binary[y*w+x] = false;												
			    	}
		    	}/*end for*/
		}
		/**
		 *原图输出处理,无需膨胀直接输出
		 **/
		else{
			if(!getUseSlider())
			{
			//	System.out.println("not use slider!");
				if(RGBToYUV.gety(rgb) <= 30)
				{
					slidervalue = 3.0f;
					slidervalue2 = -2.73f;
				}
				else if(RGBToYUV.gety(rgb) <= 60)
				{
					slidervalue = (float)80/RGBToYUV.gety(rgb);
					slidervalue2 = -1.5f * slidervalue;
				}
				else if(RGBToYUV.gety(rgb) <= 80)
				{
					slidervalue = 1.1f;
					slidervalue2 = -2.06f;
				}
				else if(RGBToYUV.gety(rgb) <= 100)
				{
					slidervalue = 1.16f;
					slidervalue2 = -1.5f;
				}
				else if(RGBToYUV.gety(rgb) <= 130)
				{
					slidervalue = 1.16f;
					slidervalue2 = -1.13f;
				}
				else
				{
					slidervalue = 3.0f;
					slidervalue2 = -3.0f;
				}	
			}else
			{
			//	System.out.println("Use slider!");
			}
										
		/*进行边界分类,对图像进行最后处理*/	
			for(int y=0;y<h;y++)
			    for(int x=0;x<w;x++){
			    	
			    	
			    	/*阈值，进行边界选择*/
				    float t_a1 = 1 + 2.58f*(α[y*w+x]);
				    float t_a2 = 1 - 2.58f*α[y*w+x] * slidervalue ;
				
			    	/*阴影（和当前图象中相同像素具有相似的色度和较低的亮度）设置蓝色*/
			    	if((α_[y * w + x]<slidervalue2)&&(α_[y * w + x]>t_a2))
			    	{
			    		tag.setRGB(x,y,255);
			    	}
			    	/*突出背景（和当前图象中相同像素具有相似的色度和较高的亮度）设置红色*/
			    	else if((α_[y * w + x]<t_a2)||(α_[y * w + x]>t_a1))
			    	{
			    		tag.setRGB(x,y,16711680);
			    	}
			   		//原始背景（和背景图象中相同像素具有相似的光亮度和色度）设置原来颜色
			    	else {
			    		tag.setRGB(x,y,(int)(r[y * w + x]*65536+
			    		g[y * w + x]*256+b[y * w + x]));
			    													
			    	}
		    	}/*end for*/
       		}
       	/**
       	 *二值化膨胀处理
       	 **/
       	 if(wantpengzhang)
       	 {
       	 	for(int y=1;y<h-1;y++){
       	 		int yw=y*w,y1w=(y-1)*w,y2w=(y+1)*w;
			    for(int x=1;x<w-1;x++){
			    	if(!binary[yw + x])
			    		{
			    			if(binary[y1w + x]||binary[y2w + x]||binary[yw + x + 1]||binary[yw + x - 1])
			    			{
			    				binarytemp[yw + x]=true;
			    			} 
    						else binarytemp[yw + x]=false;
			    		}
			    	else binarytemp[yw + x]=true;
			    
			    }
			}
			
			for(int y=0;y<h;y++)
			    for(int x=0;x<w;x++){
			    	binary[y * w + x] = binarytemp[y * w + x];
			 	}   
       	 }
       	 
       	 /*二值化结果图像输出*/
       	 if(binaryvalue)
		{
			for(int y=0;y<h;y++)
			    for(int x=0;x<w;x++){					  
			        /*动态前景（像素具有和期望值不同的色度）设置成绿色*/
			    	if(binary[y * w + x]){
						tag.setRGB(x,y,0);				
			    	}
			    	else {
			    		tag.setRGB(x,y,-1);											
			    	}
		    	}/*end for*/
		}
		
        /**
         *保存图像处理
         **/
         if(saved)
         {
	        FileOutputStream out=new FileOutputStream("result/result"+
			sampleImageNum+".jpg");
			JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(out);
			encoder.encode(tag);
			out.close();
         }
		
		t0 = System.currentTimeMillis() - t0;
      	System.out.println("Paint the picture takes " + t0 + "ms");
      	 
	    return tag;   
	    
	}/*end SNPProcess()*/
}