#include <volume_local_sharpening.h>

Inheritance diagram for ProgLocSharpening:

Collaboration diagram for ProgLocSharpening:

Public Member Functions
void	defineParams ()

void	readParams ()

void	produceSideInfo ()

void	lowPassFilterFunction (const MultidimArray< std::complex< double > > &myfftV, double w, double wL, MultidimArray< double > &filteredVol, int count)

void	bandPassFilterFunction (const MultidimArray< std::complex< double > > &myfftV, double w, double wL, MultidimArray< double > &filteredVol, int count)

void	wideBandPassFilter (const MultidimArray< std::complex< double > > &myfftV, double wmin, double wmax, double wL, MultidimArray< double > &filteredVol)

void	maxMinResolution (MultidimArray< double > &resVol, double &maxRes, double &minRes)

void	computeAvgStdev_within_binary_mask (const MultidimArray< double > &resVol, const MultidimArray< double > &vol, double &stddev, bool outside=false)

void	localfiltering (MultidimArray< std::complex< double > > &myfftV, MultidimArray< double > &localfilteredVol, double &minFreq, double &maxFreq, double &step)

void	amplitudeMonogenicSignalBP (MultidimArray< std::complex< double > > &myfftV, double w1, double w1l, MultidimArray< double > &amplitude, int count)

void	sameEnergy (MultidimArray< std::complex< double > > &myfftV, MultidimArray< double > &localfilteredVol, double &minFreq, double &maxFreq, double &step)

void	run ()

Public Member Functions inherited from XmippProgram
const char *	getParam (const char *param, int arg=0)

const char *	getParam (const char param, const char subparam, int arg=0)

int	getIntParam (const char *param, int arg=0)

int	getIntParam (const char param, const char subparam, int arg=0)

double	getDoubleParam (const char *param, int arg=0)

double	getDoubleParam (const char param, const char subparam, int arg=0)

float	getFloatParam (const char *param, int arg=0)

float	getFloatParam (const char param, const char subparam, int arg=0)

void	getListParam (const char *param, StringVector &list)

int	getCountParam (const char *param)

bool	checkParam (const char *param)

bool	existsParam (const char *param)

void	addParamsLine (const String &line)

void	addParamsLine (const char *line)

ParamDef *	getParamDef (const char *param) const

virtual void	quit (int exit_code=0) const

virtual int	tryRun ()

void	initProgress (size_t total, size_t stepBin=60)

void	setProgress (size_t value=0)

void	endProgress ()

void	processDefaultComment (const char param, const char left)

void	setDefaultComment (const char param, const char comment)

virtual void	initComments ()

void	setProgramName (const char *name)

void	addUsageLine (const char *line, bool verbatim=false)

void	clearUsage ()

void	addExampleLine (const char *example, bool verbatim=true)

void	addSeeAlsoLine (const char *seeAlso)

void	addKeywords (const char *keywords)

const char *	name () const

virtual void	usage (int verb=0) const

virtual void	usage (const String &param, int verb=2)

int	version () const

virtual void	show () const

virtual void	read (int argc, const char **argv, bool reportErrors=true)

virtual void	read (int argc, char **argv, bool reportErrors=true)

void	read (const String &argumentsLine)

	XmippProgram ()

	XmippProgram (int argc, const char **argv)

virtual	~XmippProgram ()

Public Attributes
FileName	fnOut

FileName	fnVol

FileName	fnRes

FileName	fnMD

double	sampling

double	maxRes

double	minRes

double	lambda

double	K

double	maxFreq

double	minFreq

double	desv_Vorig

double	desvOutside_Vorig

int	Niter

int	Nthread

MultidimArray< double >	Vorig

MultidimArray< int >	mask

MultidimArray< double >	resVol

MultidimArray< double >	iu

MultidimArray< double >	sharpenedMap

MultidimArray< std::complex< double > >	fftV

MultidimArray< std::complex< double > >	fftVfilter

FourierTransformer	transformer

FourierTransformer	transformer_inv

FourierFilter	FilterBand

Public Attributes inherited from XmippProgram
bool	doRun

bool	runWithoutArgs

int	verbose
	Verbosity level. More...

int	debug

Additional Inherited Members
Protected Member Functions inherited from XmippProgram
void	defineCommons ()

Protected Attributes inherited from XmippProgram
int	errorCode

ProgramDef *	progDef
	Program definition and arguments parser. More...

std::map< String, CommentList >	defaultComments

int	argc
	Original command line arguments. More...

const char **	argv

Detailed Description

SSNR parameters.

Definition at line 49 of file volume_local_sharpening.h.

Member Function Documentation

◆ amplitudeMonogenicSignalBP()

void ProgLocSharpening::amplitudeMonogenicSignalBP	(	MultidimArray< std::complex< double > > &	myfftV,
		double	w1,
		double	w1l,
		MultidimArray< double > &	amplitude,
		int	count
	)

◆ bandPassFilterFunction()

void ProgLocSharpening::bandPassFilterFunction	(	const MultidimArray< std::complex< double > > &	myfftV,
		double	w,
		double	wL,
		MultidimArray< double > &	filteredVol,
		int	count
	)

Definition at line 181 of file volume_local_sharpening.cpp.

 {
         fftVfilter.initZeros(myfftV);
         size_t xdim, ydim, zdim, ndim;
         Vorig.getDimensions(xdim, ydim, zdim, ndim);
 
 
         double delta = wL-w;
         double w_inf = w-delta;
         // Filter the input volume and add it to amplitude
         long n=0;
         double ideltal=PI/delta;
         FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY(myfftV)
         {
                 double un=DIRECT_MULTIDIM_ELEM(iu,n);
                 if (un>=w && un<=wL)
                 {
                         DIRECT_MULTIDIM_ELEM(fftVfilter, n) = DIRECT_MULTIDIM_ELEM(myfftV, n);
                         DIRECT_MULTIDIM_ELEM(fftVfilter, n) *= 0.5*(1+cos((un-w)*ideltal));//H;
                 } else if (un<=w && un>=w_inf)
                 {
                         DIRECT_MULTIDIM_ELEM(fftVfilter, n) = DIRECT_MULTIDIM_ELEM(myfftV, n);
                         DIRECT_MULTIDIM_ELEM(fftVfilter, n) *= 0.5*(1+cos((un-w)*ideltal));//H;
                 }
         }
 
         filteredVol.resizeNoCopy(Vorig);
 
         transformer_inv.inverseFourierTransform(fftVfilter, filteredVol);
 
 //        #ifdef DEBUG_FILTER
 //        Image<double> filteredvolume;
 //        filteredvolume() = filteredVol;
 //        filteredvolume.write(formatString("Volumen_filtrado_%i.vol", count));
 //        #endif
 }

◆ computeAvgStdev_within_binary_mask()

void ProgLocSharpening::computeAvgStdev_within_binary_mask	(	const MultidimArray< double > &	resVol,
		const MultidimArray< double > &	vol,
		double &	stddev,
		bool	outside = `false`
	)

Definition at line 151 of file volume_local_sharpening.cpp.

 {
 
     SPEED_UP_tempsInt;
     double sum1 = 0;
     double sum2 = 0;
     int N = 0;
     double avg=0;
 
     FOR_ALL_ELEMENTS_IN_COMMON_IN_ARRAY3D(resVol, vol)
     {
         if ((not outside && A3D_ELEM(resVol, k, i, j) > 2*sampling) ||
                 (outside && A3D_ELEM(resVol, k, i, j) < 2*sampling))
         {
             ++N;
             double aux=A3D_ELEM(vol, k, i, j);
             sum1 += aux;
             sum2 += aux*aux;
         }
     }
 
     // average and standard deviation
       avg  = sum1 / (double) N;
     if (N > 1)
       stddev = sqrt(fabs(sum2 / N - avg * avg) * N / (N - 1));
     else
         stddev = 0;
 }

◆ defineParams()

void ProgLocSharpening::defineParams ( )

virtual

Function in which the param of each Program are defined.

Reimplemented from XmippProgram.

Definition at line 44 of file volume_local_sharpening.cpp.

 {
         addUsageLine("This function performs local sharpening");
         addParamsLine("  --vol <vol_file=\"\">   : Input volume");
         addParamsLine("  --resolution_map <vol_file=\"\">: Resolution map");
         addParamsLine("  --sampling <s=1>: sampling");
         addParamsLine("  -o <output=\"Sharpening.vol\">: sharpening volume");
         addParamsLine("  [--md <output=\"params.xmd\">]: sharpening params");
         addParamsLine("  [-l <lambda=1>]: regularization param");
         addParamsLine("  [-k <K=0.025>]: K param");
         addParamsLine("  [-i <Niter=50>]: iteration");
         addParamsLine("  [-n <Nthread=1>]: threads number");
 }

◆ localfiltering()

void ProgLocSharpening::localfiltering	(	MultidimArray< std::complex< double > > &	myfftV,
		MultidimArray< double > &	localfilteredVol,
		double &	minFreq,
		double &	maxFreq,
		double &	step
	)

Definition at line 219 of file volume_local_sharpening.cpp.

 {
         MultidimArray<double> filteredVol, lastweight, weight;
         localfilteredVol.initZeros(Vorig);
         weight.initZeros(Vorig);
         lastweight.initZeros(Vorig);
 
         double freq, lastResolution=1e38;
         int idx, lastidx = -1;
     
     for(double res = minRes; res<maxRes; res+=step)
     {   
                 freq = sampling/res;
 
                 DIGFREQ2FFT_IDX(freq, ZSIZE(myfftV), idx);
 
                 if (idx == lastidx)
                 {
                         continue;
                 }
 
                 double wL = sampling/(res - step);
 
                 bandPassFilterFunction(myfftV, freq, wL, filteredVol, idx);
 
                 FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY(filteredVol)
                 {
 
                        if (DIRECT_MULTIDIM_ELEM(resVol, n) < 2*sampling)
                             {
                                DIRECT_MULTIDIM_ELEM(filteredVol, n)=0;
                             }
                        else
                             {
                                double res_map = DIRECT_MULTIDIM_ELEM(resVol, n);//+1e-38;
                                DIRECT_MULTIDIM_ELEM(weight, n) = (exp(-K*(res-res_map)*(res-res_map)));
                                DIRECT_MULTIDIM_ELEM(filteredVol, n) *= DIRECT_MULTIDIM_ELEM(weight, n);
                             }
 
                 }
 
                 localfilteredVol += filteredVol;
                 lastweight += weight;
                 lastResolution = res;
                 lastidx = idx;
         }
 //      double sigmaBefore=0;
 //        computeAvgStdev_within_binary_mask(resVol, localfilteredVol, sigmaBefore);
 
         FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY(localfilteredVol)
         {
             if (DIRECT_MULTIDIM_ELEM(lastweight, n)>0)
                 DIRECT_MULTIDIM_ELEM(localfilteredVol, n) /=DIRECT_MULTIDIM_ELEM(lastweight, n);
         }
 //      double sigmaAfter=0;
 //        computeAvgStdev_within_binary_mask(resVol, localfilteredVol, sigmaAfter);
 //        std::cout << "sigmaBefore div=" << sigmaBefore << " sigmaAfter div=" << sigmaAfter << std::endl;
 //        FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY(localfilteredVol)
 //        {
 //          if (DIRECT_MULTIDIM_ELEM(lastweight, n)>0)
 //                DIRECT_MULTIDIM_ELEM(localfilteredVol, n) *=0.01*sigmaBefore/sigmaAfter;
 //        }
 }

◆ lowPassFilterFunction()

void ProgLocSharpening::lowPassFilterFunction	(	const MultidimArray< std::complex< double > > &	myfftV,
		double	w,
		double	wL,
		MultidimArray< double > &	filteredVol,
		int	count
	)

◆ maxMinResolution()

void ProgLocSharpening::maxMinResolution	(	MultidimArray< double > &	resVol,
		double &	maxRes,
		double &	minRes
	)

Definition at line 132 of file volume_local_sharpening.cpp.

 {
         // Count number of voxels with resolution
         size_t n=0;
         double lastMinRes=1e38, lastMaxRes=1e-38, value;
         FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY(resVol)
         {
                 value = DIRECT_MULTIDIM_ELEM(resVol, n);
                 if (value>lastMaxRes)
                         lastMaxRes = value;
                 if (value<lastMinRes && value>0)
                         lastMinRes = value;
         }
 
         maxRes = lastMaxRes;
         minRes = lastMinRes;
 }

◆ produceSideInfo()

void ProgLocSharpening::produceSideInfo ( )

Definition at line 58 of file volume_local_sharpening.cpp.

 {
         std::cout << "Starting..." << std::endl;
         Image<double> V;
         V.read(fnVol);
         V().setXmippOrigin();
 
 
         if (Nthread>1)
         {
            std::cout << "used procesors = " << Nthread << std::endl;
            transformer_inv.setThreadsNumber(Nthread);
            transformer.setThreadsNumber(Nthread);
         }
 
         MultidimArray<double> &inputVol = V();
         Vorig = inputVol;
 
         transformer.FourierTransform(inputVol, fftV);
 
         iu.initZeros(fftV);
         double uz, uy, ux, uz2, u2, uz2y2;
         long n=0;
         for(size_t k=0; k<ZSIZE(fftV); ++k)
         {
                 FFT_IDX2DIGFREQ(k,ZSIZE(inputVol),uz);
                 uz2=uz*uz;
 
                 for(size_t i=0; i<YSIZE(fftV); ++i)
                 {
                         FFT_IDX2DIGFREQ(i,YSIZE(inputVol),uy);
                         uz2y2=uz2+uy*uy;
 
                         for(size_t j=0; j<XSIZE(fftV); ++j)
                         {
                                 FFT_IDX2DIGFREQ(j,XSIZE(inputVol),ux);
                                 u2=uz2y2+ux*ux;
                                 if ((k != 0) || (i != 0) || (j != 0))
                                         DIRECT_MULTIDIM_ELEM(iu,n) = sqrt(u2);
                                 else
                                         DIRECT_MULTIDIM_ELEM(iu,n) = 1e-38;
                                 ++n;
                         }
                 }
         }
 
         inputVol.clear();
 
     Image<double> resolutionVolume;
     resolutionVolume.read(fnRes);
 
     resVol = resolutionVolume();
     resolutionVolume().clear();
 
     maxMinResolution(resVol, maxRes, minRes);
 //  std::cout << "maxRes = " << maxRes << "  minRes = " << minRes << std::endl;
 
     FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY(resVol)
     {
 
         if ((DIRECT_MULTIDIM_ELEM(resVol, n) < 2*sampling) && (DIRECT_MULTIDIM_ELEM(resVol, n)>0))
         {
             DIRECT_MULTIDIM_ELEM(resVol, n) = 2*sampling;
         }
 
     }
 
     resVol.setXmippOrigin();
 
     computeAvgStdev_within_binary_mask(resVol, Vorig, desvOutside_Vorig, true);
     //std::cout << "desvOutside_Vorig = " << desvOutside_Vorig << std::endl;
 
 }

◆ readParams()

void ProgLocSharpening::readParams ( )

virtual

Function in which each program will read parameters that it need. If some error occurs the usage will be printed out.

Reimplemented from XmippProgram.

Definition at line 31 of file volume_local_sharpening.cpp.

 {
         fnVol = getParam("--vol");
         fnRes = getParam("--resolution_map");
         sampling = getDoubleParam("--sampling");
         lambda = getDoubleParam("-l");
         K= getDoubleParam("-k");
         Niter = getIntParam("-i");
         Nthread = getIntParam("-n");
         fnOut = getParam("-o");
         fnMD = getParam("--md");
 }

◆ run()

void ProgLocSharpening::run ( )

virtual

This function will be start running the program. it also should be implemented by derived classes.

Reimplemented from XmippProgram.

Definition at line 285 of file volume_local_sharpening.cpp.

 {
         produceSideInfo();
 
         MultidimArray<double> auxVol;
         MultidimArray<double> operatedfiltered, Vk, filteredVol;
         double lastnorm=0, lastporc=1;
         double freq;
         double step = 0.2;
         int idx, bool1=1, bool2=1;
         int lastidx = -1;
 
         minRes = 2*sampling;
         maxRes=maxRes+2;
 
         //std::cout << "Resolutions between " << minRes << " and " << maxRes << std::endl;
 
         filteredVol = Vorig;
 
         sharpenedMap.resizeNoCopy(Vorig);
         double normOrig=0;
 
         MetaDataVec mditer;
         size_t objId;
         objId = mditer.addObject();
 
         for (size_t i = 1; i<=Niter; ++i)
         {
             //std::cout << "----------------Iteration " << i << "----------------" << std::endl;
             mditer.setValue(MDL_ITER, (int) i, objId);
             auxVol = filteredVol;
             transformer.FourierTransform(auxVol, fftV);
 
             localfiltering(fftV, operatedfiltered, minRes, maxRes, step);
 
             filteredVol = Vorig;
 
             filteredVol -= operatedfiltered;
 
             //calculate norm for Vorig
             if (i==1)
             {
                 FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY(Vorig)
                 {
                        normOrig +=(DIRECT_MULTIDIM_ELEM(Vorig,n)*DIRECT_MULTIDIM_ELEM(Vorig,n));
                 }
                 normOrig = sqrt(normOrig);
                 //std::cout << "norma del original  " << normOrig << std::endl;
             }
 
 
             //calculate norm for operatedfiltered
             double norm=0;
             FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY(operatedfiltered)
             {
                     norm +=(DIRECT_MULTIDIM_ELEM(operatedfiltered,n)*DIRECT_MULTIDIM_ELEM(operatedfiltered,n));
             }
             norm=sqrt(norm);
 
 
             double porc=lastnorm*100/norm;
             //std::cout << "norm " << norm << " percetage " << porc << std::endl;
 
             double subst=porc-lastporc;
 
             if ((subst<1)&&(bool1==1)&&(i>2))
             {
                 bool1=2;
                 //std::cout << "-----iteration completed-----" << std::endl;
 
             }
 
             lastnorm=norm;
             lastporc=porc;
 
             if (i==1 && lambda==1)
             {
                 lambda=(normOrig/norm)/12;
                 std::cout << "  lambda  " << lambda << std::endl;
             }
 
             transformer.FourierTransform(filteredVol, fftV);
             localfiltering(fftV, filteredVol, minRes, maxRes, step);
 
             if (i == 1)
                     Vk = Vorig;
             else
                     Vk = sharpenedMap;
 
             //sharpenedMap=Vk+lambda*(filteredVol);
             FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY(sharpenedMap)
             {
                 DIRECT_MULTIDIM_ELEM(sharpenedMap,n)=DIRECT_MULTIDIM_ELEM(Vk,n)+
                                      lambda*DIRECT_MULTIDIM_ELEM(filteredVol,n);
                                      //-0.01*DIRECT_MULTIDIM_ELEM(Vk,n)*SGN(DIRECT_MULTIDIM_ELEM(Vk,n));
                 if (DIRECT_MULTIDIM_ELEM(sharpenedMap,n)<-4*desvOutside_Vorig)
                     DIRECT_MULTIDIM_ELEM(sharpenedMap,n)=-4*desvOutside_Vorig;
             }
 
 //              double desv_sharp=0;
 //                computeAvgStdev_within_binary_mask(resVol, sharpenedMap, desv_sharp);
 //                std::cout << "desv_sharp = " << desv_sharp << std::endl;
 
             filteredVol = sharpenedMap;
 
             if (bool1==2)
             {
                 Image<double> filteredvolume;
                 filteredvolume() = sharpenedMap;
                 filteredvolume.write(fnOut);
                 break;
             }
         }
 
     mditer.setValue(MDL_COST, lambda, objId);
     mditer.write(fnMD);
 
         Image<double> filteredvolume;
         filteredvolume() = sharpenedMap;
         filteredvolume.write(fnOut);
 
 }

◆ sameEnergy()

void ProgLocSharpening::sameEnergy	(	MultidimArray< std::complex< double > > &	myfftV,
		MultidimArray< double > &	localfilteredVol,
		double &	minFreq,
		double &	maxFreq,
		double &	step
	)

◆ wideBandPassFilter()

void ProgLocSharpening::wideBandPassFilter	(	const MultidimArray< std::complex< double > > &	myfftV,
		double	wmin,
		double	wmax,
		double	wL,
		MultidimArray< double > &	filteredVol
	)

Member Data Documentation

◆ desv_Vorig

double ProgLocSharpening::desv_Vorig

Definition at line 56 of file volume_local_sharpening.h.

◆ desvOutside_Vorig

double ProgLocSharpening::desvOutside_Vorig

Definition at line 56 of file volume_local_sharpening.h.

◆ fftV

MultidimArray< std::complex<double> > ProgLocSharpening::fftV

Definition at line 99 of file volume_local_sharpening.h.

◆ fftVfilter

MultidimArray< std::complex<double> > ProgLocSharpening::fftVfilter

Definition at line 99 of file volume_local_sharpening.h.

◆ FilterBand

FourierFilter ProgLocSharpening::FilterBand

Definition at line 101 of file volume_local_sharpening.h.

◆ fnMD

FileName ProgLocSharpening::fnMD

Definition at line 53 of file volume_local_sharpening.h.

◆ fnOut

FileName ProgLocSharpening::fnOut

Filenames

Definition at line 53 of file volume_local_sharpening.h.

◆ fnRes

FileName ProgLocSharpening::fnRes

Definition at line 53 of file volume_local_sharpening.h.

◆ fnVol

FileName ProgLocSharpening::fnVol

Definition at line 53 of file volume_local_sharpening.h.

◆ iu

MultidimArray<double> ProgLocSharpening::iu

Definition at line 98 of file volume_local_sharpening.h.

◆ K

double ProgLocSharpening::K

Definition at line 56 of file volume_local_sharpening.h.

◆ lambda

double ProgLocSharpening::lambda

Definition at line 56 of file volume_local_sharpening.h.

◆ mask

MultidimArray<int> ProgLocSharpening::mask

Definition at line 96 of file volume_local_sharpening.h.

◆ maxFreq

double ProgLocSharpening::maxFreq

Definition at line 56 of file volume_local_sharpening.h.

◆ maxRes

double ProgLocSharpening::maxRes

Definition at line 56 of file volume_local_sharpening.h.

◆ minFreq

double ProgLocSharpening::minFreq

Definition at line 56 of file volume_local_sharpening.h.

◆ minRes

double ProgLocSharpening::minRes

Definition at line 56 of file volume_local_sharpening.h.

◆ Niter

int ProgLocSharpening::Niter

Definition at line 57 of file volume_local_sharpening.h.

◆ Nthread

int ProgLocSharpening::Nthread

Definition at line 57 of file volume_local_sharpening.h.

◆ resVol

MultidimArray<double> ProgLocSharpening::resVol

Definition at line 97 of file volume_local_sharpening.h.

◆ sampling

double ProgLocSharpening::sampling

sampling rate, minimum resolution, and maximum resolution

Definition at line 56 of file volume_local_sharpening.h.

◆ sharpenedMap

MultidimArray<double> ProgLocSharpening::sharpenedMap

Definition at line 98 of file volume_local_sharpening.h.

◆ transformer

FourierTransformer ProgLocSharpening::transformer

Definition at line 100 of file volume_local_sharpening.h.

◆ transformer_inv

FourierTransformer ProgLocSharpening::transformer_inv

Definition at line 100 of file volume_local_sharpening.h.

◆ Vorig

MultidimArray<double> ProgLocSharpening::Vorig

Definition at line 95 of file volume_local_sharpening.h.

The documentation for this class was generated from the following files:

xmipp/libraries/reconstruction/volume_local_sharpening.h
xmipp/libraries/reconstruction/volume_local_sharpening.cpp

Public Member Functions

Public Attributes

Additional Inherited Members

Detailed Description

Member Function Documentation

◆ amplitudeMonogenicSignalBP()

◆ bandPassFilterFunction()

◆ computeAvgStdev_within_binary_mask()

◆ defineParams()

◆ localfiltering()

◆ lowPassFilterFunction()

◆ maxMinResolution()

◆ produceSideInfo()

◆ readParams()

◆ run()

◆ sameEnergy()

◆ wideBandPassFilter()

Member Data Documentation

◆ desv_Vorig

◆ desvOutside_Vorig

◆ fftV

◆ fftVfilter

◆ FilterBand

◆ fnMD

◆ fnOut

◆ fnRes

◆ fnVol

◆ iu

◆ K

◆ lambda

◆ mask

◆ maxFreq

◆ maxRes

◆ minFreq

◆ minRes

◆ Niter

◆ Nthread

◆ resVol

◆ sampling

◆ sharpenedMap

◆ transformer

◆ transformer_inv

◆ Vorig