int freeFeaturePyramidObject (CvLSVMFeaturePyramid **obj){
int i;
if(*obj == NULL) return 0;
for(i = 0; i < (*obj)->countLevel; i++)
freeFeatureMapObject(&((*obj)->pyramid[i]));
free((*obj)->pyramid);
free(*obj);
(*obj) = NULL;
return LATENT_SVM_OK;
}
int freeFeaturePyramidObject (CvLSVMFeaturePyramidCaskade **obj)
{
int i;
if(*obj == NULL) return LATENT_SVM_MEM_NULL;
for(i = 0; i < (*obj)->numLevels; i++)
{
freeFeatureMapObject(&((*obj)->pyramid[i]));
}
free((*obj)->pyramid);
free(*obj);
(*obj) = NULL;
return LATENT_SVM_OK;
}
/*
// Computation score function at the level that exceed threshold
//
// API
// int thresholdFunctionalScoreFixedLevel(const CvLSVMFilterObject **all_F, int n,
const featurePyramid *H,
int level, float b,
int maxXBorder, int maxYBorder,
float scoreThreshold,
float **score, CvPoint **points, int *kPoints,
CvPoint ***partsDisplacement);
// INPUT
// all_F - the set of filters (the first element is root filter,
the other - part filters)
// n - the number of part filters
// H - feature pyramid
// level - feature pyramid level for computation maximum score
// b - linear term of the score function
// maxXBorder - the largest root filter size (X-direction)
// maxYBorder - the largest root filter size (Y-direction)
// scoreThreshold - score threshold
// OUTPUT
// score - score function at the level that exceed threshold
// points - the set of root filter positions (in the block space)
// levels - the set of levels
// kPoints - number of root filter positions
// partsDisplacement - displacement of part filters (in the block space)
// RESULT
// Error status
*/
int thresholdFunctionalScoreFixedLevel(const CvLSVMFilterObject **all_F, int n,
const CvLSVMFeaturePyramid *H,
int level, float b,
int maxXBorder, int maxYBorder,
float scoreThreshold,
float **score, CvPoint **points, int *kPoints,
CvPoint ***partsDisplacement)
{
int i, j, k, dimX, dimY, nF0, mF0, p;
int diff1, diff2, index, last, partsLevel;
CvLSVMFilterDisposition **disposition;
float *f;
float *scores;
float sumScorePartDisposition;
int res;
CvLSVMFeatureMap *map;
#ifdef FFT_CONV
CvLSVMFftImage *rootFilterImage, *mapImage;
#else
#endif
/*
// DEBUG variables
FILE *file;
char *tmp;
char buf[40] = "..\\Data\\score\\score", buf1[10] = ".csv";
tmp = (char *)malloc(sizeof(char) * 80);
itoa(level, tmp, 10);
strcat(tmp, buf1);
//*/
// Feature map matrix dimension on the level
dimX = H->pyramid[level]->sizeX;
dimY = H->pyramid[level]->sizeY;
// Number of features
p = H->pyramid[level]->p;
// Getting dimension of root filter
nF0 = all_F[0]->sizeY;
mF0 = all_F[0]->sizeX;
// Processing the situation when root filter goes
// beyond the boundaries of the block set
if (nF0 > dimY || mF0 > dimX)
{
return LATENT_SVM_FAILED_SUPERPOSITION;
}
diff1 = dimY - nF0 + 1;
diff2 = dimX - mF0 + 1;
// Allocation memory for saving values of function D
// on the level for each part filter
disposition = (CvLSVMFilterDisposition **)malloc(sizeof(CvLSVMFilterDisposition *) * n);
for (i = 0; i < n; i++)
{
disposition[i] = (CvLSVMFilterDisposition *)malloc(sizeof(CvLSVMFilterDisposition));
}
// Allocation memory for values of score function for each block on the level
scores = (float *)malloc(sizeof(float) * (diff1 * diff2));
// A dot product vectors of feature map and weights of root filter
#ifdef FFT_CONV
getFFTImageFeatureMap(H->pyramid[level], &mapImage);
getFFTImageFilterObject(all_F[0], H->pyramid[level]->sizeX, H->pyramid[level]->sizeY, &rootFilterImage);
res = convFFTConv2d(mapImage, rootFilterImage, all_F[0]->sizeX, all_F[0]->sizeY, &f);
freeFFTImage(&mapImage);
freeFFTImage(&rootFilterImage);
#else
// Allocation memory for saving a dot product vectors of feature map and
// weights of root filter
f = (float *)malloc(sizeof(float) * (diff1 * diff2));
res = convolution(all_F[0], H->pyramid[level], f);
#endif
if (res != LATENT_SVM_OK)
{
free(f);
free(scores);
for (i = 0; i < n; i++)
{
free(disposition[i]);
}
free(disposition);
return res;
}
// Computation values of function D for each part filter
// on the level (level - LAMBDA)
partsLevel = level - LAMBDA;
// For feature map at the level 'partsLevel' add nullable border
map = featureMapBorderPartFilter(H->pyramid[partsLevel],
maxXBorder, maxYBorder);
// Computation the maximum of score function
sumScorePartDisposition = 0.0;
#ifdef FFT_CONV
getFFTImageFeatureMap(map, &mapImage);
for (k = 1; k <= n; k++)
{
filterDispositionLevelFFT(all_F[k], mapImage,
&(disposition[k - 1]->score),
&(disposition[k - 1]->x),
&(disposition[k - 1]->y));
}
freeFFTImage(&mapImage);
#else
for (k = 1; k <= n; k++)
{
filterDispositionLevel(all_F[k], map,
&(disposition[k - 1]->score),
&(disposition[k - 1]->x),
&(disposition[k - 1]->y));
}
#endif
(*kPoints) = 0;
for (i = 0; i < diff1; i++)
{
for (j = 0; j < diff2; j++)
{
sumScorePartDisposition = 0.0;
for (k = 1; k <= n; k++)
{
// This condition takes on a value true
// when filter goes beyond the boundaries of block set
if ((2 * i + all_F[k]->V.y <
map->sizeY - all_F[k]->sizeY + 1) &&
(2 * j + all_F[k]->V.x <
map->sizeX - all_F[k]->sizeX + 1))
{
index = (2 * i + all_F[k]->V.y) *
(map->sizeX - all_F[k]->sizeX + 1) +
(2 * j + all_F[k]->V.x);
sumScorePartDisposition += disposition[k - 1]->score[index];
}
}
scores[i * diff2 + j] = f[i * diff2 + j] - sumScorePartDisposition + b;
if (scores[i * diff2 + j] > scoreThreshold)
{
(*kPoints)++;
}
}
}
// Allocation memory for saving positions of root filter and part filters
(*points) = (CvPoint *)malloc(sizeof(CvPoint) * (*kPoints));
(*partsDisplacement) = (CvPoint **)malloc(sizeof(CvPoint *) * (*kPoints));
for (i = 0; i < (*kPoints); i++)
{
(*partsDisplacement)[i] = (CvPoint *)malloc(sizeof(CvPoint) * n);
}
/*// DEBUG
strcat(buf, tmp);
file = fopen(buf, "w+");
//*/
// Construction of the set of positions for root filter
// that correspond score function on the level that exceed threshold
(*score) = (float *)malloc(sizeof(float) * (*kPoints));
last = 0;
for (i = 0; i < diff1; i++)
{
for (j = 0; j < diff2; j++)
{
if (scores[i * diff2 + j] > scoreThreshold)
{
(*score)[last] = scores[i * diff2 + j];
(*points)[last].y = i;
(*points)[last].x = j;
for (k = 1; k <= n; k++)
{
if ((2 * i + all_F[k]->V.y <
map->sizeY - all_F[k]->sizeY + 1) &&
(2 * j + all_F[k]->V.x <
map->sizeX - all_F[k]->sizeX + 1))
{
index = (2 * i + all_F[k]->V.y) *
(map->sizeX - all_F[k]->sizeX + 1) +
(2 * j + all_F[k]->V.x);
(*partsDisplacement)[last][k - 1].x =
disposition[k - 1]->x[index];
(*partsDisplacement)[last][k - 1].y =
disposition[k - 1]->y[index];
}
}
last++;
}
//fprintf(file, "%lf;", scores[i * diff2 + j]);
}
//fprintf(file, "\n");
}
//fclose(file);
//free(tmp);
// Release allocated memory
for (i = 0; i < n ; i++)
{
free(disposition[i]->score);
free(disposition[i]->x);
free(disposition[i]->y);
free(disposition[i]);
}
free(disposition);
free(f);
free(scores);
freeFeatureMapObject(&map);
return LATENT_SVM_OK;
}