centroid.cpp

图像处理软件,功能比较基础

   }

   /* get the target region in search window  */
   for(k=0; k<labelnum; k++)
   {
      mean_ratio = fabs(region[k].mean-target->mean)/target->mean;
      //aera_ratio = fabs(region[k].aera-target->aera)/target->aera;
      if(mean_ratio<0.5)// && aera_ratio<0.5)
      {
         target->left = region[k].left;
         target->up = region[k].up;
         target->down = region[k].down;
         target->right = region[k].right;
         target->mean = region[k].mean;
         target->aera = region[k].aera;
         target->distance = region[k].distance;
         target->centroidr = region[k].centroidr;
         target->centroidc = region[k].centroidc;
         k = labelnum+1;   /* end the cycle */
        /* adjust the coordinate */
         target->left += SearchWin.left;
         target->up += SearchWin.up;
         target->down += SearchWin.up;
         target->right += SearchWin.left;
         target->centroidr += SearchWin.up;
         target->centroidc += SearchWin.left;
         ffree_2d((void **)segimg,SearchWinRow);     
         return 1;
      }
      else
      {
         
      }
   }

/*   for(i=0; i<SearchWinRow; i++)
   for(j=0; j<SearchWinCol; j++)
      oriimg[i+SearchWin.up][j+SearchWin.left]=segimg[i][j];
  */ 
 
   ffree_2d((void **)segimg,SearchWinRow);     
   return 0;
}

int CentroidTrack1(unsigned char **oriimg,int row,int col,RegionInfo *target)
{
   FRAME SearchWin;
   int dr,dc;       /*   */
   double ratio;       /* expended ratio  */
   int threshold;
   int SearchWinRow,SearchWinCol;
   int labelnum;    /* label region number */
   unsigned char **segimg;
   RegionInfo region[10],temp;
   double aera_ratio;
   double mean_ratio;
   int i,j,k;
   double aver;
   int count;
   
   ratio = 1.0;
   dr = (int)((target->down - target->up)*ratio);
   dc = (int)((target->right - target->left)*ratio);
//   dr = 5;
//   dc = 5;
   dr = dr<8 ? 8 : dr;
   dc = dc<8 ? 8 : dc;
   /* define the search window  */
   SearchWin.up = target->up - dr;
   SearchWin.down = target->down + dr;
   SearchWin.left = target->left - dc;
   SearchWin.right = target->right + dc;
   //boundary detection
   SearchWin.up = SearchWin.up<0 ? 0 : SearchWin.up;
   SearchWin.down = SearchWin.down>=row ? row-1 : SearchWin.down;
   SearchWin.left = SearchWin.left<0 ? 0 : SearchWin.left;
   SearchWin.right = SearchWin.right>=col ? col-1 : SearchWin.right;
   SearchWinRow = SearchWin.down - SearchWin.up;
   SearchWinCol = SearchWin.right - SearchWin.left;

 
   /* get the segmented threshold */
//   threshold = NonlineOtsu(oriimg,SearchWin.up,SearchWin.left,SearchWinRow,SearchWinCol,0.1);
//   threshold = Otsu1(oriimg,SearchWin.up,SearchWin.left,SearchWinRow,SearchWinCol);
//   threshold = GrdientSeg(oriimg,SearchWin.up,SearchWin.left,SearchWinRow,SearchWinCol);
   
   segimg = (unsigned char **)fspace_2d(SearchWinRow,SearchWinCol,sizeof(unsigned char));   
   if(!segimg) return 0;
   /* segment the selected window  */
   aver = 0;
   count = 0;
   for(i=0; i<SearchWinRow; i++)
   for(j=0; j<SearchWinCol; j++)
   {
      segimg[i][j] = oriimg[i+SearchWin.up][j+SearchWin.left];
      aver += segimg[i][j];
      count += 1;
   }
   aver /= count;
   for(i=0; i<SearchWinRow; i++)
   for(j=0; j<SearchWinCol; j++)
   {
      //segimg[i][j] = (int)(segimg[i][j] - aver);
      //if(segimg[i][j]<0) segimg[i][j] = 1;
	   if(segimg[i][j]<aver) segimg[i][j] = 0;
   }

   threshold = Otsu1(segimg,0,0,SearchWinRow,SearchWinCol);
   for(i=0; i<SearchWinRow; i++)
   for(j=0; j<SearchWinCol; j++)
   {
      if(segimg[i][j]>threshold) segimg[i][j]=255;
	  else segimg[i][j] = 0;
   }
   
   /* label the segmented image */
   labelnum = Label(segimg,SearchWinRow,SearchWinCol,LABELMODE_1,4);
   
   /* get the segmented region's information,including aera,mean,range,centroid,etc. */
   for(k=0; k<labelnum; k++)
   {
      region[k].left = SearchWinCol;
      region[k].up = SearchWinRow;
      region[k].right = 0;
      region[k].down = 0;
      region[k].mean = 0;
      region[k].aera = 0;
      region[k].centroidr = 0;
      region[k].centroidc = 0;
   }

   for(i=0; i<SearchWinRow; i++)
   for(j=0; j<SearchWinCol; j++)
   {
      if(segimg[i][j])
      {
         k = segimg[i][j];
         if(i<region[255-k].up) region[255-k].up = i;
         if(i>region[255-k].down) region[255-k].down = i;
         if(j<region[255-k].left) region[255-k].left = j;
         if(j>region[255-k].right) region[255-k].right = j;
         region[255-k].aera += 1;
         region[255-k].mean += oriimg[i+SearchWin.up][j+SearchWin.left];
         region[255-k].centroidr += i*oriimg[i+SearchWin.up][j+SearchWin.left];
         region[255-k].centroidc += j*oriimg[i+SearchWin.up][j+SearchWin.left];
      }
   }

   for(k=0; k<labelnum; k++)
   {
      region[k].centroidr = region[k].centroidr/region[k].mean;
      region[k].centroidc = region[k].centroidc/region[k].mean;
      region[k].mean /= region[k].aera;
      region[k].distance = sqrt((region[k].centroidr-target->centroidr)*(region[k].centroidr-target->centroidr)
                 + (region[k].centroidc-target->centroidc)*(region[k].centroidc-target->centroidc));
   }
   /* sort region according the distance */
   for(i=0; i<labelnum; i++)
   for(j=i+1; j<labelnum; j++)
   {
      if(region[j].distance<region[i].distance)
      {
         temp.aera = region[i].aera;
         temp.mean = region[i].mean;
         temp.distance = region[i].distance;
         temp.left = region[i].left;
         temp.up = region[i].up;
         temp.right = region[i].right;
         temp.down = region[i].down;            
         temp.centroidr = region[i].centroidr;
         temp.centroidc = region[i].centroidc;

         region[i].aera = region[j].aera;
         region[i].mean = region[j].mean;
         region[i].distance = region[j].distance;
         region[i].left = region[j].left;
         region[i].up = region[j].up;
         region[i].right = region[j].right;
         region[i].down = region[j].down;            
         region[i].centroidr = region[j].centroidr;
         region[i].centroidc = region[j].centroidc;

         region[j].aera = temp.aera;
         region[j].mean = temp.mean;
         region[j].distance = temp.distance;
         region[j].left = temp.left;
         region[j].up = temp.up;
         region[j].right = temp.right;
         region[j].down = temp.down;            
         region[j].centroidr = temp.centroidr;
         region[j].centroidc = temp.centroidc;
      }
   }

   /* get the target region in search window  */
   for(k=0; k<labelnum; k++)
   {
      mean_ratio = fabs(region[k].mean-target->mean)/target->mean;
      aera_ratio = fabs(region[k].aera-target->aera)/target->aera;
      if(mean_ratio<0.5)// && aera_ratio<0.5)
      {
         target->left = region[k].left;
         target->up = region[k].up;
         target->down = region[k].down;
         target->right = region[k].right;
         target->mean = region[k].mean;
         target->aera = region[k].aera;
         target->distance = region[k].distance;
         target->centroidr = region[k].centroidr;
         target->centroidc = region[k].centroidc;
         k = labelnum+1;   /* end the cycle */
        /* adjust the coordinate */
         target->left += SearchWin.left;
         target->up += SearchWin.up;
         target->down += SearchWin.up;
         target->right += SearchWin.left;
         target->centroidr += SearchWin.up;
         target->centroidc += SearchWin.left;
      
         ffree_2d((void **)segimg,SearchWinRow);     
         return 1;
      }
   }

   ffree_2d((void **)segimg,SearchWinRow);     
   return 0;   // lost the target
}

void PushQueue(double dr,double dc,int FrameRate)
{
   int i;
   if(QueueIndex>=QueueSize)
   {  /* if the quene is full */
      for(i=0; i<QueueSize-1; i++)
      { 
         XYQueue[i].dr = XYQueue[i+1].dr;
         XYQueue[i].dc = XYQueue[i+1].dc;
         XYQueue[i].v = XYQueue[i+1].v;
         XYQueue[i].vr = XYQueue[i+1].vr;
         XYQueue[i].vc = XYQueue[i+1].vc;
         XYQueue[i].a = XYQueue[i+1].a;
      }
      XYQueue[QueueSize-1].dr = dr;
      XYQueue[QueueSize-1].dc = dc;
      XYQueue[QueueSize-1].vr = dr*FrameRate;
      XYQueue[QueueSize-1].vc = dc*FrameRate;
      XYQueue[QueueSize-1].v = sqrt(dr*dr+dc*dc)*FrameRate;
   }
   else   /* if the quene is not full */
   {
      XYQueue[QueueIndex].dr = dr;
      XYQueue[QueueIndex].dc = dc;
      XYQueue[QueueSize-1].vr = dr*FrameRate;
      XYQueue[QueueSize-1].vc = dc*FrameRate;
      XYQueue[QueueSize-1].v = sqrt(dr*dr+dc*dc)*FrameRate;
      QueueIndex++;
   }
}

void NextPosition(unsigned char **oriimg,int row,int col,RegionInfo *target,int FrameRate)
{
   double AveVr,AveVc;  /* the average velocity along r & c direction */
   double Avedr,Avedc;
   int i;
   /* compute the average track error  */
   Avedr = 0;
   Avedc = 0;
   for(i=0; i<QueueIndex; i++)    
   {
      Avedr += XYQueue[i].dr;
      Avedc += XYQueue[i].dc;
   }
   Avedr /= QueueIndex;
   Avedc /= QueueIndex;
   target->centroidr += Avedr;
   target->centroidc += Avedc;
   target->down += Avedr;
   target->up += Avedr;
   target->left += Avedc;
   target->right += Avedc;
   target->down = target->down>=row ? row-1 : target->down;
   target->up = target->up<0 ? 0 : target->up;
   target->left = target->left<0 ? 0 : target->left;
   target->right = target->right>=col ? col-1 : target->right;

   /* compute the average velocity */
/*   AveVr = 0;
   AveVc = 0;
   for(i=0; i<QueueIndex; i++)    
   {
      AveVr += XYQueue[i].vr;
      AveVc += XYQueue[i].vc;
   }
   AveVr /= QueueIndex;
   AveVc /= QueueIndex;

   target->centroidc += (AveVc/FrameRate);
   target->centroidr += (AveVr/FrameRate);
*/
}


void CorrTrack(unsigned char **oriimg,int row,int col,unsigned char **temimg,int temrow,int temcol,int *r,int *c)
{
   int i,j,k,l;