void asef_initialze(AsefEyeLocator *asef, const char *file_name){
load_asef_filters(file_name, &asef->n_rows, &asef->n_cols, &asef->lrect,
&asef->rrect, &asef->lfilter, &asef->rfilter);
asef->lfilter_dft = cvCreateMat(asef->n_rows, asef->n_cols, CV_32FC1);
asef->rfilter_dft = cvCreateMat(asef->n_rows, asef->n_cols, CV_32FC1);
asef->image = cvCreateMat(asef->n_rows, asef->n_cols, CV_32FC1);
asef->image_tile = cvCreateMat(asef->n_rows, asef->n_cols, CV_8UC1);
asef->lcorr = cvCreateMat(asef->n_rows, asef->n_cols, CV_32FC1);
asef->rcorr = cvCreateMat(asef->n_rows, asef->n_cols, CV_32FC1);
asef->lroi = cvCreateMatHeader(asef->n_rows, asef->n_cols, CV_32FC1);
asef->rroi = cvCreateMatHeader(asef->n_rows, asef->n_cols, CV_32FC1);
cvDFT(asef->lfilter, asef->lfilter_dft, CV_DXT_FORWARD, 0);
cvDFT(asef->rfilter, asef->rfilter_dft, CV_DXT_FORWARD, 0);
cvGetSubRect(asef->lcorr, asef->lroi, asef->lrect);
cvGetSubRect(asef->rcorr, asef->rroi, asef->rrect);
asef->lut = cvCreateMat(256, 1, CV_32FC1);
for (int i = 0; i<256; i++){
cvmSet(asef->lut, i, 0, 1.0 + i);
}
cvLog(asef->lut, asef->lut);
}
void SSR(IplImage* src, int sigma, int scale)
{
IplImage* src_fl = cvCreateImage(cvGetSize(src), IPL_DEPTH_32F, src->nChannels);
IplImage* src_fl1 = cvCreateImage(cvGetSize(src), IPL_DEPTH_32F, src->nChannels);
IplImage* src_fl2 = cvCreateImage(cvGetSize(src), IPL_DEPTH_32F, src->nChannels);
float a = 0.0, b = 0.0, c = 0.0;
cvConvertScale(src, src_fl, 1.0, 1.0);//转换范围，所有图像元素增加1.0保证cvlog正常
cvLog(src_fl, src_fl1);
cvSmooth(src_fl, src_fl2, CV_GAUSSIAN, 0, 0, sigma); //SSR算法的核心之一，高斯模糊
cvLog(src_fl2, src_fl2);
cvSub(src_fl1, src_fl2, src_fl);//Retinex公式，Log(R(x,y))=Log(I(x,y))-Log(Gauss(I(x,y)))
//计算图像的均值、方差，SSR算法的核心之二
//使用GIMP中转换方法：使用图像的均值方差等信息进行变换
//没有添加溢出判断
CvScalar mean;
CvScalar dev;
cvAvgSdv(src_fl, &mean, &dev, NULL);//计算图像的均值和标准差
double min[3];
double max[3];
double maxmin[3];
for (int i = 0; i < 3; i++)
{
min[i] = mean.val[i] - scale*dev.val[i];
max[i] = mean.val[i] + scale*dev.val[i];
maxmin[i] = max[i] - min[i];
}
float* data2 = (float*)src_fl->imageData;
for (int i = 0; i < src_fl2->width; i++)
{
for (int j = 0; j < src_fl2->height; j++)
{
data2[j*src_fl->widthStep / 4 + 3 * i + 0] = 255 * (data2[j*src_fl->widthStep / 4 + 3 * i + 0] - min[0]) / maxmin[0];
data2[j*src_fl->widthStep / 4 + 3 * i + 1] = 255 * (data2[j*src_fl->widthStep / 4 + 3 * i + 1] - min[1]) / maxmin[1];
data2[j*src_fl->widthStep / 4 + 3 * i + 2] = 255 * (data2[j*src_fl->widthStep / 4 + 3 * i + 2] - min[2]) / maxmin[2];
}
}
cvConvertScale(src_fl, src, 1, 0);
cvReleaseImage(&src_fl);
cvReleaseImage(&src_fl1);
cvReleaseImage(&src_fl2);
}
int asef_initialze(AsefEyeLocator *asef, const char *asef_file_name, const char *fd_file_name){
if ( !asef || !asef_file_name || !fd_file_name ||
strlen(asef_file_name)==0 || strlen(fd_file_name)==0)
return -1;
// For face detection:
asef->face_detection_buffer = cvCreateMemStorage(0);
asef->face_detection_classifier = fd_load_detector( fd_file_name );
if ( !asef->face_detection_classifier )
return -1;
// For asef eye locator:
if ( load_asef_filters(asef_file_name, &asef->n_rows, &asef->n_cols, &asef->lrect,
&asef->rrect, &asef->lfilter, &asef->rfilter) )
return -1;
asef->lfilter_dft = cvCreateMat(asef->n_rows, asef->n_cols, CV_32FC1);
asef->rfilter_dft = cvCreateMat(asef->n_rows, asef->n_cols, CV_32FC1);
asef->scaled_face_image_32fc1 = cvCreateMat(asef->n_rows, asef->n_cols, CV_32FC1);
asef->scaled_face_image_8uc1 = cvCreateMat(asef->n_rows, asef->n_cols, CV_8UC1);
asef->lcorr = cvCreateMat(asef->n_rows, asef->n_cols, CV_32FC1);
asef->rcorr = cvCreateMat(asef->n_rows, asef->n_cols, CV_32FC1);
asef->lroi = cvCreateMatHeader(asef->n_rows, asef->n_cols, CV_32FC1);
asef->rroi = cvCreateMatHeader(asef->n_rows, asef->n_cols, CV_32FC1);
asef->lut = cvCreateMat(256, 1, CV_32FC1);
if ( !(asef->lfilter_dft && asef->rfilter_dft && asef->scaled_face_image_32fc1 &&
asef->scaled_face_image_8uc1 && asef->lcorr && asef->rcorr && asef->lroi &&
asef->rroi && asef->lut) ){
return -1;
}
cvDFT(asef->lfilter, asef->lfilter_dft, CV_DXT_FORWARD, 0);
cvDFT(asef->rfilter, asef->rfilter_dft, CV_DXT_FORWARD, 0);
cvGetSubRect(asef->lcorr, asef->lroi, asef->lrect);
cvGetSubRect(asef->rcorr, asef->rroi, asef->rrect);
for (int i = 0; i<256; i++){
cvmSet(asef->lut, i, 0, 1.0 + i);
}
cvLog(asef->lut, asef->lut);
return 0;
}
void cvShowInvDFT1(IplImage* im, CvMat* dft_A, int dft_M, int dft_N,char* src)
{
IplImage* realInput;
IplImage* imaginaryInput;
IplImage* complexInput;
IplImage * image_Re;
IplImage * image_Im;
double m, M;
char str[80];
realInput = cvCreateImage( cvGetSize(im), IPL_DEPTH_64F, 1);
imaginaryInput = cvCreateImage( cvGetSize(im), IPL_DEPTH_64F, 1);
complexInput = cvCreateImage( cvGetSize(im), IPL_DEPTH_64F, 2);
image_Re = cvCreateImage( cvSize(dft_N, dft_M), IPL_DEPTH_64F, 1);
image_Im = cvCreateImage( cvSize(dft_N, dft_M), IPL_DEPTH_64F, 1);
//cvDFT( dft_A, dft_A, CV_DXT_INV_SCALE, complexInput->height );
cvDFT( dft_A, dft_A, CV_DXT_INV_SCALE, dft_M);
strcpy(str,"DFT INVERSE - ");
strcat(str,src);
cvNamedWindow(str, 0);
// Split Fourier in real and imaginary parts
cvSplit( dft_A, image_Re, image_Im, 0, 0 );
// Compute the magnitude of the spectrum Mag = sqrt(Re^2 + Im^2)
cvPow( image_Re, image_Re, 2.0);
cvPow( image_Im, image_Im, 2.0);
cvAdd( image_Re, image_Im, image_Re, NULL);
cvPow( image_Re, image_Re, 0.5 );
// Compute log(1 + Mag)
cvAddS( image_Re, cvScalarAll(1.0), image_Re, NULL ); // 1 + Mag
cvLog( image_Re, image_Re ); // log(1 + Mag)
cvMinMaxLoc(image_Re, &m, &M, NULL, NULL, NULL);
cvScale(image_Re, image_Re, 1.0/(M-m), 1.0*(-m)/(M-m));
//cvCvtColor(image_Re, image_Re, CV_GRAY2RGBA);
cvShowImage(str, image_Re);
}
int ASEF_Algorithm::initialize() {
if (load_asef_filters(haar_cascade_path, &n_rows, &n_cols, &lrect,
&rrect, &lfilter, &rfilter))
return -1;
lfilter_dft = cvCreateMat(n_rows, n_cols, CV_32FC1);
rfilter_dft = cvCreateMat(n_rows, n_cols, CV_32FC1);
scaled_face_image_32fc1 = cvCreateMat(n_rows, n_cols, CV_32FC1);
scaled_face_image_8uc1 = cvCreateMat(n_rows, n_cols, CV_8UC1);
lcorr = cvCreateMat(n_rows, n_cols, CV_32FC1);
rcorr = cvCreateMat(n_rows, n_cols, CV_32FC1);
lroi = cvCreateMatHeader(n_rows, n_cols, CV_32FC1);
rroi = cvCreateMatHeader(n_rows, n_cols, CV_32FC1);
lut = cvCreateMat(256, 1, CV_32FC1);
point = cvCreateMat(1, 2, CV_32FC1);
if (!(lfilter_dft && rfilter_dft && scaled_face_image_32fc1 &&
scaled_face_image_8uc1 && lcorr && rcorr && lroi &&
rroi && lut)) {
return -1;
}
cvDFT(lfilter, lfilter_dft, CV_DXT_FORWARD, 0);
cvDFT(rfilter, rfilter_dft, CV_DXT_FORWARD, 0);
cvGetSubRect(lcorr, lroi, lrect);
cvGetSubRect(rcorr, rroi, rrect);
for (int i = 0; i < 256; i++) {
cvmSet(lut, i, 0, 1.0 + i);
}
cvLog(lut, lut);
isInitialized = true;
return 0;
}
void LogDCT()
{
allocateImages();
if(!cvIm32F) {
cvIm32Fin = cvCreateImage(cvGetSize(cvImGray), IPL_DEPTH_32F, 1);
cvIm32F = cvCreateImage(cvGetSize(cvImGray), IPL_DEPTH_32F, 1);
cvImDCT = cvCreateImage(cvGetSize(cvImGray), IPL_DEPTH_32F, 1);
}
cvConvertScale(cvImGray, cvIm32Fin);
// cvConvertScale(cvImGray, cvIm32F);
cvLog(cvIm32Fin, cvIm32F);
cvDCT(cvIm32F, cvImDCT, CV_DXT_FORWARD);
/* OUTPUTS
*
char * LogDCT_outputnames_list[] = {
"LogDCT",
"Log DCT Cropped",
"Log DCT Inv",
"DCT Inv",
"Final"};
*/
if(LogDCT_output.curitem == 0) // "LogDCT"
{
cvConvertScale(cvImDCT, cvImGray, 100.);
}
// Reduce low DCT
float rad = (float)LogDCT_radius / 100.f;
for(int r = 0; r<cvImDCT->height; r++)
{
float fr = (float)r / (float)cvImDCT->height;
float * line = (float *)(cvImDCT->imageData + r*cvImDCT->widthStep);
for(int c = 0; c<cvImDCT->width; c++)
{
float fc = (float)c / (float)cvImDCT->width;
// float dc = fc*fc;
// float dr = fr*fr;
if(fc > rad || fr > rad)
{
line[c] = 0;
}
}
}
if(LogDCT_output.curitem == 1) // "Log DCT Cropped"
{
cvConvertScale(cvImDCT, cvImGray, 100.);
}
cvDCT(cvImDCT, cvIm32F, CV_DXT_INVERSE);
if(LogDCT_output.curitem == 2) // "LogDCT Inv"
{
cvConvertScale(cvIm32F, cvImGray, 1.);
}
cvExp(cvIm32F, cvImDCT);
//cvConvertScale(cvImDCT, cvImGray, 1.);
//cvConvertScale(cvIm32F, cvImGray, 1.);
cvConvertScale(cvImDCT, cvImDCT, LogDCT_coef);
if(LogDCT_output.curitem == 3) // "DCT Inv"
{
cvConvertScale(cvImDCT, cvImGray, 1.);
}
// Substract low pass image from input image
cvSub(cvIm32Fin, cvImDCT, cvIm32F);
if(LogDCT_output.curitem == 4) // "DCT Inv - scal"
{
cvConvertScale(cvIm32F, cvImGray, 1.);
}
//cvConvertScale(cvImDCT, cvImGray, 1.);
cvAddS(cvIm32F, cvScalarAll(LogDCT_add), cvImDCT);
if(LogDCT_output.curitem == 5) // "Out"
{
cvConvertScale(cvImDCT, cvImGray, 1.);
}
finishImages();
}
/* log_weight_div_det[k] = -2*log(weights_k) + log(det(Sigma_k)))
covs[k] = cov_rotate_mats[k] * cov_eigen_values[k] * (cov_rotate_mats[k])'
cov_rotate_mats[k] are orthogonal matrices of eigenvectors and
cov_eigen_values[k] are diagonal matrices (represented by 1D vectors) of eigen values.
The <alpha_ik> is the probability of the vector x_i to belong to the k-th cluster:
<alpha_ik> ~ weights_k * exp{ -0.5[ln(det(Sigma_k)) + (x_i - mu_k)' Sigma_k^(-1) (x_i - mu_k)] }
We calculate these probabilities here by the equivalent formulae:
Denote
S_ik = -0.5(log(det(Sigma_k)) + (x_i - mu_k)' Sigma_k^(-1) (x_i - mu_k)) + log(weights_k),
M_i = max_k S_ik = S_qi, so that the q-th class is the one where maximum reaches. Then
alpha_ik = exp{ S_ik - M_i } / ( 1 + sum_j!=q exp{ S_ji - M_i })
*/
double CvEM::run_em( const CvVectors& train_data )
{
CvMat* centered_sample = 0;
CvMat* covs_item = 0;
CvMat* log_det = 0;
CvMat* log_weights = 0;
CvMat* cov_eigen_values = 0;
CvMat* samples = 0;
CvMat* sum_probs = 0;
log_likelihood = -DBL_MAX;
CV_FUNCNAME( "CvEM::run_em" );
__BEGIN__;
int nsamples = train_data.count, dims = train_data.dims, nclusters = params.nclusters;
double min_variation = FLT_EPSILON;
double min_det_value = MAX( DBL_MIN, pow( min_variation, dims ));
double likelihood_bias = -CV_LOG2PI * (double)nsamples * (double)dims / 2., _log_likelihood = -DBL_MAX;
int start_step = params.start_step;
int i, j, k, n;
int is_general = 0, is_diagonal = 0, is_spherical = 0;
double prev_log_likelihood = -DBL_MAX / 1000., det, d;
CvMat whdr, iwhdr, diag, *w, *iw;
double* w_data;
double* sp_data;
if( nclusters == 1 )
{
double log_weight;
CV_CALL( cvSet( probs, cvScalar(1.)) );
if( params.cov_mat_type == COV_MAT_SPHERICAL )
{
d = cvTrace(*covs).val[0]/dims;
d = MAX( d, FLT_EPSILON );
inv_eigen_values->data.db[0] = 1./d;
log_weight = pow( d, dims*0.5 );
}
else
{
w_data = inv_eigen_values->data.db;
if( params.cov_mat_type == COV_MAT_GENERIC )
cvSVD( *covs, inv_eigen_values, *cov_rotate_mats, 0, CV_SVD_U_T );
else
cvTranspose( cvGetDiag(*covs, &diag), inv_eigen_values );
cvMaxS( inv_eigen_values, FLT_EPSILON, inv_eigen_values );
for( j = 0, det = 1.; j < dims; j++ )
det *= w_data[j];
log_weight = sqrt(det);
cvDiv( 0, inv_eigen_values, inv_eigen_values );
}
log_weight_div_det->data.db[0] = -2*log(weights->data.db[0]/log_weight);
log_likelihood = DBL_MAX/1000.;
EXIT;
}
if( params.cov_mat_type == COV_MAT_GENERIC )
is_general = 1;
else if( params.cov_mat_type == COV_MAT_DIAGONAL )
is_diagonal = 1;
else if( params.cov_mat_type == COV_MAT_SPHERICAL )
is_spherical = 1;
/* In the case of <cov_mat_type> == COV_MAT_DIAGONAL, the k-th row of cov_eigen_values
contains the diagonal elements (variations). In the case of
<cov_mat_type> == COV_MAT_SPHERICAL - the 0-ths elements of the vectors cov_eigen_values[k]
are to be equal to the mean of the variations over all the dimensions. */
CV_CALL( log_det = cvCreateMat( 1, nclusters, CV_64FC1 ));
CV_CALL( log_weights = cvCreateMat( 1, nclusters, CV_64FC1 ));
CV_CALL( covs_item = cvCreateMat( dims, dims, CV_64FC1 ));
CV_CALL( centered_sample = cvCreateMat( 1, dims, CV_64FC1 ));
CV_CALL( cov_eigen_values = cvCreateMat( inv_eigen_values->rows, inv_eigen_values->cols, CV_64FC1 ));
CV_CALL( samples = cvCreateMat( nsamples, dims, CV_64FC1 ));
CV_CALL( sum_probs = cvCreateMat( 1, nclusters, CV_64FC1 ));
sp_data = sum_probs->data.db;
// copy the training data into double-precision matrix
for( i = 0; i < nsamples; i++ )
{
const float* src = train_data.data.fl[i];
double* dst = (double*)(samples->data.ptr + samples->step*i);
for( j = 0; j < dims; j++ )
dst[j] = src[j];
}
if( start_step != START_M_STEP )
{
for( k = 0; k < nclusters; k++ )
{
if( is_general || is_diagonal )
{
w = cvGetRow( cov_eigen_values, &whdr, k );
if( is_general )
cvSVD( covs[k], w, cov_rotate_mats[k], 0, CV_SVD_U_T );
else
cvTranspose( cvGetDiag( covs[k], &diag ), w );
w_data = w->data.db;
for( j = 0, det = 1.; j < dims; j++ )
det *= w_data[j];
if( det < min_det_value )
{
if( start_step == START_AUTO_STEP )
det = min_det_value;
else
EXIT;
}
log_det->data.db[k] = det;
}
else
{
d = cvTrace(covs[k]).val[0]/(double)dims;
if( d < min_variation )
{
if( start_step == START_AUTO_STEP )
d = min_variation;
else
EXIT;
}
cov_eigen_values->data.db[k] = d;
log_det->data.db[k] = d;
}
}
cvLog( log_det, log_det );
if( is_spherical )
cvScale( log_det, log_det, dims );
}
for( n = 0; n < params.term_crit.max_iter; n++ )
{
if( n > 0 || start_step != START_M_STEP )
{
// e-step: compute probs_ik from means_k, covs_k and weights_k.
CV_CALL(cvLog( weights, log_weights ));
// S_ik = -0.5[log(det(Sigma_k)) + (x_i - mu_k)' Sigma_k^(-1) (x_i - mu_k)] + log(weights_k)
for( k = 0; k < nclusters; k++ )
{
CvMat* u = cov_rotate_mats[k];
const double* mean = (double*)(means->data.ptr + means->step*k);
w = cvGetRow( cov_eigen_values, &whdr, k );
iw = cvGetRow( inv_eigen_values, &iwhdr, k );
cvDiv( 0, w, iw );
w_data = (double*)(inv_eigen_values->data.ptr + inv_eigen_values->step*k);
for( i = 0; i < nsamples; i++ )
{
double *csample = centered_sample->data.db, p = log_det->data.db[k];
const double* sample = (double*)(samples->data.ptr + samples->step*i);
double* pp = (double*)(probs->data.ptr + probs->step*i);
for( j = 0; j < dims; j++ )
csample[j] = sample[j] - mean[j];
if( is_general )
cvGEMM( centered_sample, u, 1, 0, 0, centered_sample, CV_GEMM_B_T );
for( j = 0; j < dims; j++ )
p += csample[j]*csample[j]*w_data[is_spherical ? 0 : j];
pp[k] = -0.5*p + log_weights->data.db[k];
// S_ik <- S_ik - max_j S_ij
if( k == nclusters - 1 )
{
double max_val = 0;
for( j = 0; j < nclusters; j++ )
max_val = MAX( max_val, pp[j] );
for( j = 0; j < nclusters; j++ )
pp[j] -= max_val;
}
}
}
CV_CALL(cvExp( probs, probs )); // exp( S_ik )
cvZero( sum_probs );
// alpha_ik = exp( S_ik ) / sum_j exp( S_ij ),
// log_likelihood = sum_i log (sum_j exp(S_ij))
for( i = 0, _log_likelihood = likelihood_bias; i < nsamples; i++ )
{
double* pp = (double*)(probs->data.ptr + probs->step*i), sum = 0;
for( j = 0; j < nclusters; j++ )
sum += pp[j];
sum = 1./MAX( sum, DBL_EPSILON );
for( j = 0; j < nclusters; j++ )
{
double p = pp[j] *= sum;
sp_data[j] += p;
}
_log_likelihood -= log( sum );
}
// check termination criteria
if( fabs( (_log_likelihood - prev_log_likelihood) / prev_log_likelihood ) < params.term_crit.epsilon )
break;
prev_log_likelihood = _log_likelihood;
}
// m-step: update means_k, covs_k and weights_k from probs_ik
cvGEMM( probs, samples, 1, 0, 0, means, CV_GEMM_A_T );
for( k = 0; k < nclusters; k++ )
{
double sum = sp_data[k], inv_sum = 1./sum;
CvMat* cov = covs[k], _mean, _sample;
w = cvGetRow( cov_eigen_values, &whdr, k );
w_data = w->data.db;
cvGetRow( means, &_mean, k );
cvGetRow( samples, &_sample, k );
// update weights_k
weights->data.db[k] = sum;
// update means_k
cvScale( &_mean, &_mean, inv_sum );
// compute covs_k
cvZero( cov );
cvZero( w );
for( i = 0; i < nsamples; i++ )
{
double p = probs->data.db[i*nclusters + k]*inv_sum;
_sample.data.db = (double*)(samples->data.ptr + samples->step*i);
if( is_general )
{
cvMulTransposed( &_sample, covs_item, 1, &_mean );
cvScaleAdd( covs_item, cvRealScalar(p), cov, cov );
}
else
for( j = 0; j < dims; j++ )
{
double val = _sample.data.db[j] - _mean.data.db[j];
w_data[is_spherical ? 0 : j] += p*val*val;
}
}
if( is_spherical )
{
d = w_data[0]/(double)dims;
d = MAX( d, min_variation );
w->data.db[0] = d;
log_det->data.db[k] = d;
}
else
{
if( is_general )
cvSVD( cov, w, cov_rotate_mats[k], 0, CV_SVD_U_T );
cvMaxS( w, min_variation, w );
for( j = 0, det = 1.; j < dims; j++ )
det *= w_data[j];
log_det->data.db[k] = det;
}
}
cvConvertScale( weights, weights, 1./(double)nsamples, 0 );
cvMaxS( weights, DBL_MIN, weights );
cvLog( log_det, log_det );
if( is_spherical )
cvScale( log_det, log_det, dims );
} // end of iteration process
//log_weight_div_det[k] = -2*log(weights_k/det(Sigma_k))^0.5) = -2*log(weights_k) + log(det(Sigma_k)))
if( log_weight_div_det )
{
cvScale( log_weights, log_weight_div_det, -2 );
cvAdd( log_weight_div_det, log_det, log_weight_div_det );
}
/* Now finalize all the covariation matrices:
1) if <cov_mat_type> == COV_MAT_DIAGONAL we used array of <w> as diagonals.
Now w[k] should be copied back to the diagonals of covs[k];
2) if <cov_mat_type> == COV_MAT_SPHERICAL we used the 0-th element of w[k]
as an average variation in each cluster. The value of the 0-th element of w[k]
should be copied to the all of the diagonal elements of covs[k]. */
if( is_spherical )
{
for( k = 0; k < nclusters; k++ )
cvSetIdentity( covs[k], cvScalar(cov_eigen_values->data.db[k]));
}
else if( is_diagonal )
{
for( k = 0; k < nclusters; k++ )
cvTranspose( cvGetRow( cov_eigen_values, &whdr, k ),
cvGetDiag( covs[k], &diag ));
}
cvDiv( 0, cov_eigen_values, inv_eigen_values );
log_likelihood = _log_likelihood;
__END__;
cvReleaseMat( &log_det );
cvReleaseMat( &log_weights );
cvReleaseMat( &covs_item );
cvReleaseMat( ¢ered_sample );
cvReleaseMat( &cov_eigen_values );
cvReleaseMat( &samples );
cvReleaseMat( &sum_probs );
return log_likelihood;
}
CvMat* cvShowDFT1(IplImage* im, int dft_M, int dft_N,char* src)
{
IplImage* realInput;
IplImage* imaginaryInput;
IplImage* complexInput;
CvMat* dft_A, tmp;
IplImage* image_Re;
IplImage* image_Im;
char str[80];
double m, M;
realInput = cvCreateImage( cvGetSize(im), IPL_DEPTH_64F, 1);
imaginaryInput = cvCreateImage( cvGetSize(im), IPL_DEPTH_64F, 1);
complexInput = cvCreateImage( cvGetSize(im), IPL_DEPTH_64F, 2);
cvScale(im, realInput, 1.0, 0.0);
cvZero(imaginaryInput);
cvMerge(realInput, imaginaryInput, NULL, NULL, complexInput);
dft_A = cvCreateMat( dft_M, dft_N, CV_64FC2 );
image_Re = cvCreateImage( cvSize(dft_N, dft_M), IPL_DEPTH_64F, 1);
image_Im = cvCreateImage( cvSize(dft_N, dft_M), IPL_DEPTH_64F, 1);
// copy A to dft_A and pad dft_A with zeros
cvGetSubRect( dft_A, &tmp, cvRect(0,0, im->width, im->height));
cvCopy( complexInput, &tmp, NULL );
if( dft_A->cols > im->width )
{
cvGetSubRect( dft_A, &tmp, cvRect(im->width,0, dft_A->cols - im->width, im->height));
cvZero( &tmp );
}
// no need to pad bottom part of dft_A with zeros because of
// use nonzero_rows parameter in cvDFT() call below
cvDFT( dft_A, dft_A, CV_DXT_FORWARD, complexInput->height );
strcpy(str,"DFT -");
strcat(str,src);
cvNamedWindow(str, 0);
// Split Fourier in real and imaginary parts
cvSplit( dft_A, image_Re, image_Im, 0, 0 );
// Compute the magnitude of the spectrum Mag = sqrt(Re^2 + Im^2)
cvPow( image_Re, image_Re, 2.0);
cvPow( image_Im, image_Im, 2.0);
cvAdd( image_Re, image_Im, image_Re, NULL);
cvPow( image_Re, image_Re, 0.5 );
// Compute log(1 + Mag)
cvAddS( image_Re, cvScalarAll(1.0), image_Re, NULL ); // 1 + Mag
cvLog( image_Re, image_Re ); // log(1 + Mag)
cvMinMaxLoc(image_Re, &m, &M, NULL, NULL, NULL);
cvScale(image_Re, image_Re, 1.0/(M-m), 1.0*(-m)/(M-m));
cvShowImage(str, image_Re);
return(dft_A);
}
int main(int argc, char ** argv)
{
const char* filename = argc >=2 ? argv[1] : "lena.jpg";
IplImage * im;
IplImage * realInput;
IplImage * imaginaryInput;
IplImage * complexInput;
int dft_M, dft_N;
CvMat* dft_A, tmp;
IplImage * image_Re;
IplImage * image_Im;
double m, M;
im = cvLoadImage( filename, CV_LOAD_IMAGE_GRAYSCALE );
if( !im )
return -1;
realInput = cvCreateImage( cvGetSize(im), IPL_DEPTH_64F, 1);
imaginaryInput = cvCreateImage( cvGetSize(im), IPL_DEPTH_64F, 1);
complexInput = cvCreateImage( cvGetSize(im), IPL_DEPTH_64F, 2);
cvScale(im, realInput, 1.0, 0.0);
cvZero(imaginaryInput);
cvMerge(realInput, imaginaryInput, NULL, NULL, complexInput);
dft_M = cvGetOptimalDFTSize( im->height - 1 );
dft_N = cvGetOptimalDFTSize( im->width - 1 );
dft_A = cvCreateMat( dft_M, dft_N, CV_64FC2 );
image_Re = cvCreateImage( cvSize(dft_N, dft_M), IPL_DEPTH_64F, 1);
image_Im = cvCreateImage( cvSize(dft_N, dft_M), IPL_DEPTH_64F, 1);
// copy A to dft_A and pad dft_A with zeros
cvGetSubRect( dft_A, &tmp, cvRect(0,0, im->width, im->height));
cvCopy( complexInput, &tmp, NULL );
if( dft_A->cols > im->width )
{
cvGetSubRect( dft_A, &tmp, cvRect(im->width,0, dft_A->cols - im->width, im->height));
cvZero( &tmp );
}
// no need to pad bottom part of dft_A with zeros because of
// use nonzero_rows parameter in cvDFT() call below
cvDFT( dft_A, dft_A, CV_DXT_FORWARD, complexInput->height );
cvNamedWindow("win", 0);
cvNamedWindow("magnitude", 0);
cvShowImage("win", im);
// Split Fourier in real and imaginary parts
cvSplit( dft_A, image_Re, image_Im, 0, 0 );
// Compute the magnitude of the spectrum Mag = sqrt(Re^2 + Im^2)
cvPow( image_Re, image_Re, 2.0);
cvPow( image_Im, image_Im, 2.0);
cvAdd( image_Re, image_Im, image_Re, NULL);
cvPow( image_Re, image_Re, 0.5 );
// Compute log(1 + Mag)
cvAddS( image_Re, cvScalarAll(1.0), image_Re, NULL ); // 1 + Mag
cvLog( image_Re, image_Re ); // log(1 + Mag)
// Rearrange the quadrants of Fourier image so that the origin is at
// the image center
cvShiftDFT( image_Re, image_Re );
cvMinMaxLoc(image_Re, &m, &M, NULL, NULL, NULL);
cvScale(image_Re, image_Re, 1.0/(M-m), 1.0*(-m)/(M-m));
cvShowImage("magnitude", image_Re);
cvWaitKey(-1);
return 0;
}
void prefilt(const IplImage* img,IplImage* prefedImg,int pad,IplImage* filter2D)
{
int imagesize=img->height;
int padImgSize=imagesize+2*pad;
IplImage* temp1=cvCreateImage(cvSize(imagesize,imagesize),IPL_DEPTH_32F,3);
/*put 8 bits image into 32 bits float image*/
cvConvertScale(img,temp1,1,1);
int i;
//use ptr to get access to data blocks/pixels,each block/pixel has three float numbers
IplImage* temp2=cvCreateImage(cvSize(imagesize,imagesize),IPL_DEPTH_32F,3);
float* ptr=NULL;
cvLog(temp1,temp2);
cvReleaseImage(&temp1);
/*pad the image to reduce boundary artifacts*/
IplImage* temp5=cvCreateImage(cvSize(padImgSize,padImgSize),IPL_DEPTH_32F,3);
IplImage* pad1=cvCreateImage(cvSize(imagesize,imagesize),IPL_DEPTH_32F,1);
IplImage* pad2=cvCreateImage(cvSize(imagesize,imagesize),IPL_DEPTH_32F,1);
IplImage* pad3=cvCreateImage(cvSize(imagesize,imagesize),IPL_DEPTH_32F,1);
cvSplit(temp2,pad1,pad2,pad3,NULL);
IplImage* C1=cvCreateImage(cvSize(padImgSize,padImgSize),IPL_DEPTH_32F,1);
IplImage* C2=cvCreateImage(cvSize(padImgSize,padImgSize),IPL_DEPTH_32F,1);
IplImage* C3=cvCreateImage(cvSize(padImgSize,padImgSize),IPL_DEPTH_32F,1);
padarraySym(pad1,C1,pad);/* pad each channel */
padarraySym(pad2,C2,pad);
padarraySym(pad3,C3,pad);
cvMerge(C1,C2,C3,NULL,temp5);
cvReleaseImage(&pad1);
cvReleaseImage(&pad2);
cvReleaseImage(&pad3);
cvReleaseImage(&C1);
cvReleaseImage(&C2);
cvReleaseImage(&C3);
/* FFT */
/* split 3-channel image to single channel images */
IplImage* splitImgs[3];
IplImage* dftOutput[3];
IplImage* splitImgsC2[3];
for(i=0;i<3;i++)
{
splitImgs[i]=cvCreateImage(cvSize(padImgSize,padImgSize),IPL_DEPTH_32F,1);
splitImgsC2[i]=cvCreateImage(cvSize(padImgSize,padImgSize),IPL_DEPTH_32F,2);
dftOutput[i]=cvCreateImage(cvSize(padImgSize,padImgSize),IPL_DEPTH_32F,2);
cvSetZero(splitImgs[i]);
cvSetZero(splitImgsC2[i]);
cvSetZero(dftOutput[i]);
}
cvSplit(temp5,splitImgs[0],splitImgs[1],splitImgs[2],NULL);
IplImage* mergSrc=cvCreateImage(cvSize(padImgSize,padImgSize),IPL_DEPTH_32F,1);
cvSetZero(mergSrc);
/* merge to double channel images for input of FFT */
for(i=0;i<3;i++)
{
cvMerge(splitImgs[i],mergSrc,NULL,NULL,splitImgsC2[i]);
cvReleaseImage(&splitImgs[i]);
}
/* FFT */
for(i=0;i<3;i++)
{
cvDFT(splitImgsC2[i],dftOutput[i],CV_DXT_FORWARD);
cvReleaseImage(&splitImgsC2[i]);
}
/* apply prefilt to three channels */
IplImage* output_temp[3];
IplImage* outputReal[3];
IplImage* outputImaginary[3];
IplImage* ifftOutput[3];
float temp=0;
int j=0;
float* ptr1=NULL;
for(i=0;i<3;i++)
{
output_temp[i]=cvCreateImage(cvSize(padImgSize,padImgSize),IPL_DEPTH_32F,2);
cvSetZero(output_temp[i]);
cvMul(filter2D,dftOutput[i],output_temp[i]);
cvReleaseImage(&dftOutput[i]);
outputReal[i]=cvCreateImage(cvSize(padImgSize,padImgSize),IPL_DEPTH_32F,1);
cvSetZero(outputReal[i]);
outputImaginary[i]=cvCreateImage(cvSize(padImgSize,padImgSize),IPL_DEPTH_32F,1);
cvSetZero(outputImaginary[i]);
ifftOutput[i]=cvCreateImage(cvSize(padImgSize,padImgSize),IPL_DEPTH_32F,2);
cvSetZero(ifftOutput[i]);
cvDFT(output_temp[i],ifftOutput[i],CV_DXT_INVERSE_SCALE);
cvSplit(ifftOutput[i],outputReal[i],outputImaginary[i],NULL,NULL);
cvReleaseImage(&outputImaginary[i]);
cvReleaseImage(&ifftOutput[i]);
}
/* merge real parts to a 3-channel image */
IplImage* temp3=cvCreateImage(cvSize(padImgSize,padImgSize),IPL_DEPTH_32F,3);
cvMerge(outputReal[0],outputReal[1],outputReal[2],NULL,temp3);
cvReleaseImage(&outputReal[0]);
cvReleaseImage(&outputReal[1]);
cvReleaseImage(&outputReal[2]);
IplImage* prefiltOutput=cvCreateImage(cvSize(padImgSize,padImgSize),IPL_DEPTH_32F,3);
cvSub(temp5,temp3,prefiltOutput);
cvReleaseImage(&temp3);
cvReleaseImage(&temp5);
/* local contrast normalization */
/* mean of values in different channels of each pixel */
IplImage* mean=cvCreateImage(cvSize(padImgSize,padImgSize),IPL_DEPTH_32F,1);
IplImage* mean2D=cvCreateImage(cvSize(padImgSize,padImgSize),IPL_DEPTH_32F,2);
ptr=(float*) mean->imageData;
ptr1=(float*) prefiltOutput->imageData;
for(i=0;i<(padImgSize)*(padImgSize)*3;i++)
{
if((i+1)%3==0)
{
temp=(*(ptr1+i)+*(ptr1+i-1)+*(ptr1+i-2))/3;
*(ptr+(i+1)/3-1)=temp*temp;
}
}
/* FFT */
IplImage* fftRes=cvCreateImage(cvSize(padImgSize,padImgSize),IPL_DEPTH_32F,2);
cvMerge(mean,mergSrc,NULL,NULL,mean2D);
cvReleaseImage(&mergSrc);
cvDFT(mean2D,fftRes,CV_DXT_FORWARD);
cvReleaseImage(&mean);
IplImage* temp4=cvCreateImage(cvSize(padImgSize,padImgSize),IPL_DEPTH_32F,2);
cvMul(filter2D,fftRes,temp4);
/* Inverse FFT */
IplImage* ifftRes=cvCreateImage(cvSize(padImgSize,padImgSize),IPL_DEPTH_32F,2);
IplImage* lccstTemp=cvCreateImage(cvSize(padImgSize,padImgSize),IPL_DEPTH_32F,1);
ptr1=(float*) lccstTemp->imageData;
cvFFT(temp4,ifftRes,CV_DXT_INVERSE_SCALE);
/* caculate the abs of complex number matrix */
ptr=(float*)ifftRes->imageData;
float realV=0;
float imgV=0;
for(i=0;i<(padImgSize)*(padImgSize);i++)
{
realV=*(ptr+2*i);
imgV=*(ptr+2*i+1);
*(ptr1+i)=sqrt(sqrt(realV*realV+fabs(imgV*imgV)))+0.2;
}
IplImage* lccst=cvCreateImage(cvSize(padImgSize,padImgSize),IPL_DEPTH_32F,3);
cvMerge(lccstTemp,lccstTemp,lccstTemp,NULL,lccst);
IplImage* outputTemp=cvCreateImage(cvSize(padImgSize,padImgSize),IPL_DEPTH_32F,3);
cvDiv(prefiltOutput,lccst,outputTemp);
cvReleaseImage(&mean2D);
cvReleaseImage(&fftRes);
cvReleaseImage(&ifftRes);
cvReleaseImage(&lccstTemp);
cvReleaseImage(&lccst);
cvReleaseImage(&prefiltOutput);
cvReleaseImage(&temp2);
cvReleaseImage(&temp4);
cvReleaseImage(&output_temp[0]);
cvReleaseImage(&output_temp[1]);
cvReleaseImage(&output_temp[2]);
IplImage* temp6 = cvGetSubImage(outputTemp,cvRect(pad,pad,imagesize,imagesize));
cvCopy(temp6,prefedImg);
cvReleaseImage(&outputTemp);
cvReleaseImage(&temp6);
}
IplImage*
ComputeSaliency(IplImage* image, int thresh, int scale) {
//given a one channel image
unsigned int size = floor(pow(2,scale)); //the size to do teh saliency @
IplImage* bw_im = cvCreateImage(cvSize(size,size),
IPL_DEPTH_8U,1);
cvResize(image, bw_im);
IplImage* realInput = cvCreateImage( cvGetSize(bw_im), IPL_DEPTH_32F, 1);
IplImage* imaginaryInput = cvCreateImage( cvGetSize(bw_im), IPL_DEPTH_32F, 1);
IplImage* complexInput = cvCreateImage( cvGetSize(bw_im), IPL_DEPTH_32F, 2);
cvScale(bw_im, realInput, 1.0/255.0);
cvZero(imaginaryInput);
cvMerge(realInput, imaginaryInput, NULL, NULL, complexInput);
CvMat* dft_A = cvCreateMat( size, size, CV_32FC2 );
// copy A to dft_A and pad dft_A with zeros
CvMat tmp;
cvGetSubRect( dft_A, &tmp, cvRect(0,0, size,size));
cvCopy( complexInput, &tmp );
// cvZero(&tmp);
cvDFT( dft_A, dft_A, CV_DXT_FORWARD, size );
cvSplit( dft_A, realInput, imaginaryInput, NULL, NULL );
// Compute the phase angle
IplImage* image_Mag = cvCreateImage(cvSize(size, size), IPL_DEPTH_32F, 1);
IplImage* image_Phase = cvCreateImage(cvSize(size, size), IPL_DEPTH_32F, 1);
//compute the phase of the spectrum
cvCartToPolar(realInput, imaginaryInput, image_Mag, image_Phase, 0);
IplImage* log_mag = cvCreateImage(cvSize(size, size), IPL_DEPTH_32F, 1);
cvLog(image_Mag, log_mag);
//Box filter the magnitude, then take the difference
IplImage* log_mag_Filt = cvCreateImage(cvSize(size, size),
IPL_DEPTH_32F, 1);
CvMat* filt = cvCreateMat(3,3, CV_32FC1);
cvSet(filt,cvScalarAll(1.0/9.0));
cvFilter2D(log_mag, log_mag_Filt, filt);
cvReleaseMat(&filt);
cvSub(log_mag, log_mag_Filt, log_mag);
cvExp(log_mag, image_Mag);
cvPolarToCart(image_Mag, image_Phase, realInput, imaginaryInput,0);
cvExp(log_mag, image_Mag);
cvMerge(realInput, imaginaryInput, NULL, NULL, dft_A);
cvDFT( dft_A, dft_A, CV_DXT_INV_SCALE, size);
cvAbs(dft_A, dft_A);
cvMul(dft_A,dft_A, dft_A);
cvGetSubRect( dft_A, &tmp, cvRect(0,0, size,size));
cvCopy( &tmp, complexInput);
cvSplit(complexInput, realInput, imaginaryInput, NULL,NULL);
IplImage* result_image = cvCreateImage(cvGetSize(image),IPL_DEPTH_32F, 1);
double minv, maxv;
CvPoint minl, maxl;
cvSmooth(realInput,realInput);
cvSmooth(realInput,realInput);
cvMinMaxLoc(realInput,&minv,&maxv,&minl,&maxl);
printf("Max value %lf, min %lf\n", maxv,minv);
cvScale(realInput, realInput, 1.0/(maxv-minv), 1.0*(-minv)/(maxv-minv));
cvResize(realInput, result_image);
double threshold = thresh/100.0*cvAvg(realInput).val[0];
cvThreshold(result_image, result_image, threshold, 1.0, CV_THRESH_BINARY);
IplImage* final_result = cvCreateImage(cvGetSize(image),IPL_DEPTH_8U, 1);
cvScale(result_image, final_result, 255.0, 0.0);
cvReleaseImage(&result_image);
//cvReleaseImage(&realInput);
cvReleaseImage(&imaginaryInput);
cvReleaseImage(&complexInput);
cvReleaseMat(&dft_A);
cvReleaseImage(&bw_im);
cvReleaseImage(&image_Mag);
cvReleaseImage(&image_Phase);
cvReleaseImage(&log_mag);
cvReleaseImage(&log_mag_Filt);
cvReleaseImage(&bw_im);
return final_result;
//return bw_im;
}
IplImage*
create_fourier_image(const IplImage *im)
{
IplImage *realInput;
IplImage *imaginaryInput;
IplImage *complexInput;
int dft_M, dft_N;
CvMat *dft_A, tmp;
IplImage *image_Re;
IplImage *image_Im;
realInput = rb_cvCreateImage( cvGetSize(im), IPL_DEPTH_64F, 1);
imaginaryInput = rb_cvCreateImage( cvGetSize(im), IPL_DEPTH_64F, 1);
complexInput = rb_cvCreateImage( cvGetSize(im), IPL_DEPTH_64F, 2);
cvScale(im, realInput, 1.0, 0.0);
cvZero(imaginaryInput);
cvMerge(realInput, imaginaryInput, NULL, NULL, complexInput);
dft_M = cvGetOptimalDFTSize( im->height - 1 );
dft_N = cvGetOptimalDFTSize( im->width - 1 );
dft_A = rb_cvCreateMat( dft_M, dft_N, CV_64FC2 );
image_Re = rb_cvCreateImage( cvSize(dft_N, dft_M), IPL_DEPTH_64F, 1);
image_Im = rb_cvCreateImage( cvSize(dft_N, dft_M), IPL_DEPTH_64F, 1);
// copy A to dft_A and pad dft_A with zeros
cvGetSubRect( dft_A, &tmp, cvRect(0,0, im->width, im->height));
cvCopy( complexInput, &tmp, NULL );
if( dft_A->cols > im->width )
{
cvGetSubRect( dft_A, &tmp, cvRect(im->width,0, dft_A->cols - im->width, im->height));
cvZero( &tmp );
}
// no need to pad bottom part of dft_A with zeros because of
// use nonzero_rows parameter in cvDFT() call below
cvDFT( dft_A, dft_A, CV_DXT_FORWARD, complexInput->height );
// Split Fourier in real and imaginary parts
cvSplit( dft_A, image_Re, image_Im, 0, 0 );
// Compute the magnitude of the spectrum Mag = sqrt(Re^2 + Im^2)
cvPow( image_Re, image_Re, 2.0);
cvPow( image_Im, image_Im, 2.0);
cvAdd( image_Re, image_Im, image_Re, NULL);
cvPow( image_Re, image_Re, 0.5 );
// Compute log(1 + Mag)
cvAddS( image_Re, cvScalarAll(1.0), image_Re, NULL ); // 1 + Mag
cvLog( image_Re, image_Re ); // log(1 + Mag)
// Rearrange the quadrants of Fourier image so that the origin is at
// the image center
cvShiftDFT( image_Re, image_Re );
cvReleaseImage(&realInput);
cvReleaseImage(&imaginaryInput);
cvReleaseImage(&complexInput);
cvReleaseImage(&image_Im);
cvReleaseMat(&dft_A);
return image_Re;
}
void CMagicCabsineUniversalProperty_feature_texture_spectral_DFT::ComputeProperty()
{
IplImage * im;//输入图像必须是灰度图像
IplImage * realInput;
IplImage * imaginaryInput;
IplImage * complexInput;
int dft_M, dft_N;
CvMat* dft_A, tmp;
IplImage * image_Im;
IplImage * image_Re;
double m, M;
//灰度图转化
IplImage *srcimg_cvt = cvCreateImage(cvGetSize(srcImage),IPL_DEPTH_8U,3);//源图像格式化图像
im = cvCreateImage(cvGetSize(srcImage),IPL_DEPTH_8U,1);
cvConvertScale(srcImage,srcimg_cvt);//源图像格式化 转换成 IPL_DEPTH_32F 3通道
cvCvtColor(srcImage,im,CV_BGR2GRAY);//源图像转换成灰度图
cvReleaseImage(&srcimg_cvt);
realInput = cvCreateImage( cvGetSize(srcImage), IPL_DEPTH_64F, 1);//灰度图像
imaginaryInput = cvCreateImage( cvGetSize(srcImage), IPL_DEPTH_64F, 1);//灰度图像
complexInput = cvCreateImage( cvGetSize(srcImage), IPL_DEPTH_64F, 2);
cvScale(im, realInput, 1.0, 0.0);//从8u转换成32f 提高精度
cvZero(imaginaryInput);
//将单通道图像合并成多通道图像（将realInput和imageinaryImput合并到双通道图像complexInput）
cvMerge(realInput, imaginaryInput, NULL, NULL, complexInput);
/*dft_M = cvGetOptimalDFTSize( im->height - 1 );
dft_N = cvGetOptimalDFTSize( im->width - 1 );*/
dft_M = im->height;
dft_N = im->width;
dft_A = cvCreateMat( dft_M, dft_N, CV_64FC2 );
image_Re = cvCreateImage( cvSize(dft_N, dft_M), IPL_DEPTH_64F, 1);//DFT最佳尺寸的图像
image_Im = cvCreateImage( cvSize(dft_N, dft_M), IPL_DEPTH_64F, 1);
// copy A to dft_A and pad dft_A with zeros
cvGetSubRect( dft_A, &tmp, cvRect(0,0, im->width, im->height));
cvCopy( complexInput, &tmp, NULL );
if( dft_A->cols > im->width )
{
cvGetSubRect( dft_A, &tmp, cvRect(im->width,0, dft_A->cols - im->width, im->height));
cvZero( &tmp );
}
// no need to pad bottom part of dft_A with zeros because of
// use nonzero_rows parameter in cvDFT() call below
cvDFT( dft_A, dft_A, CV_DXT_FORWARD, complexInput->height );
// Split Fourier in real and imaginary parts
cvSplit( dft_A, image_Re, image_Im, 0, 0 );
// Compute the magnitude of the spectrum Mag = sqrt(Re^2 + Im^2)
cvPow( image_Re, image_Re, 2.0);
cvPow( image_Im, image_Im, 2.0);
cvAdd( image_Re, image_Im, image_Re, NULL);
cvPow( image_Re, image_Re, 0.5 );
// Compute log(1 + Mag)
cvAddS( image_Re, cvScalarAll(1.0), image_Re, NULL ); // 1 + Mag
cvLog( image_Re, image_Re ); // log(1 + Mag)
// Rearrange the quadrants of Fourier image so that the origin is at
// the image center
cvShiftDFT( image_Re, image_Re );
cvMinMaxLoc(image_Re, &m, &M, NULL, NULL, NULL);
cvScale(image_Re, image_Re, 1.0/(M-m), 1.0*(-m)/(M-m));
//cvShowImage("magnitude", image_Re);
//正规化傅里叶变换图像使其可以被存储
image_Re_save = cvCreateImage(cvSize(dft_N,dft_M),IPL_DEPTH_64F,1);//注意本来应该在初始化中创建，但是由于大小参数无法估计故在此创建需要在析构函数中release
cvNormalize(image_Re,image_Re_save,255,0,CV_MINMAX,NULL);
cvReleaseImage(&im);
cvReleaseImage(&realInput);
cvReleaseImage(&imaginaryInput);
cvReleaseImage(&complexInput);
cvReleaseImage(&image_Re);
cvReleaseImage(&image_Im);
////对傅里叶进行正规化使用L2(欧几里得)范式获取正规化傅里叶系数NFP,以计算3个傅里叶系数,未加绝对值
//cvNormalize(image_Re,image_Re,1,0,CV_L2,NULL);
////test
//cvMinMaxLoc(image_Re, &m, &M, NULL, NULL, NULL);
////对傅里叶NFP取绝对值
//cvAbs(image_Re,image_Re);
////test
//cvMinMaxLoc(image_Re, &m, &M, NULL, NULL, NULL);
////计算傅里叶系数熵
//double h = FT_Entropy(image_Re, dft_N, dft_M);
//double e = FT_Energy(image_Re, dft_N, dft_M);
//double i = FT_Inertia(image_Re, dft_N, dft_M);
////存储特征
//featurefilename+=".txt";
//
//FILE* file = fopen(featurefilename.c_str(),"w");
//fprintf_s(file,"%.6f\n",h);
//fprintf_s(file,"%.6f\n",e);
//fprintf_s(file,"%.6f\n",i);
//fclose(file);
//return 0;
}
static int icvL1QCNewton( CvAAtOpsData& AAtData, CvMat* B, CvMat* X, CvMat* U, double epsilon, double tau, CvTermCriteria nt_term_crit, CvTermCriteria cg_term_crit )
{
const double alpha = .01;
const double beta = .5;
CvMat* R = cvCreateMat( B->rows, B->cols, CV_MAT_TYPE(B->type) );
AAtData.AOps( X, AAtData.AR, AAtData.userdata );
cvSub( AAtData.AR, B, R );
CvMat* fu1 = cvCreateMat( X->rows, X->cols, CV_MAT_TYPE(X->type) );
CvMat* fu2 = cvCreateMat( X->rows, X->cols, CV_MAT_TYPE(X->type) );
CvMat* lfu1 = cvCreateMat( fu1->rows, fu1->cols, CV_MAT_TYPE(fu1->type) );
CvMat* lfu2 = cvCreateMat( fu2->rows, fu2->cols, CV_MAT_TYPE(fu2->type) );
cvSub( U, X, lfu1 );
cvAdd( X, U, lfu2 );
cvSubRS( lfu1, cvScalar(0), fu1 );
cvSubRS( lfu2, cvScalar(0), fu2 );
double epsilon2 = epsilon * epsilon;
double tau_inv = 1. / tau;
double fe = .5 * (cvDotProduct( R, R ) - epsilon2);
double fe_inv = 1. / fe;
cvLog( lfu1, lfu1 );
cvLog( lfu2, lfu2 );
CvScalar sumU = cvSum( U );
CvScalar sumfu1 = cvSum( lfu1 );
CvScalar sumfu2 = cvSum( lfu2 );
double f = sumU.val[0] - tau_inv * (sumfu1.val[0] + sumfu2.val[0] + log(-fe));
CvMat* atr = cvCreateMat( X->rows, X->cols, CV_MAT_TYPE(X->type) );
CvMat* ntgx = cvCreateMat( X->rows, X->cols, CV_MAT_TYPE(X->type) );
CvMat* ntgu = cvCreateMat( X->rows, X->cols, CV_MAT_TYPE(X->type) );
CvMat* sig1211 = cvCreateMat( X->rows, X->cols, CV_MAT_TYPE(X->type) );
CvMat* sigx = cvCreateMat( X->rows, X->cols, CV_MAT_TYPE(X->type) );
CvMat* w1 = cvCreateMat( X->rows, X->cols, CV_MAT_TYPE(X->type) );
CvMat* du = cvCreateMat( X->rows, X->cols, CV_MAT_TYPE(X->type) );
CvMat* pX = cvCreateMat( X->rows, X->cols, CV_MAT_TYPE(X->type) );
CvMat* pU = cvCreateMat( U->rows, U->cols, CV_MAT_TYPE(U->type) );
CvMat* pR = cvCreateMat( R->rows, R->cols, CV_MAT_TYPE(R->type) );
CvMat* pfu1 = cvCreateMat( fu1->rows, fu1->cols, CV_MAT_TYPE(fu1->type) );
CvMat* pfu2 = cvCreateMat( fu2->rows, fu2->cols, CV_MAT_TYPE(fu2->type) );
CvMat* Adx = cvCreateMat( B->rows, B->cols, CV_MAT_TYPE(B->type) );
CvMat* dx = cvCreateMat( X->rows, X->cols, CV_MAT_TYPE(X->type) );
CvMat* tX = cvCreateMat( X->rows, X->cols, CV_MAT_TYPE(X->type) );
int result = nt_term_crit.max_iter;
CvH11OpsData H11OpsData;
H11OpsData.AOps = AAtData.AOps;
H11OpsData.AtOps = AAtData.AtOps;
H11OpsData.AR = AAtData.AR;
H11OpsData.AtR = AAtData.AtR;
H11OpsData.userdata = AAtData.userdata;
H11OpsData.tX = tX;
H11OpsData.atr = atr;
H11OpsData.sigx = sigx;
int t, i;
for ( t = 0; t < nt_term_crit.max_iter; ++t )
{
AAtData.AtOps( R, atr, AAtData.userdata );
double* atrp = atr->data.db;
double* fu1p = fu1->data.db;
double* fu2p = fu2->data.db;
double* ntgxp = ntgx->data.db;
double* ntgup = ntgu->data.db;
double* sig1211p = sig1211->data.db;
double* sigxp = sigx->data.db;
double* w1p = w1->data.db;
double* dup = du->data.db;
for ( i = 0; i < X->rows; ++i, ++atrp, ++fu1p, ++fu2p, ++ntgxp, ++ntgup, ++sig1211p, ++sigxp, ++w1p, ++dup )
{
double fu1_inv = 1. / (*fu1p);
double fu2_inv = 1. / (*fu2p);
double ntgxv = fu1_inv - fu2_inv + fe_inv * (*atrp);
double ntguv = -tau - fu1_inv - fu2_inv;
double sig11 = fu1_inv * fu1_inv + fu2_inv * fu2_inv;
double sig12 = -fu1_inv * fu1_inv + fu2_inv * fu2_inv;
*sig1211p = sig12 / sig11;
*sigxp = sig11 - sig12 * (*sig1211p);
*w1p = ntgxv - (*sig1211p) * ntguv;
*ntgxp = -tau_inv * ntgxv;
*ntgup = -tau_inv * ntguv;
*dup = ntguv / sig11;
}
H11OpsData.fe_inv = fe_inv;
H11OpsData.fe_inv_2 = fe_inv * fe_inv;
if ( cvCGSolve( icvH11Ops, &H11OpsData, w1, dx, cg_term_crit ) > .5 )
{
result = t;
goto __clean_up__;
}
AAtData.AOps( dx, Adx, AAtData.userdata );
dup = du->data.db;
sig1211p = sig1211->data.db;
double* dxp = dx->data.db;
for ( i = 0; i < X->rows; ++i, ++dup, ++sig1211p, ++dxp )
*dup -= (*sig1211p) * (*dxp);
/* minimum step size that stays in the interior */
double aqe = cvDotProduct( Adx, Adx );
double bqe = 2. * cvDotProduct( R, Adx );
double cqe = cvDotProduct( R, R ) - epsilon2;
double smax = MIN( 1, -bqe + sqrt( bqe * bqe - 4 * aqe * cqe ) / (2 * aqe) );
dup = du->data.db;
dxp = dx->data.db;
fu1p = fu1->data.db;
fu2p = fu2->data.db;
for ( i = 0; i < X->rows; ++i, ++dup, ++dxp, ++fu1p, ++fu2p )
{
if ( (*dxp) - (*dup) > 0 )
smax = MIN( smax, -(*fu1p) / ((*dxp) - (*dup)) );
if ( (*dxp) + (*dup) < 0 )
smax = MIN( smax, (*fu2p) / ((*dxp) + (*dup)) );
}
smax *= .99;
/* backtracking line search */
bool suffdec = 0;
int backiter = 0;
double fep = fe;
double fp = f;
double lambda2;
while (!suffdec)
{
cvAddWeighted( X, 1, dx, smax, 0, pX );
cvAddWeighted( U, 1, du, smax, 0, pU );
cvAddWeighted( R, 1, Adx, smax, 0, pR );
cvSub( pU, pX, lfu1 );
cvAdd( pX, pU, lfu2 );
cvSubRS( lfu1, cvScalar(0), pfu1 );
cvSubRS( lfu2, cvScalar(0), pfu2 );
fep = .5 * (cvDotProduct( pR, pR ) - epsilon2);
cvLog( lfu1, lfu1 );
cvLog( lfu2, lfu2 );
CvScalar sumpU = cvSum( pU );
CvScalar sumpfu1 = cvSum( pfu1 );
CvScalar sumpfu2 = cvSum( pfu2 );
fp = sumpU.val[0] - tau_inv * (sumpfu1.val[0] + sumpfu2.val[0] + log(-fep));
lambda2 = cvDotProduct( ntgx, dx ) + cvDotProduct( ntgu, du );
double flin = f + alpha * smax * lambda2;
suffdec = (fp <= flin);
smax = beta * smax;
++backiter;
if ( backiter > 32 )
{
result = t;
goto __clean_up__;
}
}
/* set up for next iteration */
cvCopy( pX, X );
cvCopy( pU, U );
cvCopy( pR, R );
cvCopy( pfu1, fu1 );
cvCopy( pfu2, fu2 );
fe = fep;
fe_inv = 1. / fe;
f = fp;
lambda2 = -lambda2 * .5;
if ( lambda2 < nt_term_crit.epsilon )
{
result = t + 1;
break;
}
}
__clean_up__:
cvReleaseMat( &pfu2 );
cvReleaseMat( &pfu1 );
cvReleaseMat( &pR );
cvReleaseMat( &pU );
cvReleaseMat( &pX );
cvReleaseMat( &tX );
cvReleaseMat( &dx );
cvReleaseMat( &Adx );
cvReleaseMat( &du );
cvReleaseMat( &w1 );
cvReleaseMat( &sigx );
cvReleaseMat( &sig1211 );
cvReleaseMat( &ntgu );
cvReleaseMat( &ntgx );
cvReleaseMat( &lfu2 );
cvReleaseMat( &lfu1 );
cvReleaseMat( &fu2 );
cvReleaseMat( &fu1 );
cvReleaseMat( &R );
return result;
}
void CLightSet::RunLightPrep(IplImage* src,IplImage* dest)
{
int M,N;
M=0;
N=0;
if (src->roi)
{
M = src->roi->width;
N = src->roi->height;
}
else
{
M = src->width;
N = src->height;
}
CvMat *matD; // create mat for meshgrid frequency matrices
matD = cvCreateMat(M,N,CV_32FC1);
CDM(M,N,matD);
CvMat *matH;
matH = cvCreateMat(M,N,CV_32FC1); // mat for lowpass filter
float D0 = 10.0;
float rH,rL,c;
rH = 2.0;
rL = 0.5;
c = 1.0;
lpfilter(matD,matH,D0,rH,rL,c);
IplImage *srcshift; // shift center
srcshift = cvCloneImage(src);
cvShiftDFT(srcshift,srcshift);
IplImage *log, *temp;
log = cvCreateImage(cvGetSize(src),IPL_DEPTH_32F,1);
temp = cvCreateImage(cvGetSize(src),IPL_DEPTH_32F,1);
cvCvtScale(srcshift,temp,1.0,0);
cvLog(temp,log);
cvCvtScale(log,log,-1.0,0);
CvMat *Fourier;
Fourier = cvCreateMat( M, N, CV_32FC2 );
fft2(log,Fourier);
IplImage* image_im;
image_im = cvCreateImage(cvGetSize(src),IPL_DEPTH_32F,1);
cvSplit(Fourier,dest,image_im,0,0);
cvMul(dest,matH,dest);
cvMul(image_im,matH,image_im);
IplImage *dst;
dst = cvCreateImage(cvGetSize(src),IPL_DEPTH_32F,2);
cvMerge(dest,image_im,0,0,dst);
cvDFT(dst,dst,CV_DXT_INV_SCALE);
cvExp(dst,dst);
cvZero(dest);
cvZero(image_im);
cvSplit(dst,dest,image_im,0,0);
//使得图像按照原来的顺序显示
cvShiftDFT(dest,dest);
double max,min; // normalize
cvMinMaxLoc(dest,&min,&max,NULL,NULL);
cvReleaseImage(&image_im);
cvReleaseImage(&srcshift);
cvReleaseImage(&dst);
cvReleaseImage(&log);
cvReleaseImage(&temp);
cvReleaseMat(&matD);
cvReleaseMat(&matH);
}
