static Boolean logs_sum_to_zero(
Complex summand0, Orientation eo0,
Complex summand1, Orientation eo1)
{
Complex sum;
if (eo0 != eo1)
summand1.real = - summand1.real;
sum = complex_plus(summand0, summand1);
normalize_angle(&sum.imag);
return (complex_modulus(sum) < CANCELLATION_EPSILON);
}
void find_peak(double EachImage_Filter_Respone[][Width][2],int row_start,int row_end,int column_start,int column_end,int *row_position, int *column_position)
{
double temp=0.0;
double local_max=0.0;
int i,j;
for (i=row_start;i<row_end;i++)
{
for (j=column_start;j<column_end;j++)
{
temp=complex_modulus(EachImage_Filter_Respone[i][j]);
if (local_max<=temp)
{
local_max=temp;
*row_position=i;
*column_position=j;
}
}
}
}
int EBGM_FaceComparison(int total_trainface,int train_feature_count[], double train_feature[][500][41][2],
int probe_feature_count,double Probe_feature_Vectors[][41][2])
{
int i,j,k,m;
int MaxSimilarity_count[Total_train_face]={0};
double OveralSimilarity[Total_train_face]={0.0};
double temp_max_similarity=0.0;
double point_peak_similarity=0.0;
int max_similarity_index=0;
int point_peak_index;
int point_peak_existed=0;
double similarity=0.0;
double similarity_matrix[500][Total_train_face]={0.0};
double temp_MaxSimilarity_count=0.0,temp_feature_count=0.0;
double thresh_distance=8.0;
double probe_xcoordiante;
double probe_ycoordiante;
double train_xcoordiante;
double train_ycoordiante;
double distance=0.0;
double last_similarity=0.0;
double dotproduct=0.0;
double train_feature_sqr=0.0;
double probe_feature_sqr=0.0;
for (i=0;i<probe_feature_count;i++)
{
probe_xcoordiante=Probe_feature_Vectors[i][0][0];
probe_ycoordiante=Probe_feature_Vectors[i][0][1];
for (j=0;j<total_trainface;j++)
{
last_similarity=0.0;
for (k=0;k<train_feature_count[j];k++)
{
similarity=0.0;
train_xcoordiante=train_feature[j][k][0][0];
train_ycoordiante=train_feature[j][k][0][1];
distance=sqrt((train_xcoordiante-probe_xcoordiante)*(train_xcoordiante-probe_xcoordiante)+(train_ycoordiante-probe_ycoordiante)*(train_ycoordiante-probe_ycoordiante));
if (distance<=thresh_distance)
{
dotproduct=0.0;
train_feature_sqr=0.0;
probe_feature_sqr=0.0;
for (m=1;m<41;m++) //the first one is position information
{
dotproduct=dotproduct+sqrt(complex_modulus(train_feature[j][k][m]))*sqrt(complex_modulus(Probe_feature_Vectors[i][m]));
train_feature_sqr = train_feature_sqr + complex_modulus(train_feature[j][k][m]);
probe_feature_sqr = probe_feature_sqr + complex_modulus(Probe_feature_Vectors[i][m]);
}
similarity=dotproduct/sqrt(train_feature_sqr*probe_feature_sqr);
if (similarity>last_similarity)
{
similarity_matrix[i][j]=similarity;
last_similarity=similarity;
}
}
}
}
}
for (i=0;i<probe_feature_count;i++)
{
point_peak_similarity=0.0;
point_peak_existed=0;
for (j=0;j<total_trainface;j++)
{
if (similarity_matrix[i][j]>point_peak_similarity)
{
point_peak_similarity=similarity_matrix[i][j];
point_peak_index=j;
point_peak_existed++;
}
}
if (point_peak_existed>0)
{
MaxSimilarity_count[point_peak_index]++;
}
}
for (i=0;i<total_trainface;i++)
{
temp_MaxSimilarity_count=MaxSimilarity_count[i];
temp_feature_count=train_feature_count[i];
OveralSimilarity[i]= temp_MaxSimilarity_count/temp_feature_count;
if (temp_max_similarity<=OveralSimilarity[i])
{
temp_max_similarity=OveralSimilarity[i];
max_similarity_index=i;
}
}
return max_similarity_index;
}
int EBGM_FaceComparison(int total_trainface,int train_feature_count[], double train_gabor_feature[][500][41][2],
int probe_feature_count,double Probe_feature_Vectors[][41][2], int candidate_index[])
{
int i,j,k,m;
int MaxSimilarity_count[Total_train_face]={0};
double OveralSimilarity[Total_train_face]={0.0};
double temp_max_similarity=0.0;
double point_peak_similarity=0.0;
int max_similarity_index=0;
double similarity=0.0;
double similarity_matrix[500][Total_train_face]={0.0};
double temp_MaxSimilarity_count=0.0,temp_feature_count=0.0;
double thresh_distance=8.0;
double probe_xcoordiante;
double probe_ycoordiante;
double train_xcoordiante;
double train_ycoordiante;
double distance=0.0;
double last_similarity=0.0;
double dotproduct=0.0;
double train_feature_sqr=0.0;
double probe_feature_sqr=0.0;
int temp_index,real_index;
int new_candidate_index[Total_train_face];
double copy_OveralSimilarity[Total_train_face]={0.0};
double temp_OveralSimilarity;
double temp_Similarity;
double copy_Similarity[Total_train_face]={0.0};
double index_Similarity[Total_train_face]={0.0};
for (i=0;i<probe_feature_count;i++)
{
probe_xcoordiante=Probe_feature_Vectors[i][0][0];
probe_ycoordiante=Probe_feature_Vectors[i][0][1];
for (j=0;j<total_trainface;j++)
{
last_similarity=0.0;
for (k=0;k<train_feature_count[j];k++)
{
similarity=0.0;
train_xcoordiante=train_gabor_feature[j][k][0][0];
train_ycoordiante=train_gabor_feature[j][k][0][1];
distance=sqrt((train_xcoordiante-probe_xcoordiante)*(train_xcoordiante-probe_xcoordiante)+(train_ycoordiante-probe_ycoordiante)*(train_ycoordiante-probe_ycoordiante));
if (distance<=thresh_distance)
{
dotproduct=0.0;
train_feature_sqr=0.0;
probe_feature_sqr=0.0;
for (m=1;m<41;m++) //the first one is position information
{
dotproduct=dotproduct+sqrt(complex_modulus(train_gabor_feature[j][k][m]))*sqrt(complex_modulus(Probe_feature_Vectors[i][m]));
train_feature_sqr = train_feature_sqr + complex_modulus(train_gabor_feature[j][k][m]);
probe_feature_sqr = probe_feature_sqr + complex_modulus(Probe_feature_Vectors[i][m]);
}
similarity=dotproduct/sqrt(train_feature_sqr*probe_feature_sqr);
if (similarity>last_similarity)
{
similarity_matrix[i][j]=similarity;
last_similarity=similarity;
}
}
}
}
}
for (i=0;i<probe_feature_count;i++)
{
memcpy(copy_Similarity,similarity_matrix[i],total_trainface*sizeof(double));
memcpy(index_Similarity,similarity_matrix[i],total_trainface*sizeof(double));
for (j=total_trainface;j>total_trainface-1;j--)
{
temp_Similarity=randomized_selection(copy_Similarity,0,total_trainface-1,j-1);
temp_index=search_index(index_Similarity,total_trainface,temp_Similarity);
MaxSimilarity_count[temp_index]++;
}
}
for (i=0;i<total_trainface;i++)
{
temp_MaxSimilarity_count=MaxSimilarity_count[i];
temp_feature_count=train_feature_count[i];
OveralSimilarity[i]= temp_MaxSimilarity_count/temp_feature_count;
}
memcpy(copy_OveralSimilarity,OveralSimilarity,Total_train_face*sizeof(double));
for (i=total_trainface;i>0;i--) //Only find the active rankings
{
temp_OveralSimilarity=randomized_selection(copy_OveralSimilarity,0,total_trainface-1,i-1);
temp_index=search_index(OveralSimilarity,total_trainface,temp_OveralSimilarity);
real_index=candidate_index[temp_index];
new_candidate_index[total_trainface-i]=real_index;
}
memcpy(candidate_index,new_candidate_index,total_trainface*sizeof(int));
max_similarity_index=new_candidate_index[0]; //The first one is the index of the max
return max_similarity_index;
}
static void current_curve_basis_on_cusp(
Cusp *cusp,
MatrixInt22 basis_change)
{
int m_int,
l_int,
the_gcd;
long a,
b;
Complex new_shape;
int multiple;
int i,
j;
m_int = (int) cusp->m;
l_int = (int) cusp->l;
if (cusp->is_complete == FALSE /* cusp is filled and */
&& m_int == cusp->m /* coefficients are integers */
&& l_int == cusp->l)
{
/*
* Find a and b such that am + bl = gcd(m, l).
*/
the_gcd = euclidean_algorithm(m_int, l_int, &a, &b);
/*
* Divide through by the g.c.d.
*/
m_int /= the_gcd;
l_int /= the_gcd;
/*
* Set basis_change to
*
* m l
* -b a
*/
basis_change[0][0] = m_int;
basis_change[0][1] = l_int;
basis_change[1][0] = -b;
basis_change[1][1] = a;
/*
* Make sure the new longitude is as short as possible.
* The ratio (new longitude)/(new meridian) should have a
* real part in the interval (-1/2, +1/2].
*/
/*
* Compute the new_shape, using the tentative longitude.
*/
new_shape = transformed_cusp_shape( cusp->cusp_shape[initial],
basis_change);
/*
* 96/10/1 There is a danger that for nonhyperbolic solutions
* the cusp shape will be ill-defined (either very large or NaN).
* However for some nonhyperbolic solutions (flat solutions
* for example) it may make good sense. So we attempt to
* make the longitude short iff the new_shape is defined and
* not outrageously large; otherwise we're content with an
* arbitrary longitude.
*/
if (complex_modulus(new_shape) < BIG_MODULUS)
{
/*
* Figure out how many meridians we need to subtract
* from the longitude.
*/
multiple = (int) floor(new_shape.real - (-0.5 + EPSILON));
/*
* longitude -= multiple * meridian
*/
for (j = 0; j < 2; j++)
basis_change[1][j] -= multiple * basis_change[0][j];
}
}
else
{
/*
* Set basis_change to the identity.
*/
for (i = 0; i < 2; i++)
for (j = 0; j < 2; j++)
basis_change[i][j] = (i == j);
}
}
