void Postprocessing::applyFscWeighting(MultidimArray<Complex > &FT, MultidimArray<DOUBLE> my_fsc)
{
// Find resolution where fsc_true drops below zero for the first time
// Set all weights to zero beyond that resolution
int ires_max = 0 ;
FOR_ALL_DIRECT_ELEMENTS_IN_ARRAY1D(my_fsc)
{
if (DIRECT_A1D_ELEM(my_fsc, i) < 1e-10)
break;
ires_max = i;
}
FOR_ALL_ELEMENTS_IN_FFTW_TRANSFORM(FT)
{
int ires = ROUND(sqrt((DOUBLE)kp * kp + ip * ip + jp * jp));
if (ires <= ires_max)
{
DOUBLE fsc = DIRECT_A1D_ELEM(my_fsc, ires);
if (fsc < 1e-10)
REPORT_ERROR("Postprocessing::applyFscWeighting BUG: fsc <= 0");
DIRECT_A3D_ELEM(FT, k, i, j) *= sqrt((2 * fsc) / (1 + fsc));
}
else
{
DIRECT_A3D_ELEM(FT, k, i, j) = 0.;
}
}
}
// Inforce Hermitian symmetry ---------------------------------------------
void FourierTransformer::enforceHermitianSymmetry()
{
int ndim = 3;
if (ZSIZE(*fReal) == 1)
{
ndim = 2;
if (YSIZE(*fReal) == 1)
{
ndim = 1;
}
}
long int yHalf = YSIZE(*fReal) / 2;
if (YSIZE(*fReal) % 2 == 0)
{
yHalf--;
}
long int zHalf = ZSIZE(*fReal) / 2;
if (ZSIZE(*fReal) % 2 == 0)
{
zHalf--;
}
switch (ndim)
{
case 2:
for (long int i = 1; i <= yHalf; i++)
{
long int isym = intWRAP(-i, 0, YSIZE(*fReal) - 1);
Complex mean = 0.5 * (
DIRECT_A2D_ELEM(fFourier, i, 0) +
conj(DIRECT_A2D_ELEM(fFourier, isym, 0)));
DIRECT_A2D_ELEM(fFourier, i, 0) = mean;
DIRECT_A2D_ELEM(fFourier, isym, 0) = conj(mean);
}
break;
case 3:
for (long int k = 0; k < ZSIZE(*fReal); k++)
{
long int ksym = intWRAP(-k, 0, ZSIZE(*fReal) - 1);
for (long int i = 1; i <= yHalf; i++)
{
long int isym = intWRAP(-i, 0, YSIZE(*fReal) - 1);
Complex mean = 0.5 * (
DIRECT_A3D_ELEM(fFourier, k, i, 0) +
conj(DIRECT_A3D_ELEM(fFourier, ksym, isym, 0)));
DIRECT_A3D_ELEM(fFourier, k, i, 0) = mean;
DIRECT_A3D_ELEM(fFourier, ksym, isym, 0) = conj(mean);
}
}
for (long int k = 1; k <= zHalf; k++)
{
long int ksym = intWRAP(-k, 0, ZSIZE(*fReal) - 1);
Complex mean = 0.5 * (
DIRECT_A3D_ELEM(fFourier, k, 0, 0) +
conj(DIRECT_A3D_ELEM(fFourier, ksym, 0, 0)));
DIRECT_A3D_ELEM(fFourier, k, 0, 0) = mean;
DIRECT_A3D_ELEM(fFourier, ksym, 0, 0) = conj(mean);
}
break;
}
}
// Fourier ring correlation -----------------------------------------------
// from precalculated Fourier Transforms, and without sampling rate etc.
void getFSC(MultidimArray< Complex >& FT1,
MultidimArray< Complex >& FT2,
MultidimArray< double >& fsc)
{
if (!FT1.sameShape(FT2))
{
REPORT_ERROR("fourierShellCorrelation ERROR: MultidimArrays have different shapes!");
}
MultidimArray< int > radial_count(XSIZE(FT1));
MultidimArray<double> num, den1, den2;
Matrix1D<double> f(3);
num.initZeros(radial_count);
den1.initZeros(radial_count);
den2.initZeros(radial_count);
fsc.initZeros(radial_count);
FOR_ALL_ELEMENTS_IN_FFTW_TRANSFORM(FT1)
{
int idx = ROUND(sqrt(kp * kp + ip * ip + jp * jp));
if (idx >= XSIZE(FT1))
{
continue;
}
Complex z1 = DIRECT_A3D_ELEM(FT1, k, i, j);
Complex z2 = DIRECT_A3D_ELEM(FT2, k, i, j);
double absz1 = abs(z1);
double absz2 = abs(z2);
num(idx) += (conj(z1) * z2).real;
den1(idx) += absz1 * absz1;
den2(idx) += absz2 * absz2;
radial_count(idx)++;
}
FOR_ALL_ELEMENTS_IN_ARRAY1D(fsc)
{
fsc(i) = num(i) / sqrt(den1(i) * den2(i));
}
}
void Postprocessing::makeGuinierPlot(MultidimArray<Complex > &FT, std::vector<fit_point2D> &guinier)
{
MultidimArray<int> radial_count(XSIZE(FT));
MultidimArray<DOUBLE> lnF(XSIZE(FT));
fit_point2D onepoint;
FOR_ALL_ELEMENTS_IN_FFTW_TRANSFORM(FT)
{
int r2 = kp * kp + ip * ip + jp * jp;
int ires = ROUND(sqrt((DOUBLE)r2));
if (ires < XSIZE(radial_count))
{
lnF(ires) += abs(DIRECT_A3D_ELEM(FT, k, i, j));
radial_count(ires)++;
}
}
DOUBLE xsize = XSIZE(I1());
guinier.clear();
FOR_ALL_ELEMENTS_IN_ARRAY1D(radial_count)
{
DOUBLE res = (xsize * angpix)/(DOUBLE)i; // resolution in Angstrom
if (res >= angpix * 2.) // Apply B-factor sharpening until Nyquist, then low-pass filter later on (with a soft edge)
{
onepoint.x = 1. / (res * res);
if (DIRECT_A1D_ELEM(lnF, i) > 0.)
{
onepoint.y = log ( DIRECT_A1D_ELEM(lnF, i) / DIRECT_A1D_ELEM(radial_count, i) );
if (res <= fit_minres && res >= fit_maxres)
{
onepoint.w = 1.;
}
else
{
onepoint.w = 0.;
}
}
else
{
onepoint.y = -99.;
onepoint.w = 0.;
}
//std::cerr << " onepoint.x= " << onepoint.x << " onepoint.y= " << onepoint.y << " onepoint.w= " << onepoint.w << std::endl;
guinier.push_back(onepoint);
}
}
}
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 Steerable::singleFilter(const MultidimArray<double>& Vin,
MultidimArray<double> &hx1, MultidimArray<double> &hy1, MultidimArray<double> &hz1,
MultidimArray<double> &Vout){
MultidimArray< std::complex<double> > H, Aux;
Vout.initZeros(Vin);
// Filter in X
#define MINUS_ONE_POWER(n) (((n)%2==0)? 1:-1)
FourierTransformer transformer;
transformer.FourierTransform(hx1,H);
FOR_ALL_ELEMENTS_IN_ARRAY1D(H)
H(i)*= MINUS_ONE_POWER(i);
FourierTransformer transformer2;
MultidimArray<double> aux(XSIZE(Vin));
transformer2.setReal(aux);
for (size_t k=0; k<ZSIZE(Vin); k++)
for (size_t i=0; i<YSIZE(Vin); i++)
{
for (size_t j=0; j<XSIZE(Vin); j++)
DIRECT_A1D_ELEM(aux,j)=DIRECT_A3D_ELEM(Vin,k,i,j);
transformer2.FourierTransform( );
transformer2.getFourierAlias( Aux );
Aux*=H;
transformer2.inverseFourierTransform( );
for (size_t j=0; j<XSIZE(Vin); j++)
DIRECT_A3D_ELEM(Vout,k,i,j)=XSIZE(aux)*DIRECT_A1D_ELEM(aux,j);
}
// Filter in Y
transformer.FourierTransform(hy1,H);
FOR_ALL_ELEMENTS_IN_ARRAY1D(H)
H(i)*= MINUS_ONE_POWER(i);
aux.initZeros(YSIZE(Vin));
transformer2.setReal(aux);
for (size_t k=0; k<ZSIZE(Vin); k++)
for (size_t j=0; j<XSIZE(Vin); j++)
{
for (size_t i=0; i<YSIZE(Vin); i++)
DIRECT_A1D_ELEM(aux,i)=DIRECT_A3D_ELEM(Vout,k,i,j);
transformer2.FourierTransform( );
transformer2.getFourierAlias( Aux );
Aux*=H;
transformer2.inverseFourierTransform( );
for (size_t i=0; i<YSIZE(Vin); i++)
DIRECT_A3D_ELEM(Vout,k,i,j)=XSIZE(aux)*DIRECT_A1D_ELEM(aux,i);
}
// Filter in Z
transformer.FourierTransform(hz1,H);
FOR_ALL_ELEMENTS_IN_ARRAY1D(H)
H(i)*= MINUS_ONE_POWER(i);
aux.initZeros(ZSIZE(Vin));
transformer2.setReal(aux);
for (size_t i=0; i<YSIZE(Vin); i++)
for (size_t j=0; j<XSIZE(Vin); j++)
{
for (size_t k=0; k<ZSIZE(Vin); k++)
DIRECT_A1D_ELEM(aux,k)=DIRECT_A3D_ELEM(Vout,k,i,j);
transformer2.FourierTransform( );
transformer2.getFourierAlias( Aux );
Aux*=H;
transformer2.inverseFourierTransform( );
for (size_t k=0; k<ZSIZE(Vin); k++)
DIRECT_A3D_ELEM(Vout,k,i,j)=XSIZE(aux)*DIRECT_A1D_ELEM(aux,k);
}
// If Missing wedge
if (MW!=NULL)
MW->removeWedge(Vout);
}
/** Kullback-Leibner divergence */
double getKullbackLeibnerDivergence(MultidimArray<Complex >& Fimg,
MultidimArray<Complex >& Fref, MultidimArray<double>& sigma2,
MultidimArray<double>& p_i, MultidimArray<double>& q_i, int highshell, int lowshell)
{
// First check dimensions are OK
if (!Fimg.sameShape(Fref))
{
REPORT_ERROR("getKullbackLeibnerDivergence ERROR: Fimg and Fref are not of the same shape.");
}
if (highshell < 0)
{
highshell = XSIZE(Fimg) - 1;
}
if (lowshell < 0)
{
lowshell = 0;
}
if (highshell > XSIZE(sigma2))
{
REPORT_ERROR("getKullbackLeibnerDivergence ERROR: highshell is larger than size of sigma2 array.");
}
if (highshell < lowshell)
{
REPORT_ERROR("getKullbackLeibnerDivergence ERROR: highshell is smaller than lowshell.");
}
// Initialize the histogram
MultidimArray<int> histogram;
int histogram_size = 101;
int histogram_origin = histogram_size / 2;
double sigma_max = 10.;
double histogram_factor = histogram_origin / sigma_max;
histogram.initZeros(histogram_size);
// This way this will work in both 2D and 3D
FOR_ALL_ELEMENTS_IN_FFTW_TRANSFORM(Fimg)
{
int ires = ROUND(sqrt(kp * kp + ip * ip + jp * jp));
if (ires >= lowshell && ires <= highshell)
{
// Use FT of masked image for noise estimation!
double diff_real = (DIRECT_A3D_ELEM(Fref, k, i, j)).real - (DIRECT_A3D_ELEM(Fimg, k, i, j)).real;
double diff_imag = (DIRECT_A3D_ELEM(Fref, k, i, j)).imag - (DIRECT_A3D_ELEM(Fimg, k, i, j)).imag;
double sigma = sqrt(DIRECT_A1D_ELEM(sigma2, ires));
// Divide by standard deviation to normalise all the difference
diff_real /= sigma;
diff_imag /= sigma;
// Histogram runs from -10 sigma to +10 sigma
diff_real += sigma_max;
diff_imag += sigma_max;
// Make histogram on-the-fly;
// Real part
int ihis = ROUND(diff_real * histogram_factor);
if (ihis < 0)
{
ihis = 0;
}
else if (ihis >= histogram_size)
{
ihis = histogram_size - 1;
}
histogram(ihis)++;
// Imaginary part
ihis = ROUND(diff_imag * histogram_factor);
if (ihis < 0)
{
ihis = 0;
}
else if (ihis > histogram_size)
{
ihis = histogram_size;
}
histogram(ihis)++;
}
}
// Normalise the histogram and the discretised analytical Gaussian
double norm = (double)histogram.sum();
double gaussnorm = 0.;
for (int i = 0; i < histogram_size; i++)
{
double x = (double)i / histogram_factor;
gaussnorm += gaussian1D(x - sigma_max, 1. , 0.);
}
// Now calculate the actual Kullback-Leibner divergence
double kl_divergence = 0.;
p_i.resize(histogram_size);
q_i.resize(histogram_size);
for (int i = 0; i < histogram_size; i++)
{
// Data distribution
p_i(i) = (double)histogram(i) / norm;
// Theoretical distribution
double x = (double)i / histogram_factor;
q_i(i) = gaussian1D(x - sigma_max, 1. , 0.) / gaussnorm;
if (p_i(i) > 0.)
{
kl_divergence += p_i(i) * log(p_i(i) / q_i(i));
}
}
kl_divergence /= (double)histogram_size;
return kl_divergence;
}
// Shift an image through phase-shifts in its Fourier Transform (without pretabulated sine and cosine)
void shiftImageInFourierTransform(MultidimArray<Complex >& in,
MultidimArray<Complex >& out,
double oridim, Matrix1D<double> shift)
{
out.resize(in);
shift /= -oridim;
double dotp, a, b, c, d, ac, bd, ab_cd, x, y, z, xshift, yshift, zshift;
switch (in.getDim())
{
case 1:
xshift = XX(shift);
if (ABS(xshift) < XMIPP_EQUAL_ACCURACY)
{
out = in;
return;
}
for (long int j = 0; j < XSIZE(in); j++)
{
x = j;
dotp = 2 * PI * (x * xshift);
a = cos(dotp);
b = sin(dotp);
c = DIRECT_A1D_ELEM(in, j).real;
d = DIRECT_A1D_ELEM(in, j).imag;
ac = a * c;
bd = b * d;
ab_cd = (a + b) * (c + d); // (ab_cd-ac-bd = ad+bc : but needs 4 multiplications)
DIRECT_A1D_ELEM(out, j) = Complex(ac - bd, ab_cd - ac - bd);
}
break;
case 2:
xshift = XX(shift);
yshift = YY(shift);
if (ABS(xshift) < XMIPP_EQUAL_ACCURACY && ABS(yshift) < XMIPP_EQUAL_ACCURACY)
{
out = in;
return;
}
for (long int i = 0; i < XSIZE(in); i++)
for (long int j = 0; j < XSIZE(in); j++)
{
x = j;
y = i;
dotp = 2 * PI * (x * xshift + y * yshift);
a = cos(dotp);
b = sin(dotp);
c = DIRECT_A2D_ELEM(in, i, j).real;
d = DIRECT_A2D_ELEM(in, i, j).imag;
ac = a * c;
bd = b * d;
ab_cd = (a + b) * (c + d);
DIRECT_A2D_ELEM(out, i, j) = Complex(ac - bd, ab_cd - ac - bd);
}
for (long int i = YSIZE(in) - 1; i >= XSIZE(in); i--)
{
y = i - YSIZE(in);
for (long int j = 0; j < XSIZE(in); j++)
{
x = j;
dotp = 2 * PI * (x * xshift + y * yshift);
a = cos(dotp);
b = sin(dotp);
c = DIRECT_A2D_ELEM(in, i, j).real;
d = DIRECT_A2D_ELEM(in, i, j).imag;
ac = a * c;
bd = b * d;
ab_cd = (a + b) * (c + d);
DIRECT_A2D_ELEM(out, i, j) = Complex(ac - bd, ab_cd - ac - bd);
}
}
break;
case 3:
xshift = XX(shift);
yshift = YY(shift);
zshift = ZZ(shift);
if (ABS(xshift) < XMIPP_EQUAL_ACCURACY && ABS(yshift) < XMIPP_EQUAL_ACCURACY && ABS(zshift) < XMIPP_EQUAL_ACCURACY)
{
out = in;
return;
}
for (long int k = 0; k < ZSIZE(in); k++)
{
z = (k < XSIZE(in)) ? k : k - ZSIZE(in);
for (long int i = 0; i < YSIZE(in); i++)
{
y = (i < XSIZE(in)) ? i : i - YSIZE(in);
for (long int j = 0; j < XSIZE(in); j++)
{
x = j;
dotp = 2 * PI * (x * xshift + y * yshift + z * zshift);
a = cos(dotp);
b = sin(dotp);
c = DIRECT_A3D_ELEM(in, k, i, j).real;
d = DIRECT_A3D_ELEM(in, k, i, j).imag;
ac = a * c;
bd = b * d;
ab_cd = (a + b) * (c + d);
DIRECT_A3D_ELEM(out, k, i, j) = Complex(ac - bd, ab_cd - ac - bd);
}
}
}
break;
default:
REPORT_ERROR("shiftImageInFourierTransform ERROR: dimension should be 1, 2 or 3!");
}
}
void correctMapForMTF(MultidimArray<Complex >& FT, int ori_size, FileName& fn_mtf)
{
MetaDataTable MDmtf;
if (!fn_mtf.isStarFile())
{
REPORT_ERROR("correctMapForMTF ERROR: input MTF file is not a STAR file.");
}
MDmtf.read(fn_mtf);
MultidimArray<double> mtf_resol, mtf_value;
mtf_resol.resize(MDmtf.numberOfObjects());
mtf_value.resize(mtf_resol);
int i = 0;
FOR_ALL_OBJECTS_IN_METADATA_TABLE(MDmtf)
{
MDmtf.getValue(EMDL_RESOLUTION_INVPIXEL, DIRECT_A1D_ELEM(mtf_resol, i)); // resolution needs to be given in 1/pix
MDmtf.getValue(EMDL_POSTPROCESS_MTF_VALUE, DIRECT_A1D_ELEM(mtf_value, i));
if (DIRECT_A1D_ELEM(mtf_value, i) < 1e-10)
{
std::cerr << " i= " << i << " mtf_value[i]= " << DIRECT_A1D_ELEM(mtf_value, i) << std::endl;
REPORT_ERROR("Postprocessing::sharpenMap ERROR: zero or negative values encountered in MTF curve!");
}
i++;
}
double xsize = (double)ori_size;
FOR_ALL_ELEMENTS_IN_FFTW_TRANSFORM(FT)
{
int r2 = kp * kp + ip * ip + jp * jp;
double res = sqrt((double)r2) / xsize; // get resolution in 1/pixel
if (res < 0.5)
{
// Find the suitable MTF value
int i_0 = 0;
for (int ii = 0; ii < XSIZE(mtf_resol); ii++)
{
if (DIRECT_A1D_ELEM(mtf_resol, ii) > res)
{
break;
}
i_0 = ii;
}
// linear interpolation: y = y_0 + (y_1 - y_0)*(x-x_0)/(x1_x0)
double mtf;
double x_0 = DIRECT_A1D_ELEM(mtf_resol, i_0);
if (i_0 == MULTIDIM_SIZE(mtf_resol) - 1 || i_0 == 0) // check boundaries of the array
{
mtf = DIRECT_A1D_ELEM(mtf_value, i_0);
}
else
{
double x_1 = DIRECT_A1D_ELEM(mtf_resol, i_0 + 1);
double y_0 = DIRECT_A1D_ELEM(mtf_value, i_0);
double y_1 = DIRECT_A1D_ELEM(mtf_value, i_0 + 1);
mtf = y_0 + (y_1 - y_0) * (res - x_0) / (x_1 - x_0);
}
// Divide Fourier component by the MTF
DIRECT_A3D_ELEM(FT, k, i, j) /= mtf;
}
}
}
void ProbabilisticPCA::reduceDimensionality()
{
size_t N=MAT_YSIZE(*X); // N= number of rows of X
size_t D=MAT_XSIZE(*X); // D= number of columns of X
bool converged=false;
size_t iter=0;
double sigma2=rnd_unif()*2;
double Q=MAXDOUBLE, oldQ;
Matrix2D<double> S, W, inW, invM, Ez, WtX, Wp1, Wp2, invWp2, WinvM, WinvMWt, WtSDIW, invCS;
// Compute variance and row energy
subtractColumnMeans(*X);
matrixOperation_AtA(*X,S);
S/=(double)N;
Matrix1D<double> normX;
X->rowEnergySum(normX);
W.initRandom(D,outputDim,0,2,RND_UNIFORM);
matrixOperation_AtA(W,inW);
MultidimArray <double> Ezz(N,outputDim,outputDim);
while (!converged && iter<=Niters)
{
++iter;
// Perform E-step
// Ez=(W^t*W)^-1*W^t*X^t
for (size_t i=0; i<outputDim; ++i)
MAT_ELEM(inW,i,i)+=sigma2;
inW.inv(invM);
matrixOperation_AtBt(W,*X,WtX);
matrixOperation_AB(invM,WtX,Ez);
for (size_t k=0; k<N; ++k)
FOR_ALL_ELEMENTS_IN_MATRIX2D(invM)
DIRECT_A3D_ELEM(Ezz,k,i,j)=MAT_ELEM(invM,i,j)*sigma2+MAT_ELEM(Ez,i,k)*MAT_ELEM(Ez,j,k);
// Perform M-step (maximize mapping W)
Wp1.initZeros(D,outputDim);
Wp2.initZeros(outputDim,outputDim);
for (size_t k=0; k<N; ++k)
{
FOR_ALL_ELEMENTS_IN_MATRIX2D(Wp1)
MAT_ELEM(Wp1,i,j)+=MAT_ELEM(*X,k,i)*MAT_ELEM(Ez,j,k);
FOR_ALL_ELEMENTS_IN_MATRIX2D(Wp2)
MAT_ELEM(Wp2,i,j)+=DIRECT_A3D_ELEM(Ezz,k,i,j);
}
Wp2.inv(invWp2);
matrixOperation_AB(Wp1,invWp2,W);
matrixOperation_AtA(W,inW);
// Update sigma2
double sigma2_new=0;
for (size_t k=0; k<N; ++k){
double EzWtX=0;
FOR_ALL_ELEMENTS_IN_MATRIX2D(W)
EzWtX+=MAT_ELEM(*X,k,i)*MAT_ELEM(W,i,j)*MAT_ELEM(Ez,j,k);
double t=0;
for (size_t i = 0; i < outputDim; ++i)
{
double aux=0.;
for (size_t kk = 0; kk < outputDim; ++kk)
aux += DIRECT_A3D_ELEM(Ezz,k,i,kk) * MAT_ELEM(inW, kk, i);
t+=aux;
}
sigma2_new += VEC_ELEM(normX,k) - 2 * EzWtX + t;
}
sigma2_new/=(double) N * (double) D;
//Compute likelihood of new model
oldQ = Q;
if (iter > 1)
{
matrixOperation_AB(W,invM,WinvM);
matrixOperation_ABt(WinvM,W,WinvMWt);
matrixOperation_IminusA(WinvMWt);
WinvMWt*=1/sigma2_new;
matrixOperation_AtA(W,WtSDIW);
WtSDIW*=1/sigma2_new;
matrixOperation_IplusA(WtSDIW);
double detC = pow(sigma2_new,D)* WtSDIW.det();
matrixOperation_AB(WinvMWt,S,invCS);
Q = (N*(-0.5)) * (D * log (2*PI) + log(detC) + invCS.trace());
}
// Stop condition to detect convergence
// Must not apply to the first iteration, because then it will end inmediately
if (iter>2 && abs(oldQ-Q) < 0.001)
converged=true;
sigma2=sigma2_new;
}
//mapping.M = (inW \ W')';
matrixOperation_ABt(W,inW.inv(),A);
matrixOperation_AB(*X,A,Y);
if (fnMapping!="")
A.write(fnMapping);
}
// Fill data array with oversampled Fourier transform, and calculate its power spectrum
void Projector::computeFourierTransformMap(MultidimArray<DOUBLE> &vol_in, MultidimArray<DOUBLE> &power_spectrum, int current_size, int nr_threads, bool do_gridding)
{
MultidimArray<DOUBLE> Mpad;
MultidimArray<Complex > Faux;
FourierTransformer transformer;
// DEBUGGING: multi-threaded FFTWs are giving me a headache?
// For a long while: switch them off!
//transformer.setThreadsNumber(nr_threads);
DOUBLE normfft;
// Size of padded real-space volume
int padoridim = padding_factor * ori_size;
// Initialize data array of the oversampled transform
ref_dim = vol_in.getDim();
// Make Mpad
switch (ref_dim)
{
case 2:
Mpad.initZeros(padoridim, padoridim);
normfft = (DOUBLE)(padding_factor * padding_factor);
break;
case 3:
Mpad.initZeros(padoridim, padoridim, padoridim);
if (data_dim ==3)
normfft = (DOUBLE)(padding_factor * padding_factor * padding_factor);
else
normfft = (DOUBLE)(padding_factor * padding_factor * padding_factor * ori_size);
break;
default:
REPORT_ERROR("Projector::computeFourierTransformMap%%ERROR: Dimension of the data array should be 2 or 3");
}
// First do a gridding pre-correction on the real-space map:
// Divide by the inverse Fourier transform of the interpolator in Fourier-space
// 10feb11: at least in 2D case, this seems to be the wrong thing to do!!!
// TODO: check what is best for subtomo!
if (do_gridding)// && data_dim != 3)
griddingCorrect(vol_in);
// Pad translated map with zeros
vol_in.setXmippOrigin();
Mpad.setXmippOrigin();
FOR_ALL_ELEMENTS_IN_ARRAY3D(vol_in) // This will also work for 2D
A3D_ELEM(Mpad, k, i, j) = A3D_ELEM(vol_in, k, i, j);
// Translate padded map to put origin of FT in the center
CenterFFT(Mpad, true);
// Calculate the oversampled Fourier transform
transformer.FourierTransform(Mpad, Faux, false);
// Free memory: Mpad no longer needed
Mpad.clear();
// Resize data array to the right size and initialise to zero
initZeros(current_size);
// Fill data only for those points with distance to origin less than max_r
// (other points will be zero because of initZeros() call above
// Also calculate radial power spectrum
power_spectrum.initZeros(ori_size / 2 + 1);
MultidimArray<DOUBLE> counter(power_spectrum);
counter.initZeros();
int max_r2 = r_max * r_max * padding_factor * padding_factor;
FOR_ALL_ELEMENTS_IN_FFTW_TRANSFORM(Faux) // This will also work for 2D
{
int r2 = kp*kp + ip*ip + jp*jp;
// The Fourier Transforms are all "normalised" for 2D transforms of size = ori_size x ori_size
if (r2 <= max_r2)
{
// Set data array
A3D_ELEM(data, kp, ip, jp) = DIRECT_A3D_ELEM(Faux, k, i, j) * normfft;
// Calculate power spectrum
int ires = ROUND( sqrt((DOUBLE)r2) / padding_factor );
// Factor two because of two-dimensionality of the complex plane
DIRECT_A1D_ELEM(power_spectrum, ires) += norm(A3D_ELEM(data, kp, ip, jp)) / 2.;
DIRECT_A1D_ELEM(counter, ires) += 1.;
}
}
// Calculate radial average of power spectrum
FOR_ALL_DIRECT_ELEMENTS_IN_ARRAY1D(power_spectrum)
{
if (DIRECT_A1D_ELEM(counter, i) < 1.)
DIRECT_A1D_ELEM(power_spectrum, i) = 0.;
else
DIRECT_A1D_ELEM(power_spectrum, i) /= DIRECT_A1D_ELEM(counter, i);
}
transformer.cleanup();
}
void Projector::rotate3D(MultidimArray<Complex > &f3d, Matrix2D<DOUBLE> &A, bool inv)
{
DOUBLE fx, fy, fz, xp, yp, zp;
int x0, x1, y0, y1, z0, z1, y, z, y2, z2, r2;
bool is_neg_x;
Complex d000, d010, d100, d110, d001, d011, d101, d111, dx00, dx10, dxy0, dx01, dx11, dxy1;
Matrix2D<DOUBLE> Ainv;
// f3d should already be in the right size (ori_size,orihalfdim)
// AND the points outside max_r should already be zero...
// f3d.initZeros();
// Use the inverse matrix
if (inv)
Ainv = A;
else
Ainv = A.transpose();
// The f3d image may be smaller than r_max, in that case also make sure not to fill the corners!
int my_r_max = XMIPP_MIN(r_max, XSIZE(f3d) - 1);
// Go from the 3D rotated coordinates to the original map coordinates
Ainv *= (DOUBLE)padding_factor; // take scaling into account directly
int max_r2 = my_r_max * my_r_max;
int min_r2_nn = r_min_nn * r_min_nn;
#ifdef DEBUG
std::cerr << " XSIZE(f3d)= "<< XSIZE(f3d) << std::endl;
std::cerr << " YSIZE(f3d)= "<< YSIZE(f3d) << std::endl;
std::cerr << " XSIZE(data)= "<< XSIZE(data) << std::endl;
std::cerr << " YSIZE(data)= "<< YSIZE(data) << std::endl;
std::cerr << " STARTINGX(data)= "<< STARTINGX(data) << std::endl;
std::cerr << " STARTINGY(data)= "<< STARTINGY(data) << std::endl;
std::cerr << " STARTINGZ(data)= "<< STARTINGZ(data) << std::endl;
std::cerr << " max_r= "<< r_max << std::endl;
std::cerr << " Ainv= " << Ainv << std::endl;
#endif
for (int k=0; k < ZSIZE(f3d); k++)
{
// Don't search beyond square with side max_r
if (k <= my_r_max)
{
z = k;
}
else if (k >= ZSIZE(f3d) - my_r_max)
{
z = k - ZSIZE(f3d);
}
else
continue;
z2 = z * z;
for (int i=0; i < YSIZE(f3d); i++)
{
// Don't search beyond square with side max_r
if (i <= my_r_max)
{
y = i;
}
else if (i >= YSIZE(f3d) - my_r_max)
{
y = i - YSIZE(f3d);
}
else
continue;
y2 = y * y;
for (int x=0; x <= my_r_max; x++)
{
// Only include points with radius < max_r (exclude points outside circle in square)
r2 = x * x + y2 + z2;
if (r2 > max_r2)
continue;
// Get logical coordinates in the 3D map
xp = Ainv(0,0) * x + Ainv(0,1) * y + Ainv(0,2) * z;
yp = Ainv(1,0) * x + Ainv(1,1) * y + Ainv(1,2) * z;
zp = Ainv(2,0) * x + Ainv(2,1) * y + Ainv(2,2) * z;
if (interpolator == TRILINEAR || r2 < min_r2_nn)
{
// Only asymmetric half is stored
if (xp < 0)
{
// Get complex conjugated hermitian symmetry pair
xp = -xp;
yp = -yp;
zp = -zp;
is_neg_x = true;
}
else
{
is_neg_x = false;
}
// Trilinear interpolation (with physical coords)
// Subtract STARTINGY to accelerate access to data (STARTINGX=0)
// In that way use DIRECT_A3D_ELEM, rather than A3D_ELEM
x0 = FLOOR(xp);
fx = xp - x0;
x1 = x0 + 1;
y0 = FLOOR(yp);
fy = yp - y0;
y0 -= STARTINGY(data);
y1 = y0 + 1;
z0 = FLOOR(zp);
fz = zp - z0;
z0 -= STARTINGZ(data);
z1 = z0 + 1;
// Matrix access can be accelerated through pre-calculation of z0*xydim etc.
d000 = DIRECT_A3D_ELEM(data, z0, y0, x0);
d001 = DIRECT_A3D_ELEM(data, z0, y0, x1);
d010 = DIRECT_A3D_ELEM(data, z0, y1, x0);
d011 = DIRECT_A3D_ELEM(data, z0, y1, x1);
d100 = DIRECT_A3D_ELEM(data, z1, y0, x0);
d101 = DIRECT_A3D_ELEM(data, z1, y0, x1);
d110 = DIRECT_A3D_ELEM(data, z1, y1, x0);
d111 = DIRECT_A3D_ELEM(data, z1, y1, x1);
// Set the interpolated value in the 2D output array
// interpolate in x
#ifndef FLOAT_PRECISION
__m256d __fx = _mm256_set1_pd(fx);
__m256d __interpx1 = LIN_INTERP_AVX(_mm256_setr_pd(d000.real, d000.imag, d100.real, d100.imag),
_mm256_setr_pd(d001.real, d001.imag, d101.real, d101.imag),
__fx);
__m256d __interpx2 = LIN_INTERP_AVX(_mm256_setr_pd(d010.real, d010.imag, d110.real, d110.imag),
_mm256_setr_pd(d011.real, d011.imag, d111.real, d111.imag),
__fx);
// interpolate in y
__m256d __fy = _mm256_set1_pd(fy);
__m256d __interpy = LIN_INTERP_AVX(__interpx1, __interpx2, __fy);
#else
__m128 __fx = _mm_set1_ps(fx);
__m128 __interpx1 = LIN_INTERP_AVX(_mm_setr_ps(d000.real, d000.imag, d100.real, d100.imag),
_mm_setr_ps(d001.real, d001.imag, d101.real, d101.imag),
__fx);
__m128 __interpx2 = LIN_INTERP_AVX(_mm_setr_ps(d010.real, d010.imag, d110.real, d110.imag),
_mm_setr_ps(d011.real, d011.imag, d111.real, d111.imag),
__fx);
// interpolate in y
__m128 __fy = _mm_set1_ps(fy);
__m128 __interpy = LIN_INTERP_AVX(__interpx1, __interpx2, __fy);
#endif
Complex* interpy = (Complex*)&__interpy;
//interpolate in z
DIRECT_A3D_ELEM(f3d, k, i, x) = LIN_INTERP(fz, interpy[0], interpy[1]);
// Take complex conjugated for half with negative x
if (is_neg_x)
DIRECT_A3D_ELEM(f3d, k, i, x) = conj(DIRECT_A3D_ELEM(f3d, k, i, x));
} // endif TRILINEAR
else if (interpolator == NEAREST_NEIGHBOUR )
{
x0 = ROUND(xp);
y0 = ROUND(yp);
z0 = ROUND(zp);
if (x0 < 0)
DIRECT_A3D_ELEM(f3d, k, i, x) = conj(A3D_ELEM(data, -z0, -y0, -x0));
else
DIRECT_A3D_ELEM(f3d, k, i, x) = A3D_ELEM(data, z0, y0, x0);
} // endif NEAREST_NEIGHBOUR
else
REPORT_ERROR("Unrecognized interpolator in Projector::project");
} // endif x-loop
} // endif y-loop
} // endif z-loop
}
void FourierProjector::project(double rot, double tilt, double psi, const MultidimArray<double> *ctf)
{
double freqy, freqx;
std::complex< double > f;
Euler_angles2matrix(rot,tilt,psi,E);
projectionFourier.initZeros();
double maxFreq2=maxFrequency*maxFrequency;
int Xdim=(int)XSIZE(VfourierRealCoefs);
int Ydim=(int)YSIZE(VfourierRealCoefs);
int Zdim=(int)ZSIZE(VfourierRealCoefs);
for (size_t i=0; i<YSIZE(projectionFourier); ++i)
{
FFT_IDX2DIGFREQ(i,volumeSize,freqy);
double freqy2=freqy*freqy;
double freqYvol_X=MAT_ELEM(E,1,0)*freqy;
double freqYvol_Y=MAT_ELEM(E,1,1)*freqy;
double freqYvol_Z=MAT_ELEM(E,1,2)*freqy;
for (size_t j=0; j<XSIZE(projectionFourier); ++j)
{
// The frequency of pairs (i,j) in 2D
FFT_IDX2DIGFREQ(j,volumeSize,freqx);
// Do not consider pixels with high frequency
if ((freqy2+freqx*freqx)>maxFreq2)
continue;
// Compute corresponding frequency in the volume
double freqvol_X=freqYvol_X+MAT_ELEM(E,0,0)*freqx;
double freqvol_Y=freqYvol_Y+MAT_ELEM(E,0,1)*freqx;
double freqvol_Z=freqYvol_Z+MAT_ELEM(E,0,2)*freqx;
double c,d;
if (BSplineDeg==0)
{
// 0 order interpolation
// Compute corresponding index in the volume
int kVolume=(int)round(freqvol_Z*volumePaddedSize);
int iVolume=(int)round(freqvol_Y*volumePaddedSize);
int jVolume=(int)round(freqvol_X*volumePaddedSize);
c = A3D_ELEM(VfourierRealCoefs,kVolume,iVolume,jVolume);
d = A3D_ELEM(VfourierImagCoefs,kVolume,iVolume,jVolume);
}
else if (BSplineDeg==1)
{
// B-spline linear interpolation
double kVolume=freqvol_Z*volumePaddedSize;
double iVolume=freqvol_Y*volumePaddedSize;
double jVolume=freqvol_X*volumePaddedSize;
c=VfourierRealCoefs.interpolatedElement3D(jVolume,iVolume,kVolume);
d=VfourierImagCoefs.interpolatedElement3D(jVolume,iVolume,kVolume);
}
else
{
// B-spline cubic interpolation
double kVolume=freqvol_Z*volumePaddedSize;
double iVolume=freqvol_Y*volumePaddedSize;
double jVolume=freqvol_X*volumePaddedSize;
// Commented for speed-up, the corresponding code is below
// c=VfourierRealCoefs.interpolatedElementBSpline3D(jVolume,iVolume,kVolume);
// d=VfourierImagCoefs.interpolatedElementBSpline3D(jVolume,iVolume,kVolume);
// The code below is a replicate for speed reasons of interpolatedElementBSpline3D
double z=kVolume;
double y=iVolume;
double x=jVolume;
// Logical to physical
z -= STARTINGZ(VfourierRealCoefs);
y -= STARTINGY(VfourierRealCoefs);
x -= STARTINGX(VfourierRealCoefs);
int l1 = (int)ceil(x - 2);
int l2 = l1 + 3;
int m1 = (int)ceil(y - 2);
int m2 = m1 + 3;
int n1 = (int)ceil(z - 2);
int n2 = n1 + 3;
c = d = 0.0;
double aux;
for (int nn = n1; nn <= n2; nn++)
{
int equivalent_nn=nn;
if (nn<0)
equivalent_nn=-nn-1;
else if (nn>=Zdim)
equivalent_nn=2*Zdim-nn-1;
double yxsumRe = 0.0, yxsumIm = 0.0;
for (int m = m1; m <= m2; m++)
{
int equivalent_m=m;
if (m<0)
equivalent_m=-m-1;
else if (m>=Ydim)
equivalent_m=2*Ydim-m-1;
double xsumRe = 0.0, xsumIm = 0.0;
for (int l = l1; l <= l2; l++)
{
double xminusl = x - (double) l;
int equivalent_l=l;
if (l<0)
equivalent_l=-l-1;
else if (l>=Xdim)
equivalent_l=2*Xdim-l-1;
double CoeffRe = (double) DIRECT_A3D_ELEM(VfourierRealCoefs,equivalent_nn,equivalent_m,equivalent_l);
double CoeffIm = (double) DIRECT_A3D_ELEM(VfourierImagCoefs,equivalent_nn,equivalent_m,equivalent_l);
BSPLINE03(aux,xminusl);
xsumRe += CoeffRe * aux;
xsumIm += CoeffIm * aux;
}
double yminusm = y - (double) m;
BSPLINE03(aux,yminusm);
yxsumRe += xsumRe * aux;
yxsumIm += xsumIm * aux;
}
double zminusn = z - (double) nn;
BSPLINE03(aux,zminusn);
c += yxsumRe * aux;
d += yxsumIm * aux;
}
}
// Phase shift to move the origin of the image to the corner
double a=DIRECT_A2D_ELEM(phaseShiftImgA,i,j);
double b=DIRECT_A2D_ELEM(phaseShiftImgB,i,j);
if (ctf!=NULL)
{
double ctfij=DIRECT_A2D_ELEM(*ctf,i,j);
a*=ctfij;
b*=ctfij;
}
// Multiply Fourier coefficient in volume times phase shift
double ac = a * c;
double bd = b * d;
double ab_cd = (a + b) * (c + d);
// And store the multiplication
double *ptrI_ij=(double *)&DIRECT_A2D_ELEM(projectionFourier,i,j);
*ptrI_ij = ac - bd;
*(ptrI_ij+1) = ab_cd - ac - bd;
}
}
transformer2D.inverseFourierTransform();
}
//#define DEBUG
void ProgResolutionIBW::run()
{
V.read(fnVol);
//Mask generation
Image<double> aux;
double bg_mean;
MultidimArray<double> Vmask;
detectBackground(V(),aux(),0.1,bg_mean);
#ifdef DEBUG
aux.write("PPPmask_no_ero_03.vol");
#endif
//Mask volume erosion to expand the mask boundaries
Vmask.initZeros(V());
erode3D(aux(),Vmask, 18,0,2);
//Correction of some flaws produced in the edges of the mask volume
FOR_ALL_DIRECT_ELEMENTS_IN_ARRAY3D(Vmask)
if (k<=4 || i<=4 || j<=4 ||
k>=ZSIZE(Vmask)-4 || i>=YSIZE(Vmask)-4 || j>=XSIZE(Vmask)-4)
DIRECT_A3D_ELEM(Vmask,k,i,j)=1;
aux()=Vmask;
#ifdef DEBUG
aux.write("PPPmask_ero_03.vol");
#endif
//Sobel edge detection applied to original volume
Image<double> Vedge;
computeEdges(V(),Vedge());
#ifdef DEBUG
Vedge.write("PPPvolume_sobel_unmask_03.vol");
#endif
//Masked volume generation
const MultidimArray<double> &mVedge=Vedge();
FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY(mVedge)
if (DIRECT_MULTIDIM_ELEM(Vmask,n)==1)
DIRECT_MULTIDIM_ELEM(mVedge,n)=0;
#ifdef DEBUG
Vedge.write("volume_sobel_mask_03.vol");
#endif
double minval, maxval, avg, stddev;
//Invert the mask to meet computeStats_within_binary_mask requirements
FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY(Vmask)
if (DIRECT_MULTIDIM_ELEM(Vmask,n)==1)
DIRECT_MULTIDIM_ELEM(Vmask,n)=0;
else
DIRECT_MULTIDIM_ELEM(Vmask,n)=1;
//Threshold is 3 times the standard deviation of unmasked pixel values
double thresh;
computeStats_within_binary_mask(Vmask,mVedge,minval, maxval, avg, stddev);
thresh=3*stddev;
//Final edge volume generated by setting to 1 positions with values > threshold
Image<double> Vaux;
Vaux().initZeros(mVedge);
FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY(mVedge)
if (DIRECT_MULTIDIM_ELEM(mVedge,n)>=thresh)
DIRECT_MULTIDIM_ELEM(Vaux(),n)=1;
#ifdef DEBUG
Vaux.write("volumen_bordes_definitivo_03.vol");
#endif
const MultidimArray<double> &mVaux=Vaux();
//Spline coefficient volume from original volume, to allow <1 step sizes
MultidimArray<double> Volcoeffs;
Volcoeffs.initZeros(V());
produceSplineCoefficients(3,Volcoeffs,V());
//Width parameter volume initialization
Image<double> widths;
widths().resizeNoCopy(V());
widths().initConstant(1e5);
double step=0.25;
Matrix1D<double> direction(3);
//Calculation of edge width for 10 different directions, if a smaller value is found for a different
//direction on a given position the former value is overwritten
//Direction (1,0,0)
VECTOR_R3(direction,1,0,0);
edgeWidth(Volcoeffs, mVaux, widths(), direction, step);
//Direction (0,1,0)
VECTOR_R3(direction,0,1,0);
edgeWidth(Volcoeffs, mVaux, widths(), direction, step);
//Direction (0,0,1)
VECTOR_R3(direction,0,0,1);
edgeWidth(Volcoeffs, mVaux, widths(), direction, step);
//Direction (1,1,0)
VECTOR_R3(direction,(1/sqrt(2)),(1/sqrt(2)),0);
edgeWidth(Volcoeffs, mVaux, widths(), direction, step);
//Direction (1,0,1)
VECTOR_R3(direction,(1/sqrt(2)),0,(1/sqrt(2)));
edgeWidth(Volcoeffs, mVaux, widths(), direction, step);
//Direction (0,1,1)
VECTOR_R3(direction,0,(1/sqrt(2)),(1/sqrt(2)));
edgeWidth(Volcoeffs, mVaux, widths(), direction, step);
//Direction (1,1,1)
VECTOR_R3(direction,(1/sqrt(3)),(1/sqrt(3)),(1/sqrt(3)));
edgeWidth(Volcoeffs, mVaux, widths(), direction, step);
//Direction (-1,1,1)
VECTOR_R3(direction,-(1/sqrt(3)),(1/sqrt(3)),(1/sqrt(3)));
edgeWidth(Volcoeffs, mVaux, widths(), direction, step);
//Direction (1,1,-1)
VECTOR_R3(direction,(1/sqrt(3)),(1/sqrt(3)),-(1/sqrt(3)));
edgeWidth(Volcoeffs, mVaux, widths(), direction, step);
//Direction (1,-1,1)
VECTOR_R3(direction,(1/sqrt(3)),-(1/sqrt(3)),(1/sqrt(3)));
edgeWidth(Volcoeffs, mVaux, widths(), direction, step);
#ifdef DEBUG
std::cout << "width stats: ";
widths().printStats();
std::cout << std::endl;
widths.write("PPPwidths.vol");
#endif
double ibw=calculateIBW(widths());
std::cout << "Resolution ibw= " << ibw << std::endl;
if (fnOut!="")
widths.write(fnOut);
}
void Postprocessing::divideByMtf(MultidimArray<Complex > &FT)
{
if (fn_mtf != "")
{
if (verb > 0)
{
std::cout << "== Dividing map by the MTF of the detector ..." << std::endl;
std::cout.width(35); std::cout << std::left <<" + mtf STAR-file: "; std::cout << fn_mtf << std::endl;
}
MetaDataTable MDmtf;
if (!fn_mtf.isStarFile())
REPORT_ERROR("Postprocessing::divideByMtf ERROR: input MTF file is not a STAR file.");
MDmtf.read(fn_mtf);
MultidimArray<DOUBLE> mtf_resol, mtf_value;
mtf_resol.resize(MDmtf.numberOfObjects());
mtf_value.resize(mtf_resol);
int i =0;
FOR_ALL_OBJECTS_IN_METADATA_TABLE(MDmtf)
{
MDmtf.getValue(EMDL_RESOLUTION_INVPIXEL, DIRECT_A1D_ELEM(mtf_resol, i) ); // resolution needs to be given in 1/pix
MDmtf.getValue(EMDL_POSTPROCESS_MTF_VALUE, DIRECT_A1D_ELEM(mtf_value, i) );
if (DIRECT_A1D_ELEM(mtf_value, i) < 1e-10)
{
std::cerr << " i= " << i << " mtf_value[i]= " << DIRECT_A1D_ELEM(mtf_value, i) << std::endl;
REPORT_ERROR("Postprocessing::sharpenMap ERROR: zero or negative values encountered in MTF curve!");
}
i++;
}
DOUBLE xsize = (DOUBLE)XSIZE(I1());
FOR_ALL_ELEMENTS_IN_FFTW_TRANSFORM(FT)
{
int r2 = kp * kp + ip * ip + jp * jp;
DOUBLE res = sqrt((DOUBLE)r2)/xsize; // get resolution in 1/pixel
if (res < 0.5 )
{
// Find the suitable MTF value
int i_0 = 0;
for (int ii = 0; ii < XSIZE(mtf_resol); ii++)
{
if (DIRECT_A1D_ELEM(mtf_resol, ii) > res)
break;
i_0 = ii;
}
// linear interpolation: y = y_0 + (y_1 - y_0)*(x-x_0)/(x1_x0)
DOUBLE mtf;
DOUBLE x_0 = DIRECT_A1D_ELEM(mtf_resol, i_0);
if (i_0 == MULTIDIM_SIZE(mtf_resol) - 1 || i_0 == 0) // check boundaries of the array
mtf = DIRECT_A1D_ELEM(mtf_value, i_0);
else
{
DOUBLE x_1 = DIRECT_A1D_ELEM(mtf_resol, i_0 + 1);
DOUBLE y_0 = DIRECT_A1D_ELEM(mtf_value, i_0);
DOUBLE y_1 = DIRECT_A1D_ELEM(mtf_value, i_0 + 1);
mtf = y_0 + (y_1 - y_0)*(res - x_0)/(x_1 - x_0);
}
// Divide Fourier component by the MTF
DIRECT_A3D_ELEM(FT, k, i, j) /= mtf;
}
}
}
}
