gradient_sum.cpp

人头跟踪算法

//////////////////////////////////////////////////////////////////////
// gradient_sum.cpp
// 
// Searches for the head in a neighborhood.
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"	// TRACE(), AfxMessageBox(), max(), min()
#include <stdio.h>
#include <assert.h>
#include <math.h>	// fabs()

#include "base.h" // ISIZE[XY]
#include "outline.h"


//////////////////////////////////////////////////////////////////////
// perimGradMagnitude
// 
// Sums the gradient magnitude along the perimeter of an outline.
static int perimGradMagnitude(OUTLINE *outline, 
							  unsigned char *grad, 
							  int x_cen, int y_cen)
{
	int x, y;
	short *ptr;
	unsigned char *ptrgrad;
	int sum;
	int i;
	int incx, incy;

	ptr = outline->perim;
	x = x_cen;
	y = y_cen;
	ptrgrad = grad + (ISIZEX * y_cen) + x_cen;

	sum = 0;
	for (i = 0 ; i < outline->perim_length ; i++)  {
		incx = *ptr++;
		incy = *ptr++;
		ptrgrad += (ISIZEX * incy) + incx;
		assert(ptrgrad >= grad 
			   && ptrgrad < (grad + ISIZEX*ISIZEY*sizeof(char)));
		sum += *ptrgrad;
	}	

	return(sum);
}

int NormalizedSumOfGradientMagnitude(int x, int y, OUTLINE *outline, //int sz, 
									 unsigned char *grad)
{
	int perim, score;

	perim = outline->perim_length;
	score = perimGradMagnitude(outline, grad, x, y);
	score /= perim;
	return score;
}

//////////////////////////////////////////////////////////////////////
// perimGradDotProduct
// 
// Sums the gradient magnitude along the perimeter of an outline.

static int perimGradDotProduct(OUTLINE *outline, 
							   float *gradx, float *grady,
							   int x_cen, int y_cen)
{
	int x, y;
	short *ptr;
	float *ptrn;
	float *ptrgradx, *ptrgrady;
	float sum;
	float nx, ny;
	int i;
	int incx, incy;

	ptr = outline->perim;
	ptrn = outline->normals;
	x = x_cen;
	y = y_cen;
	ptrgradx = gradx + (ISIZEX * y_cen) + x_cen;
	ptrgrady = grady + (ISIZEX * y_cen) + x_cen;

	sum = 0.0f;
	for (i = 0 ; i < outline->perim_length ; i++)  {
		incx = *ptr++;
		incy = *ptr++;
		ptrgradx += (ISIZEX * incy) + incx;
		ptrgrady += (ISIZEX * incy) + incx;
		assert(ptrgradx >= gradx 
			   && ptrgradx < (gradx + ISIZEX*ISIZEY*sizeof(float)));
		assert(ptrgrady >= grady 
			   && ptrgrady < (grady + ISIZEX*ISIZEY*sizeof(float)));
		nx = *ptrn++;
		ny = *ptrn++;
		sum += fabs((nx * *ptrgradx) + (ny * *ptrgrady));
	}	

	return((int) (100*sum));
}

int NormalizedSumOfGradientDotProduct(int x, int y, OUTLINE *outline, //int sz, 
									  float *gradx, float *grady)
{
	int perim, score;

	perim = outline->perim_length;
	score = perimGradDotProduct(outline, gradx, grady, x, y);
	score /= perim;
	return score;
}