alg.c

dm642上实现运动目标检测与跟踪

/******************************************************************************
* FileName :alg.c
*Author : Bentao Wu
* Modified Date :  15:16 2007-7-19
*Description :
*Copyright (c) 2007 Whu
All right reserved.
*******************************************************************************/
#include "typedef.h"
#include "alg.h"
#include <mem.h>
#include <math.h>


extern Int EXTERNALHEAP;/*
#pragma DATA_SECTION(PIs,       ".INTPROCBUFF");
#pragma DATA_ALIGN(PIs,    4);
static  float  PIs[256];

#pragma DATA_SECTION(Hist,       ".INTPROCBUFF");
#pragma DATA_ALIGN(Hist,    4);
static  uint32  Hist[256];*/
 //******************************************************************
 //find_object 进行全视场搜索目标

 //return:  if obj was found ,return postion,else return0;
//*********************************************************************************
int32 find_object(uint8* buffer,uint8 Tr, int32 * leftx, int32* lefty, int32* rightx, int32 * righty)
{
 uint8* buf2=buffer;
   int32 i,j;
   int32 right_x=0,right_y=0,left_x=512,left_y=287;  
   int32 flag=0;

   for(i=0;i<HEIGHT;i++)
   {
     for(j=0;j<WIDTH;j++)
	 {
	   if(abs(buf2[j])>200)
	     {
		 flag=1;
		  if(j<left_x) 
				{
					left_x=j;
				}
		  else if(j>right_x)
				{
					right_x=j;
				}
	     

	   if(i<left_y)
	   {
	    left_y=i;
	    }
	  else if(i>right_y)
	   {
	    right_y=i;
	   }
	   }

	 }
	 buf2+=WIDTH;
	}
    *leftx=left_x;  
	*lefty=left_y;
	*righty=right_y;
	*rightx=right_x;

  return flag;
}


//******************************************************************
//Moment Invariants algorithm                   矩不变分割算法 ，返回阈值             *
//*  ****************************************************************   
//#define  WIDTH    512
//#define  HEIGHT    287
int32 mia(uint8 * pimage)
{ float  PIs[256];
uint32  Hist[256];
 //int Z0=0,Z1=255;
 //int Hist[256];  //normal    Histograms  
 //float PIs[256]; //  Normalization   Histograms
 int i,j;
 int nps,Tr;
 //int Size=HEIGHT*WIDTH;
  double m0=1,m1=0,m2=0,m3=0;
 double C0,C1,G,P0,P1=0;
 
 //memset(ihist, 0, 256);
 for (i = 0; i <256; i++) 
  Hist[i]=0;
 
 
 for (i =0; i < HEIGHT; i++) 
 { 
 #pragma MUST_ITERATE (WIDTH,WIDTH,WIDTH)
  for (j = 0; j < WIDTH; j++) 
  {   nps =(int) pimage[i*WIDTH+j];
  Hist[nps]++;
  }
 }
 
 for (i = 0; i <256; i++) 
  PIs[i]=(float)Hist[i]/(HEIGHT*WIDTH);
 
 for (i = 0; i <256; i++) //计算三个矩
 {
  m1+=PIs[i]*i;
  m2+=PIs[i]*i*i;
  m3+=PIs[i]*i*i*i;
 }
 
 C0=(double)((m1*m3-m2*m2)/(m2-m1*m1));//转换
 C1=(double)((m1*m2-m3)/(m2-m1*m1));
 G=(double)((sqrt(C1*C1-4*C0)-C1)/2);
 P0=(double)((G-m1)/(2*G+C1));//计算机P0
 
 for (i = 0; i <256; i++) 
 { P1+=PIs[i];
   if(P1==P0){Tr=i;break;}
   else if(P1>P0){Tr=i-1;break;}
 }
return Tr;
}

 //****************************************************************************************
//gradient-based threshold  algorithm        基于梯度的阈值分割     ，波门内使用                                          *
//****************************************************************************************
/*
int32 gradient(uint8 * pImage,int32 width,int32 height)
{
int32 i,j;
 int32* mid;
 int32* Gf;
 int32 xf,yf;
 int32 max0=0,min0=255;
 int32 Te;
 int32 MG=0;
 int32 Cont=0;
 int32 MID=0;
 int32 midheight=height>>2;

  mid=(int32*)MEM_alloc(EXTERNALHEAP,(midheight)<<2,4);
   Gf=(int32*)MEM_alloc(EXTERNALHEAP,((width-1)*(height-1))<<2,4);
 if(Gf==MEM_ILLEGAL||mid==MEM_ILLEGAL)
 return -1;
 else
 {
 for (i =0; i < (midheight); i++) 
 { mid[i]=0;
  for (j = 0; j < (width>>2); j++) 
  {mid[i]+=(int32)pImage[(i*WIDTH+j)<<2];
  }
  mid[i]/=(width>>2);
  MID+=mid[i];
 }
 MID=MID/midheight;
 
 for (i =0; i < height-1; i++) 
 { 
  for (j = 0; j < width-1; j++) 
  {
   yf=_abs((int) (pImage[((i+1)<<9)+j]-pImage[(i<<9)+j]));
   xf=_abs((int)(pImage[(i<<9)+j+1]- pImage[(i<<9)+j]));
   Gf[i*(width-1)+j]=_max2(xf,yf);
  max0=_max2(Gf[i*(width-1)+j],max0);
  min0=_min2(Gf[i*(width-1)+j],min0);
  }
  
 }
Te=((max0-min0)>>1);

 for (i =0; i < height-1; i++) 
 {      for (j = 0; j < width-1; j++) 
        {
          if(Gf[i*(width-1)+j]>=Te)
           {
             MG+=Gf[i*(width-1)+j];
             Cont++;
           }
       }
 }
 MG=MG/Cont;
 MEM_free(EXTERNALHEAP, Gf, ((width-1)*(height-1))<<2);
 MEM_free(EXTERNALHEAP, mid, (midheight)<<2);
 //MID+MG*a;      a=0.6875                a should be adjusted between  (0.6~0.8); 
 return (MID+(MG>>1)+(MG>>3)+(MG>>4));
 }
} */

//*****************************************************************************************************
//波门内搜索目标，未搜索到返回-1                                                                                                                                              *
//*******************************************************************************************************
int32 wnd_find(uint8 *obj,uint8 * p_port,int32 obj_width,int32 obj_height,int32* x,int32 *y)
{
int32 i,j,k,l;
int32 temp=0;  //the max number
//int32 pos=0;//=(i*20+j)
int32 sum=0;
for(i=0;i<13;i++)  //13=12+1
 {
   for(j=0;j<21;j++)  //21=20+1
   {  
   sum=0;
   for(k=0;k<obj_height;k++)
   {
     for(l=0;l<obj_width;l++)
	 {
	 // sum=sum+abs(obj[l+k*obj_width] -district[l+j+((i+k)<<9)]);
	 if(abs(obj[l+k*obj_width] -p_port[l+j+((i+k)<<9)])<12)
	 sum=sum+1;
	 }
	}
	if(temp<sum)
	 { temp=sum;
	 *y=i;
	 *x=j;
      }
   }
 }
//