#include <wiener2d.h>

Collaboration diagram for Wiener2D:

Public Member Functions
void	applyWienerFilter (MultidimArray< double > &ptrImg, CTFDescription &ctf)

void	applyWienerFilter (const FileName &fnImg, const FileName &fnImgOut, const MDRow &rowIn, MDRow &rowOut)

void	wienerFilter (MultidimArray< double > &Mwien, CTFDescription &ctf)

Public Attributes
bool	phase_flipped

double	pad

bool	isIsotropic

bool	correct_envelope

double	wiener_constant
	Wiener filter constant. More...

double	sampling_rate
	Sampling rate. More...

Image< double >	img

CTFDescription	ctf

size_t	Ydim

size_t	Xdim

MultidimArray< double >	Mwien

MultidimArray< std::complex< double > >	Faux

FourierTransformer	transformer

Detailed Description

Definition at line 36 of file wiener2d.h.

Member Function Documentation

◆ applyWienerFilter() [1/2]

void Wiener2D::applyWienerFilter	(	MultidimArray< double > &	ptrImg,
		CTFDescription &	ctf
	)

Definition at line 101 of file wiener2d.cpp.

 {
     ptrImg.setXmippOrigin();
     Ydim = YSIZE(ptrImg);
     Xdim = XSIZE(ptrImg);
     int paddimY = Ydim*pad;
     int paddimX = Xdim*pad;
 
     wienerFilter(Mwien, ctf);
 
     if (paddimX >= Xdim)
     {
         // pad real-space image
         int x0 = FIRST_XMIPP_INDEX(paddimX);
         int xF = LAST_XMIPP_INDEX(paddimX);
         int y0 = FIRST_XMIPP_INDEX(paddimY);
         int yF = LAST_XMIPP_INDEX(paddimY);
         ptrImg.selfWindow(y0, x0, yF, xF);
     }
 
     MultidimArray<std::complex<double> > Faux;
     transformer.FourierTransform(ptrImg, Faux);
     FOR_ALL_DIRECT_ELEMENTS_IN_ARRAY2D(Faux)
     {
         dAij(Faux,i,j) *= dAij(Mwien,i,j);
     }
 
     transformer.inverseFourierTransform(Faux, ptrImg);
 
 
     if (paddimX >= Xdim)
     {
         // de-pad real-space image
         int x0 = FIRST_XMIPP_INDEX(Xdim);
         int y0 = FIRST_XMIPP_INDEX(Ydim);
         int xF = LAST_XMIPP_INDEX(Xdim);
         int yF = LAST_XMIPP_INDEX(Ydim);
         ptrImg.selfWindow(y0, x0, yF, xF);
     }
 }

◆ applyWienerFilter() [2/2]

void Wiener2D::applyWienerFilter	(	const FileName &	fnImg,
		const FileName &	fnImgOut,
		const MDRow &	rowIn,
		MDRow &	rowOut
	)

Definition at line 143 of file wiener2d.cpp.

 {
     rowOut = rowIn;
 
     img.read(fnImg);
     ctf.readFromMdRow(rowIn);
     ctf.phase_shift = (ctf.phase_shift*PI)/180;
 
     MultidimArray<double> &ptrImg =img();
     applyWienerFilter(ptrImg, ctf);
 
     img.write(fnImgOut);
     rowOut.setValue(MDL_IMAGE, fnImgOut);
 }

◆ wienerFilter()

void Wiener2D::wienerFilter	(	MultidimArray< double > &	Mwien,
		CTFDescription &	ctf
	)

Definition at line 30 of file wiener2d.cpp.

 {
     int paddimY;
     paddimY = Ydim*pad;
     int paddimX = Xdim*pad;
     ctf.enable_CTF = true;
     ctf.enable_CTFnoise = false;
     ctf.produceSideInfo();
 
     MultidimArray<std::complex<double>> ctfComplex;
     MultidimArray<double> ctfIm;
 
     Mwien.resize(paddimY,paddimX);
 
     ctf.Tm = sampling_rate;
 
     if (isIsotropic)
     {
         double avgdef = (ctf.DeltafU + ctf.DeltafV)/2.;
         ctf.DeltafU = avgdef;
         ctf.DeltafV = avgdef;
     }
 
     ctfIm.resize(1, 1, paddimY, paddimX,false);
     //Esto puede estar mal. Cuidado con el sampling de la ctf!!!
     if (correct_envelope)
         ctf.generateCTF(paddimY, paddimX, ctfComplex);
     else
         ctf.generateCTFWithoutDamping(paddimY, paddimX, ctfComplex);
 
     if (phase_flipped)
     {
         FOR_ALL_DIRECT_ELEMENTS_IN_ARRAY2D(ctfIm)
             dAij(ctfIm, i, j) = fabs(dAij(ctfComplex, i, j).real());
     }
     else
     {
         FOR_ALL_DIRECT_ELEMENTS_IN_ARRAY2D(ctfIm)
             dAij(ctfIm, i, j) = dAij(ctfComplex, i, j).real();
     }
 
     double result;
     FOR_ALL_DIRECT_ELEMENTS_IN_ARRAY2D(Mwien)
     {
         result = (DIRECT_N_YX_ELEM (ctfIm, 0, i, j));
         dAij(Mwien,i,j) = (result *result);
     }
 
     // Add Wiener constant
     if (wiener_constant < 0.)
     {
 
         // Use Grigorieff's default for Wiener filter constant: 10% of average over all Mwien terms
         // Grigorieff JSB 157(1) (2006), pp 117-125
         double valueW = 0.1*Mwien.computeAvg();
         FOR_ALL_DIRECT_ELEMENTS_IN_ARRAY2D(Mwien)
         {
             dAij(Mwien,i,j) += valueW;
             dAij(Mwien,i,j) = dAij(ctfIm, i, j)/dAij(Mwien, i, j);
         }
     }
     else
     {
         FOR_ALL_DIRECT_ELEMENTS_IN_ARRAY2D(Mwien)
         {
             dAij(Mwien,i,j) += wiener_constant;
             dAij(Mwien,i,j) = dAij(ctfIm, i, j)/dAij(Mwien, i, j);
         }
     }
 }

Member Data Documentation

◆ correct_envelope

bool Wiener2D::correct_envelope

Definition at line 46 of file wiener2d.h.

◆ ctf

CTFDescription Wiener2D::ctf

Definition at line 64 of file wiener2d.h.

◆ Faux

MultidimArray<std::complex<double> > Wiener2D::Faux

Definition at line 69 of file wiener2d.h.

◆ img

Image<double> Wiener2D::img

Definition at line 62 of file wiener2d.h.

◆ isIsotropic

bool Wiener2D::isIsotropic

Definition at line 44 of file wiener2d.h.

◆ Mwien

MultidimArray<double> Wiener2D::Mwien

Definition at line 68 of file wiener2d.h.

◆ pad

double Wiener2D::pad

Padding factor

Definition at line 42 of file wiener2d.h.

◆ phase_flipped

bool Wiener2D::phase_flipped

Definition at line 39 of file wiener2d.h.

◆ sampling_rate

double Wiener2D::sampling_rate

Sampling rate.

Definition at line 52 of file wiener2d.h.

◆ transformer

FourierTransformer Wiener2D::transformer

Definition at line 70 of file wiener2d.h.

◆ wiener_constant

double Wiener2D::wiener_constant

Wiener filter constant.

Definition at line 49 of file wiener2d.h.

◆ Xdim

size_t Wiener2D::Xdim

Definition at line 66 of file wiener2d.h.

◆ Ydim

size_t Wiener2D::Ydim