void actualPhaseFlip(MultidimArray<double> &I, CTFDescription ctf)
{
// Perform the Fourier transform
FourierTransformer transformer;
MultidimArray< std::complex<double> > M_inFourier;
transformer.FourierTransform(I,M_inFourier,false);
Matrix1D<double> freq(2); // Frequencies for Fourier plane
int yDim=YSIZE(I);
int xDim=XSIZE(I);
double iTm=1.0/ctf.Tm;
for (size_t i=0; i<YSIZE(M_inFourier); ++i)
{
FFT_IDX2DIGFREQ(i, yDim, YY(freq));
YY(freq) *= iTm;
for (size_t j=0; j<XSIZE(M_inFourier); ++j)
{
FFT_IDX2DIGFREQ(j, xDim, XX(freq));
XX(freq) *= iTm;
ctf.precomputeValues(XX(freq),YY(freq));
if (ctf.getValuePureWithoutDampingAt()<0)
DIRECT_A2D_ELEM(M_inFourier,i,j)*=-1;
}
}
// Perform inverse Fourier transform and finish
transformer.inverseFourierTransform();
}
// Remove wedge ------------------------------------------------------------
void MissingWedge::removeWedge(MultidimArray<double> &V) const
{
Matrix2D<double> Epos, Eneg;
Euler_angles2matrix(rotPos,tiltPos,0,Epos);
Euler_angles2matrix(rotNeg,tiltNeg,0,Eneg);
Matrix1D<double> freq(3), freqPos, freqNeg;
Matrix1D<int> idx(3);
FourierTransformer transformer;
MultidimArray< std::complex<double> > Vfft;
transformer.FourierTransform(V,Vfft,false);
FOR_ALL_ELEMENTS_IN_ARRAY3D(Vfft)
{
// Frequency in the coordinate system of the volume
VECTOR_R3(idx,j,i,k);
FFT_idx2digfreq(V,idx,freq);
// Frequency in the coordinate system of the plane
freqPos=Epos*freq;
freqNeg=Eneg*freq;
if (ZZ(freqPos)<0 || ZZ(freqNeg)>0)
Vfft(k,i,j)=0;
}
transformer.inverseFourierTransform();
}
void multiplyBySpectrum(MultidimArray<double>& Min,
MultidimArray<double>& spectrum,
bool leave_origin_intact)
{
MultidimArray<Complex > Faux;
Matrix1D<double> f(3);
MultidimArray<double> lspectrum;
FourierTransformer transformer;
double dim3 = XSIZE(Min) * YSIZE(Min) * ZSIZE(Min);
transformer.FourierTransform(Min, Faux, false);
lspectrum = spectrum;
if (leave_origin_intact)
{
lspectrum(0) = 1.;
}
FOR_ALL_ELEMENTS_IN_FFTW_TRANSFORM(Faux)
{
long int idx = ROUND(sqrt(kp * kp + ip * ip + jp * jp));
dAkij(Faux, k, i, j) *= lspectrum(idx) * dim3;
}
transformer.inverseFourierTransform();
}
void correctMapForMTF(MultidimArray<double >& img, FileName& fn_mtf)
{
FourierTransformer transformer;
MultidimArray<Complex > FT;
transformer.FourierTransform(img, FT, false);
correctMapForMTF(FT, XSIZE(img), fn_mtf);
transformer.inverseFourierTransform();
}
void resizeMap(MultidimArray<double >& img, int newsize)
{
FourierTransformer transformer;
MultidimArray<Complex > FT, FT2;
transformer.FourierTransform(img, FT, false);
windowFourierTransform(FT, FT2, newsize);
if (img.getDim() == 2)
{
img.resize(newsize, newsize);
}
else if (img.getDim() == 3)
{
img.resize(newsize, newsize, newsize);
}
transformer.inverseFourierTransform(FT2, img);
}
void randomizePhasesBeyond(MultidimArray<double>& v, int index)
{
MultidimArray< Complex > FT;
FourierTransformer transformer;
transformer.FourierTransform(v, FT, false);
int index2 = index * index;
FOR_ALL_ELEMENTS_IN_FFTW_TRANSFORM(FT)
{
if (kp * kp + ip * ip + jp * jp >= index2)
{
double mag = abs(DIRECT_A3D_ELEM(FT, k, i, j));
double phas = rnd_unif(0., 2.*PI);
double realval = mag * cos(phas);
double imagval = mag * sin(phas);
DIRECT_A3D_ELEM(FT, k, i, j) = Complex(realval, imagval);
}
}
// Inverse transform
transformer.inverseFourierTransform();
}
void Postprocessing::sharpenMap()
{
MultidimArray<Complex > FT;
FourierTransformer transformer;
transformer.FourierTransform(I1(), FT, true);
makeGuinierPlot(FT, guinierin);
// A. If MTF curve is given, first divide by the MTF
divideByMtf(FT);
makeGuinierPlot(FT, guinierinvmtf);
// B. Then perform B-factor sharpening
if (do_fsc_weighting)
{
if (verb > 0)
{
std::cout <<"== Applying sqrt(2*FSC/(FSC+1)) weighting (as in Rosenthal & Henderson, 2003) ..." <<std::endl;
}
applyFscWeighting(FT, fsc_true);
}
makeGuinierPlot(FT, guinierweighted);
global_bfactor = 0.;
if (do_auto_bfac)
{
if (verb > 0)
{
std::cout <<"== Fitting straight line through Guinier plot to find B-factor ..." <<std::endl;
std::cout.width(35); std::cout << std::left <<" + fit from resolution: "; std::cout << fit_minres << std::endl;
std::cout.width(35); std::cout << std::left <<" + fit until resolution: "; std::cout << fit_maxres << std::endl;
}
fitStraightLine(guinierweighted, global_slope, global_intercept, global_corr_coeff);
global_bfactor = 4. * global_slope;
if (verb > 0)
{
std::cout.width(35); std::cout << std::left <<" + slope of fit: "; std::cout << global_slope << std::endl;
std::cout.width(35); std::cout << std::left <<" + intercept of fit: "; std::cout << global_intercept << std::endl;
std::cout.width(35); std::cout << std::left <<" + correlation of fit: "; std::cout << global_corr_coeff << std::endl;
}
}
else if (ABS(adhoc_bfac) > 0.)
{
if (verb > 0)
{
std::cout <<"== Using a user-provided (ad-hoc) B-factor ..." <<std::endl;
}
if (adhoc_bfac > 0.)
std::cout <<" WARNING: using a positive B-factor. This will effectively dampen your map. Use negative value to sharpen it!" << std::endl;
global_bfactor = adhoc_bfac;
}
// Now apply the B-factor
if (ABS(global_bfactor) > 0.)
{
if (verb > 0)
{
std::cout.width(35); std::cout << std::left <<" + apply b-factor of: "; std::cout << global_bfactor << std::endl;
}
applyBFactorToMap(FT, XSIZE(I1()), global_bfactor, angpix);
}
makeGuinierPlot(FT, guiniersharpen);
if (verb > 0)
{
std::cout << "== Low-pass filtering final map ... " << std::endl;
}
DOUBLE my_filter = (low_pass_freq > 0.) ? low_pass_freq : global_resol;
if (verb > 0)
{
std::cout.width(35); std::cout << std::left <<" + filter frequency: "; std::cout << my_filter << std::endl;
}
lowPassFilterMap(FT, XSIZE(I1()), my_filter, angpix, filter_edge_width);
transformer.inverseFourierTransform(FT, I1());
}