#include <movie_estimate_gain.h>

Inheritance diagram for ProgMovieEstimateGain:

Collaboration diagram for ProgMovieEstimateGain:

Public Member Functions
void	defineParams ()

void	readParams ()

void	show ()

void	run ()

void	produceSideInfo ()

void	computeHistograms (const MultidimArray< double > &Iframe)

void	normalizeHistograms ()

void	invertHistograms ()

void	constructSmoothHistogramsByColumn (const double *listOfWeights, int width)

void	constructSmoothHistogramsByRow (const double *listOfWeights, int width)

void	transformGrayValuesColumn (const MultidimArray< double > &Iframe, MultidimArray< double > &IframeTransformedColumn)

void	transformGrayValuesRow (const MultidimArray< double > &Iframe, MultidimArray< double > &IframeTransformedRow)

void	computeTransformedHistograms (const MultidimArray< double > &Iframe)

size_t	selectBestSigmaByColumn (const MultidimArray< double > &Iframe)

size_t	selectBestSigmaByRow (const MultidimArray< double > &Iframe)

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	fnIn

FileName	fnRoot

FileName	fnCorrected

int	Niter

double	sigma

double	maxSigma

double	sigmaStep

bool	singleReference

int	frameStep

FileName	fnGain

bool	applyGain

MetaDataVec	mdIn

MultidimArray< double >	columnH

MultidimArray< double >	rowH

MultidimArray< double >	aSingleColumnH

MultidimArray< double >	aSingleRowH

MultidimArray< double >	smoothColumnH

MultidimArray< double >	smoothRowH

MultidimArray< double >	sumObs

Image< double >	IGain

std::vector< double >	listOfSigmas

std::vector< double >	listOfWidths

std::vector< double * >	listOfWeights

int	Xdim

int	Ydim

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

Definition at line 42 of file movie_estimate_gain.h.

Member Function Documentation

◆ computeHistograms()

void ProgMovieEstimateGain::computeHistograms ( const MultidimArray< double > & Iframe )

Definition at line 264 of file movie_estimate_gain.cpp.

 {
     auto* auxElemC=new double[Ydim];
     auto* auxElemR=new double[Xdim];
 
         for(size_t j=0; j<XSIZE(columnH); j++)
         {
             for(size_t i=0; i<Ydim; i++)
                 auxElemC[i]=A2D_ELEM(Iframe,i,j);
             std::sort(auxElemC, auxElemC+Ydim);
             for(size_t i=0; i<Ydim; i++)
                 A2D_ELEM(columnH,i,j)=auxElemC[i];
         }
         delete[] auxElemC;
 
         for(size_t i=0; i<YSIZE(rowH); i++)
         {
             memcpy(auxElemR,&A2D_ELEM(Iframe,i,0),Xdim*sizeof(double));
             std::sort(auxElemR, auxElemR+Xdim);
             memcpy(&A2D_ELEM(rowH,i,0),auxElemR,Xdim*sizeof(double));
         }
         delete[] auxElemR;
 
 
 #ifdef NEVER_DEFINED
     Image<double> save;
     typeCast(columnH,save());
     save.write("PPPcolumnH.xmp");
     typeCast(rowH,save());
     save.write("PPProwH.xmp");
 #endif
 }

◆ computeTransformedHistograms()

void ProgMovieEstimateGain::computeTransformedHistograms ( const MultidimArray< double > & Iframe )

◆ constructSmoothHistogramsByColumn()

void ProgMovieEstimateGain::constructSmoothHistogramsByColumn	(	const double *	listOfWeights,
		int	width
	)

Definition at line 297 of file movie_estimate_gain.cpp.

 {
 
     smoothColumnH.initZeros(columnH);
 
     for (size_t j=0; j<XSIZE(columnH); ++j)
     {
         double sumWeightsC = 0;
         for(int k = -width; k<=width; ++k)
         {
             if (j+k<0 || j+k>=XSIZE(columnH))
                 continue;
             double actualWeightC = listOfWeights[abs(k)];
             sumWeightsC += actualWeightC;
             for (size_t i=0; i<Ydim; ++i)
                 DIRECT_A2D_ELEM(smoothColumnH,i,j) += actualWeightC * DIRECT_A2D_ELEM(columnH,i,j+k);
         }
 
         double iSumWeightsC=1/sumWeightsC;
         for (size_t i=0; i<Ydim; ++i)
             DIRECT_A2D_ELEM(smoothColumnH,i,j) *= iSumWeightsC;
     }
 
     if (singleReference)
     {
         // Compute the average of all column histograms
         for (size_t i=0; i<Ydim; ++i)
             for (size_t j=1; j<Xdim; ++j)
                 DIRECT_A2D_ELEM(smoothColumnH,i,0)+=DIRECT_A2D_ELEM(smoothColumnH,i,j);
 
         double iXdim=1.0/Xdim;
         for (size_t i=0; i<Ydim; ++i)
         {
             DIRECT_A2D_ELEM(smoothColumnH,i,0)*=iXdim;
             double aux=DIRECT_A2D_ELEM(smoothColumnH,i,0);
             for (size_t j=1; j<Xdim; ++j)
                 DIRECT_A2D_ELEM(smoothColumnH,i,j)=aux;
         }
     }
 #ifdef NEVER_DEFINED
     Image<double> save;
     typeCast(smoothColumnH,save());
     save.write("PPPsmoothColumnH.xmp");
 #endif
 }

◆ constructSmoothHistogramsByRow()

void ProgMovieEstimateGain::constructSmoothHistogramsByRow	(	const double *	listOfWeights,
		int	width
	)

Definition at line 343 of file movie_estimate_gain.cpp.

 {
     smoothRowH.initZeros(rowH);
     for(size_t i = 0; i<YSIZE(rowH); ++i)
     {
         double sumWeightsR = 0;
         for(int k = -width; k<=width; ++k)
         {
             if (i+k<0 || i+k>=YSIZE(rowH))
                 continue;
             double actualWeightR = listOfWeights[abs(k)];
             sumWeightsR += actualWeightR;
             for (size_t j=0; j< Xdim; ++j)
                 DIRECT_A2D_ELEM(smoothRowH,i,j) += actualWeightR * DIRECT_A2D_ELEM(rowH,i+k,j);
         }
         double iSumWeightsR=1/sumWeightsR;
         for (size_t j=0; j<Xdim; ++j)
             DIRECT_A2D_ELEM(smoothRowH,i,j) *= iSumWeightsR;
     }
 
     if (singleReference)
     {
         // Compute the average of all row histograms
         for (size_t j=0; j<Xdim; ++j)
             for (size_t i=1; i<Ydim; ++i)
                 DIRECT_A2D_ELEM(smoothRowH,0,j)+=DIRECT_A2D_ELEM(smoothRowH,i,j);
 
         double iYdim=1.0/Ydim;
         for (size_t j=0; j<Xdim; ++j)
         {
             DIRECT_A2D_ELEM(smoothRowH,0,j)*=iYdim;
             double aux=DIRECT_A2D_ELEM(smoothRowH,0,j);
             for (size_t i=1; i<Ydim; ++i)
                 DIRECT_A2D_ELEM(smoothRowH,i,j)=aux;
         }
     }
 
 #ifdef NEVER_DEFINED
     Image<double> save;
     typeCast(smoothRowH,save());
     save.write("PPPsmoothRowH.xmp");
 #endif
 }

◆ defineParams()

void ProgMovieEstimateGain::defineParams ( )

virtual

Function in which the param of each Program are defined.

Reimplemented from XmippProgram.

Definition at line 32 of file movie_estimate_gain.cpp.

 {
     addUsageLine("Estimate the gain image for a movie");
     addParamsLine(" -i <movie>: Input movie");
     addParamsLine(" [--oroot <fn=\"estimated\">]: Estimated corrections and gains");
     addParamsLine("                             :+(Ideal=Observed*Corr, Observed=Ideal*Gain)");
     addParamsLine(" [--iter <N=3>]: Number of iterations");
     addParamsLine(" [--sigma <s=-1>]: Sigma to use, if negative, then it is searched");
     addParamsLine(" [--maxSigma <s=3>]: Maximum number of neighbour rows/columns to analyze");
     addParamsLine(" [--frameStep <s=1>]: Skip frames during the estimation");
     addParamsLine("                    : Set to 1 to process all frames, set to 2 to process 1 every 2 frames, ...");
     addParamsLine(" [--sigmaStep <s=0.5>]: Step size for sigma");
     addParamsLine(" [--singleRef] : Use a single histogram reference");
     addParamsLine("               :+This assumes that there is no image contamination or carbon holes");
     addParamsLine(" [--gainImage <fn=\"\">] : Reference to external gain image (we will divide by it)");
     addParamsLine(" [--applyGain <fnOut>] : Flag for using external gain image");
     addParamsLine("               : applyGain=True will use external gain image");
 }

◆ invertHistograms()

void ProgMovieEstimateGain::invertHistograms ( )

◆ normalizeHistograms()

void ProgMovieEstimateGain::normalizeHistograms ( )

◆ produceSideInfo()

void ProgMovieEstimateGain::produceSideInfo ( )

Definition at line 67 of file movie_estimate_gain.cpp.

 {
     if (fnIn.getExtension()=="mrc")
         fnIn+=":mrcs";
     mdIn.read(fnIn);
     mdIn.removeDisabled();
     if (mdIn.size()==0)
         exit(0);
     Image<double> Iframe;
     FileName fnFrame;
     mdIn.getValue(MDL_IMAGE,fnFrame,mdIn.firstRowId());
     Iframe.read(fnFrame);
     Xdim=XSIZE(Iframe());
     Ydim=YSIZE(Iframe());
 
     columnH.initZeros(Ydim,Xdim);
     rowH.initZeros(Ydim,Xdim);
     if (fnGain!="")
     {
         IGain.read(fnGain);
         if (YSIZE(IGain())!=Ydim || XSIZE(IGain())!=Xdim)
             REPORT_ERROR(ERR_MULTIDIM_SIZE,"The gain image and the movie do not have the same dimensions");
     }
     else
     {
         IGain().resizeNoCopy(Ydim,Xdim);
         IGain().initConstant(1);
     }
 
     sumObs.initZeros(Ydim,Xdim);
 
     int iFrame=0;
     for (size_t objId : mdIn.ids())
     {
         if (iFrame%frameStep==0)
         {
                mdIn.getValue(MDL_IMAGE,fnFrame,objId);
                Iframe.read(fnFrame);
                MultidimArray<double>  mIframe=Iframe();
                MultidimArray<double>  mIGain=IGain();
                FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY(mIframe)
                    DIRECT_MULTIDIM_ELEM(mIframe,n) /= DIRECT_MULTIDIM_ELEM(mIGain,n);               sumObs+=Iframe();
         }
         iFrame++;
     }
     sumObs*=2;
 
     // Initialize sigma values
     const auto numIterations = static_cast<size_t>(maxSigma / sigmaStep);
     listOfSigmas.reserve(numIterations);
     for (size_t i=0; i<=numIterations; ++i)
         listOfSigmas.push_back(i*sigmaStep);
 
     for (size_t i=0; i<listOfSigmas.size(); ++i)
     {
         int jmax=ceil(3*listOfSigmas[i]);
         listOfWidths.push_back(jmax);
         auto *weights=new double[jmax+1];
         double K=1;
             if (listOfSigmas[i]>0)
                K=-0.5/(listOfSigmas[i]*listOfSigmas[i]);
         for (int j=0; j<=jmax; ++j)
            weights[j]=exp(K*j*j);
         listOfWeights.push_back(weights);
     }
 }

◆ readParams()

void ProgMovieEstimateGain::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 51 of file movie_estimate_gain.cpp.

 {
     fnIn=getParam("-i");
     fnRoot=getParam("--oroot");
     Niter=getIntParam("--iter");
     sigma=getIntParam("--sigma");
     maxSigma=getDoubleParam("--maxSigma");
     sigmaStep=getDoubleParam("--sigmaStep");
     singleReference=checkParam("--singleRef");
     frameStep=getIntParam("--frameStep");
     fnGain=getParam("--gainImage");
     applyGain=checkParam("--applyGain");
     if (applyGain)
        fnCorrected=getParam("--applyGain");
 }

◆ run()

void ProgMovieEstimateGain::run ( )

virtual

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

Reimplemented from XmippProgram.

Definition at line 153 of file movie_estimate_gain.cpp.

 {
     produceSideInfo();
 
     FileName fnFrame;
     Image<double> Iframe;
     MultidimArray<double> IframeTransformed, IframeIdeal;
     MultidimArray<double> sumIdeal;
     MultidimArray<double> &mIGain=IGain();
 
     if (applyGain)
     {
             int idx=1;
             createEmptyFile(fnCorrected, Xdim, Ydim, 1, mdIn.size());
             for (size_t objId : mdIn.ids())
             {
                 mdIn.getValue(MDL_IMAGE,fnFrame,objId);
                 Iframe.read(fnFrame);
                 MultidimArray<double> &mIframe = Iframe();
                 FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY(mIframe)
                     DIRECT_MULTIDIM_ELEM(mIframe,n) /= DIRECT_MULTIDIM_ELEM(mIGain,n);
                 //Iframe.write(formatString("%i@%s"%(idx,fnCorrected)));
                 Iframe.write(fnCorrected, idx, WRITE_REPLACE);
                 idx++;
             }
     }else{
         for (int n=0; n<Niter; n++)
         {
             std::cout << "Iteration " << n << std::endl;
             sumIdeal.initZeros(Ydim,Xdim);
             int iFrame=0;
             for (size_t objId : mdIn.ids())
             {
                 if (iFrame%frameStep==0)
                 {
                     mdIn.getValue(MDL_IMAGE,fnFrame,objId);
                     std::cout << "   Frame " << fnFrame << std::endl;
                     Iframe.read(fnFrame);
                     IframeIdeal = Iframe();
                     FOR_ALL_DIRECT_ELEMENTS_IN_ARRAY2D(IframeIdeal)
                         DIRECT_A2D_ELEM(IframeIdeal,i,j)/=DIRECT_A2D_ELEM(mIGain,i,j);
                     computeHistograms(IframeIdeal);
 
                     //sigma=0;
                     size_t bestSigmaCol = 0;
                     if (sigma>=0)
                     {
                         double bestDistance=1e38;
                         for (size_t s = 0; s< listOfWeights.size(); ++s)
                             if (fabs(listOfSigmas[s]-sigma)<bestDistance)
                             {
                                 bestDistance=fabs(listOfSigmas[s]-sigma);
                                 bestSigmaCol=s;
                             }
                     }
                     else
                         selectBestSigmaByColumn(IframeIdeal);
                     std::cout << "      sigmaCol: " << listOfSigmas[bestSigmaCol] << std::endl;
                     size_t bestSigmaRow = 0;
 
                     if (sigma>=0)
                     {
                         double bestDistance=1e38;
                         for (size_t s = 0; s< listOfWeights.size(); ++s)
                             if (fabs(listOfSigmas[s]-sigma)<bestDistance)
                             {
                                 bestDistance=fabs(listOfSigmas[s]-sigma);
                                 bestSigmaRow=s;
                             }
                     }
                     else
                         selectBestSigmaByRow(IframeIdeal);
                     std::cout << "      sigmaRow: " << listOfSigmas[bestSigmaRow] << std::endl;
 
                     constructSmoothHistogramsByRow(listOfWeights[bestSigmaRow],listOfWidths[bestSigmaRow]);
                     transformGrayValuesRow(IframeIdeal,IframeTransformed);
                     FOR_ALL_DIRECT_ELEMENTS_IN_ARRAY2D(IframeTransformed)
                         DIRECT_A2D_ELEM(sumIdeal,i,j)+=DIRECT_A2D_ELEM(IframeTransformed,i,j);
                     constructSmoothHistogramsByColumn(listOfWeights[bestSigmaCol],listOfWidths[bestSigmaCol]);
                     transformGrayValuesColumn(IframeIdeal,IframeTransformed);
                     FOR_ALL_DIRECT_ELEMENTS_IN_ARRAY2D(IframeTransformed)
                         DIRECT_A2D_ELEM(sumIdeal,i,j)+=DIRECT_A2D_ELEM(IframeTransformed,i,j);
                  }
                  iFrame++;
             }
 
             FOR_ALL_DIRECT_ELEMENTS_IN_ARRAY2D(mIGain)
             {
                 double den=DIRECT_A2D_ELEM(sumObs,i,j);
                 if (fabs(den)<1e-6)
                     DIRECT_A2D_ELEM(mIGain,i,j)=1.0;
                 else
                     DIRECT_A2D_ELEM(mIGain,i,j)=DIRECT_A2D_ELEM(sumIdeal,i,j)/den;
             }
             mIGain/=mIGain.computeAvg();
 
     #ifdef NEVER_DEFINED
         IGain.write(fnCorr);
         Image<double> save;
         typeCast(sumIdeal,save());
         save.write("PPPSumIdeal.xmp");
         typeCast(sumObs,save());
         save.write("PPPSumObs.xmp");
         //std::cout << "Press any key\n";
         //char c; std::cin >> c;
     #endif
         }
     }
     IGain.write(fnRoot+"_gain.xmp");
 }

◆ selectBestSigmaByColumn()

size_t ProgMovieEstimateGain::selectBestSigmaByColumn ( const MultidimArray< double > & Iframe )

Definition at line 477 of file movie_estimate_gain.cpp.

 {
     double bestAvgTV=1e38;
     size_t best_s=0;
     MultidimArray<double> IframeTransformed;
 
     for(size_t s = 0; s< listOfWeights.size(); ++s)
     {
         constructSmoothHistogramsByColumn(listOfWeights[s],listOfWidths[s]);
         transformGrayValuesColumn(Iframe,IframeTransformed);
         double avgTV=computeTVColumns(IframeTransformed);
         if (avgTV<bestAvgTV)
         {
             bestAvgTV=avgTV;
             best_s=s;
         }
     }
     return best_s;
 }

◆ selectBestSigmaByRow()

size_t ProgMovieEstimateGain::selectBestSigmaByRow ( const MultidimArray< double > & Iframe )

Definition at line 497 of file movie_estimate_gain.cpp.

 {
     double bestAvgTV=1e38;
     size_t best_s=0;
     MultidimArray<double> IframeTransformed;
 
     for(size_t s = 0; s< listOfWeights.size(); ++s)
     {
         constructSmoothHistogramsByRow(listOfWeights[s],listOfWidths[s]);
         transformGrayValuesRow(Iframe,IframeTransformed);
         double avgTV=computeTVRows(IframeTransformed);
         if (avgTV<bestAvgTV)
         {
             bestAvgTV=avgTV;
             best_s=s;
         }
     }
 
     return best_s;
 }

◆ show()

void ProgMovieEstimateGain::show ( )

Definition at line 134 of file movie_estimate_gain.cpp.

 {
     if (verbose==0)
         return;
     std::cout
     << "Input movie:     " << fnIn            << std::endl
     << "Output rootname: " << fnRoot          << std::endl
     << "N. Iterations:   " << Niter           << std::endl
     << "Sigma:           " << sigma           << std::endl
     << "Max. Sigma:      " << maxSigma        << std::endl
     << "Sigma step:      " << sigmaStep       << std::endl
     << "Single ref:      " << singleReference << std::endl
     << "Frame step:      " << frameStep       << std::endl
     << "Ext. gain image: " << fnGain          << std::endl
     << "Apply ext. gain: " << applyGain       << std::endl
     ;
 }

◆ transformGrayValuesColumn()

void ProgMovieEstimateGain::transformGrayValuesColumn	(	const MultidimArray< double > &	Iframe,
		MultidimArray< double > &	IframeTransformedColumn
	)

Definition at line 388 of file movie_estimate_gain.cpp.

 {
     IframeTransformedColumn.initZeros(Ydim,Xdim);
     aSingleColumnH.resizeNoCopy(Ydim);
     double *aSingleColumnH0=&DIRECT_A1D_ELEM(aSingleColumnH,0);
     double *aSingleColumnHF=(&DIRECT_A1D_ELEM(aSingleColumnH,Ydim-1))+1;
 
 
     for (size_t j=0; j<Xdim; ++j)
     {
         for (size_t i=0; i<Ydim; ++i)
             DIRECT_A1D_ELEM(aSingleColumnH,i)=DIRECT_A2D_ELEM(columnH,i,j);
 
         for (size_t i=0; i<Ydim; ++i)
         {
             double pixval=DIRECT_A2D_ELEM(Iframe,i,j);
             double *pixvalPtr=std::upper_bound(aSingleColumnH0,aSingleColumnHF,pixval);
             pixvalPtr-=1;
             int idx=pixvalPtr-aSingleColumnH0;
             DIRECT_A2D_ELEM(IframeTransformedColumn,i,j)+=(double)DIRECT_A2D_ELEM(smoothColumnH,idx,j);
         }
     }
 
 
 #ifdef NEVER_DEFINED
     Image<double> save;
     typeCast(IframeTransformedColumn,save());
     save.write("PPPIframeTransformedColumn.xmp");
     typeCast(Iframe,save());
     save.write("PPPIframe.xmp");
     std::cout << "Press any key to continue\n";
     char c; std::cin >> c;
 #endif
 }

◆ transformGrayValuesRow()

void ProgMovieEstimateGain::transformGrayValuesRow	(	const MultidimArray< double > &	Iframe,
		MultidimArray< double > &	IframeTransformedRow
	)

Definition at line 424 of file movie_estimate_gain.cpp.

 {
     IframeTransformedRow.initZeros(Ydim,Xdim);
     aSingleRowH.resizeNoCopy(Xdim);
     double *aSingleRowH0=&DIRECT_A1D_ELEM(aSingleRowH,0);
     double *aSingleRowHF=(&DIRECT_A1D_ELEM(aSingleRowH,Xdim-1))+1;
 
     for (size_t i=0; i<Ydim; ++i)
     {
         memcpy(aSingleRowH0,&DIRECT_A2D_ELEM(rowH,i,0),Xdim*sizeof(double));
 
             for (size_t j=0; j<Xdim; ++j)
             {
                 double pixvalR=DIRECT_A2D_ELEM(Iframe,i,j);
                 double *pixvalPtrR=std::upper_bound(aSingleRowH0,aSingleRowHF,pixvalR);
                 pixvalPtrR-=1;
                 int idxR=pixvalPtrR-aSingleRowH0;
                 DIRECT_A2D_ELEM(IframeTransformedRow,i,j)+=(double)DIRECT_A2D_ELEM(smoothRowH,i,idxR);
             }
     }
 
 #ifdef NEVER_DEFINED
     Image<double> save;
     typeCast(IframeTransformedRow,save());
     save.write("PPPIframeTransformedRow.xmp");
     typeCast(Iframe,save());
     save.write("PPPIframe.xmp");
     std::cout << "Press any key to continue\n";
     char c; std::cin >> c;
 #endif
 
 }

Member Data Documentation

◆ applyGain

bool ProgMovieEstimateGain::applyGain

Definition at line 53 of file movie_estimate_gain.h.

◆ aSingleColumnH

MultidimArray<double> ProgMovieEstimateGain::aSingleColumnH

Definition at line 78 of file movie_estimate_gain.h.

◆ aSingleRowH

MultidimArray<double> ProgMovieEstimateGain::aSingleRowH

Definition at line 78 of file movie_estimate_gain.h.

◆ columnH

MultidimArray<double> ProgMovieEstimateGain::columnH

Definition at line 78 of file movie_estimate_gain.h.

◆ fnCorrected

FileName ProgMovieEstimateGain::fnCorrected

Definition at line 47 of file movie_estimate_gain.h.

◆ fnGain

FileName ProgMovieEstimateGain::fnGain

Definition at line 52 of file movie_estimate_gain.h.

◆ fnIn

FileName ProgMovieEstimateGain::fnIn

Definition at line 45 of file movie_estimate_gain.h.

◆ fnRoot

FileName ProgMovieEstimateGain::fnRoot

Definition at line 46 of file movie_estimate_gain.h.

◆ frameStep

int ProgMovieEstimateGain::frameStep

Definition at line 51 of file movie_estimate_gain.h.

◆ IGain

Image<double> ProgMovieEstimateGain::IGain

Definition at line 80 of file movie_estimate_gain.h.

◆ listOfSigmas

std::vector<double> ProgMovieEstimateGain::listOfSigmas

Definition at line 82 of file movie_estimate_gain.h.

◆ listOfWeights

std::vector<double *> ProgMovieEstimateGain::listOfWeights

Definition at line 84 of file movie_estimate_gain.h.

◆ listOfWidths

std::vector<double> ProgMovieEstimateGain::listOfWidths

Definition at line 83 of file movie_estimate_gain.h.

◆ maxSigma

double ProgMovieEstimateGain::maxSigma

Definition at line 49 of file movie_estimate_gain.h.

◆ mdIn

MetaDataVec ProgMovieEstimateGain::mdIn

Definition at line 77 of file movie_estimate_gain.h.

◆ Niter

int ProgMovieEstimateGain::Niter

Definition at line 48 of file movie_estimate_gain.h.

◆ rowH

MultidimArray<double> ProgMovieEstimateGain::rowH

Definition at line 78 of file movie_estimate_gain.h.

◆ sigma

double ProgMovieEstimateGain::sigma

Definition at line 49 of file movie_estimate_gain.h.

◆ sigmaStep

double ProgMovieEstimateGain::sigmaStep

Definition at line 49 of file movie_estimate_gain.h.

◆ singleReference

bool ProgMovieEstimateGain::singleReference

Definition at line 50 of file movie_estimate_gain.h.

◆ smoothColumnH

MultidimArray<double> ProgMovieEstimateGain::smoothColumnH

Definition at line 79 of file movie_estimate_gain.h.

◆ smoothRowH

MultidimArray<double> ProgMovieEstimateGain::smoothRowH

Definition at line 79 of file movie_estimate_gain.h.

◆ sumObs

MultidimArray<double> ProgMovieEstimateGain::sumObs

Definition at line 79 of file movie_estimate_gain.h.

◆ Xdim

int ProgMovieEstimateGain::Xdim

Definition at line 85 of file movie_estimate_gain.h.

◆ Ydim

int ProgMovieEstimateGain::Ydim

Definition at line 85 of file movie_estimate_gain.h.

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

xmipp/libraries/reconstruction/movie_estimate_gain.h
xmipp/libraries/reconstruction/movie_estimate_gain.cpp

Public Member Functions

Public Attributes

Additional Inherited Members

Detailed Description

Member Function Documentation

◆ computeHistograms()

◆ computeTransformedHistograms()

◆ constructSmoothHistogramsByColumn()

◆ constructSmoothHistogramsByRow()

◆ defineParams()

◆ invertHistograms()

◆ normalizeHistograms()

◆ produceSideInfo()

◆ readParams()

◆ run()

◆ selectBestSigmaByColumn()

◆ selectBestSigmaByRow()

◆ show()

◆ transformGrayValuesColumn()

◆ transformGrayValuesRow()

Member Data Documentation

◆ applyGain

◆ aSingleColumnH

◆ aSingleRowH

◆ columnH

◆ fnCorrected

◆ fnGain

◆ fnIn

◆ fnRoot

◆ frameStep

◆ IGain

◆ listOfSigmas

◆ listOfWeights

◆ listOfWidths

◆ maxSigma

◆ mdIn

◆ Niter

◆ rowH

◆ sigma

◆ sigmaStep

◆ singleReference

◆ smoothColumnH

◆ smoothRowH

◆ sumObs

◆ Xdim

◆ Ydim