JNIEXPORT void JNICALL Java_de_jurihock_voicesmith_dsp_KissFFT_ifft
(JNIEnv* env, jobject, jlong handle, jfloatArray _buffer)
{
KissFFT* fft = (KissFFT*)handle;
float* buffer = (float*)env->GetPrimitiveArrayCritical(_buffer, 0);
// buffer => spectrum
memcpy(fft->spectrum, buffer, sizeof(float)*fft->size);
// Im(DC) => Re(Nyquist)
fft->spectrum[fft->size/2].r = fft->spectrum[0].i;
fft->spectrum[0].i = 0;
fft->spectrum[fft->size/2].i = 0;
// ifft(spectrum) => buffer
kiss_fftri(fft->backward, fft->spectrum, buffer);
// Normalize buffer values by 1/N
for (int i = 0; i < fft->size; i++)
buffer[i] /= fft->size;
// Circular shift by N/2
fftshift(fft, buffer);
env->ReleasePrimitiveArrayCritical(_buffer, buffer, 0);
}
void IQSSBDemodulator::circshift(Ipp32f* b, int len, int lo)
{
fftshift(b, len);
static Ipp32f* tmp = ippsMalloc_32f(len);
if(lo>=0)
{
ippsCopy_32f(b, tmp, lo);
ippsMove_32f(b+lo, b, len-lo);
ippsCopy_32f(tmp, b+len-lo, lo);
}
else
{
int abs_lo = -lo;
ippsCopy_32f(b+len-abs_lo, tmp, abs_lo);
ippsMove_32f(b, b+abs_lo, len-abs_lo);
ippsCopy_32f(tmp, b, abs_lo);
}
fftshift(b, len);
}
Array<T> fbp(const Array<T>& A, const Array<T>& gamma, size_t N)
{
Array<T> I = zeros(N,N);
Array<T> x = linspace(-0.5,0.5,N);
Array<T> y = linspace(-0.5,0.5,N);
size_t nrDetPix = shape(A,0);
size_t nrAngles = shape(A,1);
Array<T> filter = abs( range(-nrDetPix/2, nrDetPix/2) ); //abs(linspace(-nrDetPix/2, nrDetPix/2,nrDetPix))';
for(size_t t=0; t<size(gamma); t++)
{
auto fhat = fftshift(fft(A(full,t)));
fhat = fhat * filter;
A(full,t) = real(ifft(fftshift(fhat))); //Todo -> ifftshift
}
//gamma = gamma / 360.0 * 2 * pi;
for(size_t m=0; m<N; m++)
for(size_t n=0; n<N; n++)
for(size_t t=0; t<nrAngles; t++)
{
T xi = x(m)*cos(gamma(t))+y(n)*sin(gamma(t));
size_t index = round((xi/sqrt(2.0) + 0.5) * (nrDetPix-1.0));
I(m,n) += A(index,t);
}
//I = real(I/(2*nrAngles)*pi);
//I = rot90(I); %flipud(fliplr(I));
return I;
}
JNIEXPORT void JNICALL Java_de_jurihock_voicesmith_dsp_KissFFT_fft
(JNIEnv* env, jobject, jlong handle, jfloatArray _buffer)
{
KissFFT* fft = (KissFFT*)handle;
float* buffer = (float*)env->GetPrimitiveArrayCritical(_buffer, 0);
// Circular shift by N/2
fftshift(fft, buffer);
// fft(buffer) => spectrum
kiss_fftr(fft->forward, buffer, fft->spectrum);
// Re(Nyquist) => Im(DC)
fft->spectrum[0].i = fft->spectrum[fft->size/2].r;
// spectrum => buffer
memcpy(buffer, fft->spectrum, sizeof(float)*fft->size);
// LOG("FFT DC (%f,%f)", fft->spectrum[0].r, fft->spectrum[0].i);
// LOG("FFT Nyquist (%f,%f)", fft->spectrum[fft->size/2].r, fft->spectrum[fft->size/2].i);
env->ReleasePrimitiveArrayCritical(_buffer, buffer, 0);
}
cv::Mat HologramDecoder::fresnel( cv::Mat hologramColor, float dx, float dy, float z, float lambda ) {
#ifdef PRINT_FRESNELL
std::cout << " **INFORMACOES FRESNEL**\n"
<< " dx: " << dx << std::endl
<< " dy: " << dy << std::endl
<< " z: " << z << std::endl
<< " lamda " << lambda << std::endl;
#endif
cv::Mat hologram;
cv::cvtColor( hologramColor, hologram, CV_BGR2GRAY );
hologram.convertTo( hologram, CV_32FC1, 1.0 / 255.0 );
hologram = HologramDecoder::optimizeToFresnel( hologram );
float k = ( ( 2 * M_PI ) );
float Nxx = hologram.cols;
float Nyy = hologram.rows;
//Cria duas matrizes linha com o tamanho em x e y da imagem
//x = ones(Nyy,1)*[-Nxx/2:Nxx/2-1]*dx; [MATLAB]
cv::Mat part1x = cv::Mat::ones( hologram.rows, 1, CV_32FC1 ); //ones(Nyy,1)
cv::Mat part2x = cv::Mat( 1, hologram.cols, CV_32FC1 ); //[-Nxx/2 : Nxx/2-1]
//
float * aux = new float[hologram.cols];
int index = 0;
/*Cria um vetor gradiente com o tamanho em x da imagem*/
for( int i = ( -1 * ( hologram.cols / 2 ) ); i < ( hologram.cols / 2 ); i++ ) {
aux[index] = ( float ) i;
index++;
}
part2x = cv::Mat( part2x.rows, part2x.cols, CV_32FC1, aux ); //O vetor gradiente
//
cv::Mat x = part1x * part2x * dx;
x.convertTo( x, CV_32FC1 ); // X pronto
//
//
//Reinicia as variaveis auxiliares
aux = new float[hologram.cols];
index = 0;
//Cria outro gradiente, com tamanho em y
for( int i = ( -1 * ( hologram.rows ) / 2 ); i < ( hologram.rows ) / 2; i++ ) {
aux[index] = ( float ) i;
index++;
}
cv::Mat part1y = cv::Mat( 1, hologram.rows, CV_32FC1, aux );
cv::Mat part2y = cv::Mat::ones( 1, hologram.cols, CV_32F );
cv::Mat part1ytanspost = cv::Mat( part1y.rows, part1y.cols, part1y.type() );
cv::transpose( part1y, part1ytanspost );
cv::Mat y = part1ytanspost * part2y * dy;
y.convertTo( y, CV_32FC1 ); // Y pronto
//
//
float Lx = dx * Nxx;
float Ly = dy * Nyy;
float criti = dx * Lx / lambda;
float dfx = 1 / Lx;
float dfy = 1 / Ly;
//
//u = ones(Nyy,1)*[-Nxx/2:Nxx/2-1]*dfx;
//v = [-Nyy/2:Nyy/2-1]'*ones(1,Nxx)*dfy;l
cv::Mat part1u = cv::Mat::ones( hologram.rows, 1, CV_32F );
cv::Mat part2u = cv::Mat( 1, hologram.cols, CV_32F );
aux = new float[hologram.cols];
index = 0;
for( int i = ( -1 * ( hologram.cols / 2 ) ); i < ( hologram.cols / 2 ); i++ ) {
aux[index] = ( float ) i;
index++;
}
part2u = cv::Mat( part2x.rows, part2x.cols, CV_32F, aux );
cv::Mat u = part1u * part2u * dfx; //U pronto
//
aux = new float[hologram.rows];
index = 0;
for( int i = ( -1 * ( hologram.rows ) / 2 ); i < ( hologram.rows ) / 2; i++ ) {
aux[index] = ( float ) i;
index++;
}
cv::Mat part1v = cv::Mat( 1, hologram.rows, CV_32FC1, aux );
cv::Mat part2v = cv::Mat::ones( 1, hologram.cols, CV_32F );
cv::Mat part1vtanspost = cv::Mat( part1y.rows, part1y.cols, part1v.type() );
cv::transpose( part1v, part1vtanspost );
cv::Mat v = part1vtanspost * part2v * dfy;//V pronto
//
//
cv::Mat zero = cv::Mat( hologram.cols, hologram.rows, CV_32FC1 );
cv::Mat shifted = hologram.clone();
fftshift( shifted );
cv::Mat real = cv::Mat( hologram.rows, hologram.cols, CV_32FC1 ), imaginary = cv::Mat( hologram.rows, hologram.cols, CV_32FC1 );
cv::Mat mats[] = {real, imaginary};
cv::Mat result;
cv::merge( mats, 2, result );
cv::dft( shifted, result, cv::DFT_COMPLEX_OUTPUT );
zero = result;
cv::Mat partialFinalResult;
// if( z > criti ) {
if( false ) {
std::cout << " ENTROU NO IF" << std::endl;
std::complex<float> ifPart1;
ifPart1.imag( lambda * z );
cv::Mat sumMats;
cv::Mat xSquare = squareMatrix( x );
cv::Mat ySquare = squareMatrix( y );
sumMats = xSquare + ySquare;
// std::cout << " IF\n sumMats.channels: " << sumMats.channels() << std::endl;
std::complex<float> ifPart2_1;
ifPart2_1.imag( k / 2 * z );
// std::cout << " IF[1]" << std::endl;
cv::Mat hpart2 = ComplexMatrix::mulComplexMat( sumMats, ifPart2_1 );
// std::cout << "IF[2]" << std::endl;
cv::Mat expPart2 = ComplexMatrix::exp( hpart2 );
// std::cout << "IF[3]" << std::endl;
cv::Mat h = ComplexMatrix::mulComplexMat( expPart2, ifPart1 );
cv::Mat ifShifted = h.clone();
fftshift( ifShifted );
cv::Mat outputReal = cv::Mat( ifShifted.rows, ifShifted.cols, CV_32FC1 );
cv::Mat outputImaginary = cv::Mat( ifShifted.rows, ifShifted.cols, CV_32FC1 );
cv::Mat transformed;
cv::Mat matrixes[] = {outputReal, outputImaginary};
cv::merge( matrixes, 2, transformed );
cv::dft( ifShifted, transformed, cv::DFT_COMPLEX_OUTPUT );
std::complex<float> complexAux( dx, 0 );
complexAux.real( pow( complexAux.real(), 2 ) );
complexAux.imag( pow( complexAux.imag(), 2 ) );
partialFinalResult = ComplexMatrix::mulComplexMat( transformed, complexAux );
} else {
//std::cout << " ENTROU NO ELSE" << std::endl;
std::complex<float> part0else( 0, k * z );
std::complex<float>part1else = std::exp<float> ( part0else );
std::complex<float> part2else( 0, - ( M_PI * lambda * z ) );
cv::Mat uSquared = squareMatrix( u );
cv::Mat vSquared = squareMatrix( v );
cv::Mat sumMats = vSquared + uSquared;
cv::Mat part3else = ComplexMatrix::mulComplexRealMat( sumMats, part2else );
cv::Mat expPart3 = ComplexMatrix::exp( part3else );
cv::Mat semiFinal = ComplexMatrix::mulComplexMat( expPart3, part1else );
cv::Mat final = fftshift( semiFinal );
partialFinalResult = final;
}
cv::Mat object = ComplexMatrix::perElementMult( zero, partialFinalResult );
cv::Mat outputReal = cv::Mat::zeros( object.rows, object.cols, CV_32FC1 );
cv::Mat outputImaginary = cv::Mat::zeros( object.rows, object.cols, CV_32FC1 );
cv::Mat outputs[] = {outputReal, outputImaginary};
cv::Mat output2;
cv::merge( outputs, 2, output2 );
cv::dft( object, output2, cv::DFT_INVERSE );
return cv::abs( output2 );
}
/**
* @brief Inverse FFT shift
*
* @param m TO be inversely shifted
* @return Inversely shifted
*/
template<class T> inline Matrix<T>
ifftshift (const Matrix<T>& m) {
return fftshift (m,false);
}
static void color_prefilt(color_image_t *src, int fc)
{
fftw_lock();
int i, j;
/* Log */
for(j = 0; j < src->height; j++)
{
for(i = 0; i < src->width; i++)
{
src->c1[j*src->width+i] = log(src->c1[j*src->width+i]+1.0f);
src->c2[j*src->width+i] = log(src->c2[j*src->width+i]+1.0f);
src->c3[j*src->width+i] = log(src->c3[j*src->width+i]+1.0f);
}
}
color_image_t *img_pad = color_image_add_padding(src, 5);
/* Get sizes */
int width = img_pad->width;
int height = img_pad->height;
/* Alloc memory */
float *fx = (float *) fftwf_malloc(width*height*sizeof(float));
float *fy = (float *) fftwf_malloc(width*height*sizeof(float));
float *gfc = (float *) fftwf_malloc(width*height*sizeof(float));
fftwf_complex *ina1 = (fftwf_complex *) fftwf_malloc(width*height*sizeof(fftwf_complex));
fftwf_complex *ina2 = (fftwf_complex *) fftwf_malloc(width*height*sizeof(fftwf_complex));
fftwf_complex *ina3 = (fftwf_complex *) fftwf_malloc(width*height*sizeof(fftwf_complex));
fftwf_complex *inb1 = (fftwf_complex *) fftwf_malloc(width*height*sizeof(fftwf_complex));
fftwf_complex *inb2 = (fftwf_complex *) fftwf_malloc(width*height*sizeof(fftwf_complex));
fftwf_complex *inb3 = (fftwf_complex *) fftwf_malloc(width*height*sizeof(fftwf_complex));
fftwf_complex *out1 = (fftwf_complex *) fftwf_malloc(width*height*sizeof(fftwf_complex));
fftwf_complex *out2 = (fftwf_complex *) fftwf_malloc(width*height*sizeof(fftwf_complex));
fftwf_complex *out3 = (fftwf_complex *) fftwf_malloc(width*height*sizeof(fftwf_complex));
/* Build whitening filter */
float s1 = fc/sqrt(log(2));
for(j = 0; j < height; j++)
{
for(i = 0; i < width; i++)
{
ina1[j*width + i][0] = img_pad->c1[j*width+i];
ina2[j*width + i][0] = img_pad->c2[j*width+i];
ina3[j*width + i][0] = img_pad->c3[j*width+i];
ina1[j*width + i][1] = 0.0f;
ina2[j*width + i][1] = 0.0f;
ina3[j*width + i][1] = 0.0f;
fx[j*width + i] = (float) i - width/2.0f;
fy[j*width + i] = (float) j - height/2.0f;
gfc[j*width + i] = exp(-(fx[j*width + i]*fx[j*width + i] + fy[j*width + i]*fy[j*width + i]) / (s1*s1));
}
}
fftshift(gfc, width, height);
/* FFT */
fftwf_plan fft11 = fftwf_plan_dft_2d(width, height, ina1, out1, FFTW_FORWARD, FFTW_ESTIMATE);
fftwf_plan fft12 = fftwf_plan_dft_2d(width, height, ina2, out2, FFTW_FORWARD, FFTW_ESTIMATE);
fftwf_plan fft13 = fftwf_plan_dft_2d(width, height, ina3, out3, FFTW_FORWARD, FFTW_ESTIMATE);
fftw_unlock();
fftwf_execute(fft11);
fftwf_execute(fft12);
fftwf_execute(fft13);
fftw_lock();
/* Apply whitening filter */
for(j = 0; j < height; j++)
{
for(i = 0; i < width; i++)
{
out1[j*width+i][0] *= gfc[j*width + i];
out2[j*width+i][0] *= gfc[j*width + i];
out3[j*width+i][0] *= gfc[j*width + i];
out1[j*width+i][1] *= gfc[j*width + i];
out2[j*width+i][1] *= gfc[j*width + i];
out3[j*width+i][1] *= gfc[j*width + i];
}
}
/* IFFT */
fftwf_plan ifft11 = fftwf_plan_dft_2d(width, height, out1, inb1, FFTW_BACKWARD, FFTW_ESTIMATE);
fftwf_plan ifft12 = fftwf_plan_dft_2d(width, height, out2, inb2, FFTW_BACKWARD, FFTW_ESTIMATE);
fftwf_plan ifft13 = fftwf_plan_dft_2d(width, height, out3, inb3, FFTW_BACKWARD, FFTW_ESTIMATE);
fftw_unlock();
fftwf_execute(ifft11);
fftwf_execute(ifft12);
fftwf_execute(ifft13);
fftw_lock();
/* Local contrast normalisation */
for(j = 0; j < height; j++)
{
for(i = 0; i < width; i++)
{
img_pad->c1[j*width+i] -= inb1[j*width+i][0] / (width*height);
img_pad->c2[j*width+i] -= inb2[j*width+i][0] / (width*height);
img_pad->c3[j*width+i] -= inb3[j*width+i][0] / (width*height);
float mean = (img_pad->c1[j*width+i] + img_pad->c2[j*width+i] + img_pad->c3[j*width+i])/3.0f;
ina1[j*width+i][0] = mean*mean;
ina1[j*width+i][1] = 0.0f;
}
}
/* FFT */
fftwf_plan fft21 = fftwf_plan_dft_2d(width, height, ina1, out1, FFTW_FORWARD, FFTW_ESTIMATE);
fftw_unlock();
fftwf_execute(fft21);
fftw_lock();
/* Apply contrast normalisation filter */
for(j = 0; j < height; j++)
{
for(i = 0; i < width; i++)
{
out1[j*width+i][0] *= gfc[j*width + i];
out1[j*width+i][1] *= gfc[j*width + i];
}
}
/* IFFT */
fftwf_plan ifft2 = fftwf_plan_dft_2d(width, height, out1, inb1, FFTW_BACKWARD, FFTW_ESTIMATE);
fftw_unlock();
fftwf_execute(ifft2);
fftw_lock();
/* Get result from contrast normalisation filter */
for(j = 0; j < height; j++)
{
for(i = 0; i < width; i++)
{
float val = sqrt(sqrt(inb1[j*width+i][0]*inb1[j*width+i][0]+inb1[j*width+i][1]*inb1[j*width+i][1]) / (width*height));
img_pad->c1[j*width+i] /= (0.2f+val);
img_pad->c2[j*width+i] /= (0.2f+val);
img_pad->c3[j*width+i] /= (0.2f+val);
}
}
color_image_rem_padding(src, img_pad, 5);
/* Free */
fftwf_destroy_plan(fft11);
fftwf_destroy_plan(fft12);
fftwf_destroy_plan(fft13);
fftwf_destroy_plan(ifft11);
fftwf_destroy_plan(ifft12);
fftwf_destroy_plan(ifft13);
fftwf_destroy_plan(fft21);
fftwf_destroy_plan(ifft2);
color_image_delete(img_pad);
fftwf_free(ina1);
fftwf_free(ina2);
fftwf_free(ina3);
fftwf_free(inb1);
fftwf_free(inb2);
fftwf_free(inb3);
fftwf_free(out1);
fftwf_free(out2);
fftwf_free(out3);
fftwf_free(fx);
fftwf_free(fy);
fftwf_free(gfc);
fftw_unlock();
}
/*static*/ void prefilt(image_t *src, int fc)
{
fftw_lock();
int i, j;
/* Log */
for(j = 0; j < src->height; j++)
{
for(i = 0; i < src->width; i++) {
src->data[j*src->stride+i] = log(src->data[j*src->stride+i]+1.0f);
}
}
image_t *img_pad = image_add_padding(src, 5);
/* Get sizes */
int width = img_pad->width;
int height = img_pad->height;
int stride = img_pad->stride;
/* Alloc memory */
float *fx = (float *) fftwf_malloc(width*height*sizeof(float));
float *fy = (float *) fftwf_malloc(width*height*sizeof(float));
float *gfc = (float *) fftwf_malloc(width*height*sizeof(float));
fftwf_complex *in1 = (fftwf_complex *) fftwf_malloc(width*height*sizeof(fftwf_complex));
fftwf_complex *in2 = (fftwf_complex *) fftwf_malloc(width*height*sizeof(fftwf_complex));
fftwf_complex *out = (fftwf_complex *) fftwf_malloc(width*height*sizeof(fftwf_complex));
/* Build whitening filter */
float s1 = fc/sqrt(log(2));
for(j = 0; j < height; j++)
{
for(i = 0; i < width; i++)
{
in1[j*width + i][0] = img_pad->data[j*stride+i];
in1[j*width + i][1] = 0.0f;
fx[j*width + i] = (float) i - width/2.0f;
fy[j*width + i] = (float) j - height/2.0f;
gfc[j*width + i] = exp(-(fx[j*width + i]*fx[j*width + i] + fy[j*width + i]*fy[j*width + i]) / (s1*s1));
}
}
fftshift(gfc, width, height);
/* FFT */
fftwf_plan fft1 = fftwf_plan_dft_2d(width, height, in1, out, FFTW_FORWARD, FFTW_ESTIMATE);
fftw_unlock();
fftwf_execute(fft1);
fftw_lock();
/* Apply whitening filter */
for(j = 0; j < height; j++)
{
for(i = 0; i < width; i++)
{
out[j*width+i][0] *= gfc[j*width + i];
out[j*width+i][1] *= gfc[j*width + i];
}
}
/* IFFT */
fftwf_plan ifft1 = fftwf_plan_dft_2d(width, height, out, in2, FFTW_BACKWARD, FFTW_ESTIMATE);
fftw_unlock();
fftwf_execute(ifft1);
fftw_lock();
/* Local contrast normalisation */
for(j = 0; j < height; j++)
{
for(i = 0; i < width; i++)
{
img_pad->data[j*stride + i] -= in2[j*width+i][0] / (width*height);
in1[j*width + i][0] = img_pad->data[j*stride + i] * img_pad->data[j*stride + i];
in1[j*width + i][1] = 0.0f;
}
}
/* FFT */
fftwf_plan fft2 = fftwf_plan_dft_2d(width, height, in1, out, FFTW_FORWARD, FFTW_ESTIMATE);
fftw_unlock();
fftwf_execute(fft2);
fftw_lock();
/* Apply contrast normalisation filter */
for(j = 0; j < height; j++)
{
for(i = 0; i < width; i++)
{
out[j*width+i][0] *= gfc[j*width + i];
out[j*width+i][1] *= gfc[j*width + i];
}
}
/* IFFT */
fftwf_plan ifft2 = fftwf_plan_dft_2d(width, height, out, in2, FFTW_BACKWARD, FFTW_ESTIMATE);
fftw_unlock();
fftwf_execute(ifft2);
fftw_lock();
/* Get result from contrast normalisation filter */
for(j = 0; j < height; j++)
{
for(i = 0; i < width; i++) {
img_pad->data[j*stride+i] = img_pad->data[j*stride + i] / (0.2f+sqrt(sqrt(in2[j*width+i][0]*in2[j*width+i][0]+in2[j*width+i][1]*in2[j*width+i][1]) / (width*height)));
}
}
image_rem_padding(src, img_pad, 5);
/* Free */
fftwf_destroy_plan(fft1);
fftwf_destroy_plan(fft2);
fftwf_destroy_plan(ifft1);
fftwf_destroy_plan(ifft2);
image_delete(img_pad);
fftwf_free(in1);
fftwf_free(in2);
fftwf_free(out);
fftwf_free(fx);
fftwf_free(fy);
fftwf_free(gfc);
fftw_unlock();
}
static image_list_t *create_gabor(int nscales, const int *or, int width, int height)
{
int i, j, fn;
image_list_t *G = image_list_new();
int nfilters = 0;
for(i=0;i<nscales;i++) nfilters+=or[i];
float **param = (float **) malloc(nscales * nfilters * sizeof(float *));
for(i = 0; i < nscales * nfilters; i++) {
param[i] = (float *) malloc(4*sizeof(float));
}
float *fx = (float *) malloc(width*height*sizeof(float));
float *fy = (float *) malloc(width*height*sizeof(float));
float *fr = (float *) malloc(width*height*sizeof(float));
float *f = (float *) malloc(width*height*sizeof(float));
int l = 0;
for(i = 1; i <= nscales; i++)
{
for(j = 1; j <= or[i-1]; j++)
{
param[l][0] = 0.35f;
param[l][1] = 0.3/pow(1.85f, i-1);
param[l][2] = 16*pow(or[i-1], 2)/pow(32, 2);
param[l][3] = M_PI/(or[i-1])*(j-1);
l++;
}
}
for(j = 0; j < height; j++)
{
for(i = 0; i < width; i++)
{
fx[j*width + i] = (float) i - width/2.0f;
fy[j*width + i] = (float) j - height/2.0f;
fr[j*width + i] = sqrt(fx[j*width + i]*fx[j*width + i] + fy[j*width + i]*fy[j*width + i]);
f[j*width + i] = atan2(fy[j*width + i], fx[j*width + i]);
}
}
fftshift(fr, width, height);
fftshift(f, width, height);
for(fn = 0; fn < nfilters; fn++)
{
image_t *G0 = image_new(width, height);
float *f_ptr = f;
float *fr_ptr = fr;
for(j = 0; j < height; j++)
{
for(i = 0; i < width; i++)
{
float tmp = *f_ptr++ + param[fn][3];
if(tmp < -M_PI) {
tmp += 2.0f*M_PI;
}
else if (tmp > M_PI) {
tmp -= 2.0f*M_PI;
}
G0->data[j*G0->stride+i] = exp(-10.0f*param[fn][0]*(*fr_ptr/height/param[fn][1]-1)*(*fr_ptr/width/param[fn][1]-1)-2.0f*param[fn][2]*M_PI*tmp*tmp);
fr_ptr++;
}
}
image_list_append(G, G0);
}
for(i = 0; i < nscales * nfilters; i++) {
free(param[i]);
}
free(param);
free(fx);
free(fy);
free(fr);
free(f);
return G;
}
void CBlasMath::ifftshift(Matrix *a)
{
fftshift(a);
}
