#include <normalize.h>

Inheritance diagram for ProgNormalize:

Collaboration diagram for ProgNormalize:

Public Attributes
double	mu0

double	sigma0

Public Attributes inherited from XmippMetadataProgram
FileName	fn_in
	Filenames of input and output Metadata. More...

FileName	fn_out

FileName	baseName

FileName	pathBaseName

FileName	oextBaseName

bool	apply_geo
	Apply geo. More...

size_t	ndimOut
	Output dimensions. More...

size_t	zdimOut

size_t	ydimOut

size_t	xdimOut

DataType	datatypeOut

size_t	mdInSize
	Number of input elements. More...

Public Attributes inherited from XmippProgram
bool	doRun

bool	runWithoutArgs

int	verbose
	Verbosity level. More...

int	debug

Protected Types
enum	NormalizationMode { NONE, OLDXMIPP, NEAR_OLDXMIPP, NEWXMIPP, MICHAEL, NEWXMIPP2, ROBUST, RANDOM, RAMP, NEIGHBOUR, TOMOGRAPHY, TOMOGRAPHY0 }

enum	BackgroundMode { NOBACKGROUND, FRAME, CIRCLE }

Protected Member Functions
void	defineParams ()

void	readParams ()

void	show ()

void	preProcess ()

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

Protected Member Functions inherited from XmippMetadataProgram
virtual void	initComments ()

virtual void	postProcess ()

virtual bool	getImageToProcess (size_t &objId, size_t &objIndex)

void	show () const override

virtual void	startProcessing ()

virtual void	finishProcessing ()

virtual void	writeOutput ()

virtual void	showProgress ()

virtual void	defineLabelParam ()

Protected Member Functions inherited from XmippProgram
void	defineCommons ()

Protected Attributes
NormalizationMode	method

bool	volume

BackgroundMode	background_mode

int	r

double	aF

double	a0

double	bF

double	b0

bool	invert_contrast

bool	clip

bool	tiltMask

bool	remove_black_dust

bool	remove_white_dust

double	thresh_black_dust

double	thresh_white_dust

double	thresh_neigh

MultidimArray< int >	bg_mask

MultidimArray< int >	bg_mask_bck

bool	enable_mask

Mask	mask_prm

Protected Attributes inherited from XmippMetadataProgram
WriteModeMetaData	mode
	Metadata writing mode: OVERWRITE, APPEND. More...

FileName	oext
	Output extension and root. More...

FileName	oroot

MDLabel	image_label
	MDLabel to be used to read/write images, usually will be MDL_IMAGE. More...

bool	produces_an_output
	Indicate that a unique final output is produced. More...

bool	produces_a_metadata
	Indicate that the unique final output file is a Metadata. More...

bool	each_image_produces_an_output
	Indicate that an output is produced for each image in the input. More...

bool	allow_apply_geo

bool	decompose_stacks
	Input Metadata will treat a stack file as a set of images instead of a unique file. More...

bool	delete_output_stack
	Delete previous output stack file prior to process images. More...

bool	get_image_info
	Get the input image file dimensions to further operations. More...

bool	save_metadata_stack
	Save the associated output metadata when output file is a stack. More...

bool	track_origin
	Include the original input image filename in the output stack. More...

bool	keep_input_columns
	Keep input metadata columns. More...

bool	remove_disabled
	Remove disabled images from the input selfile. More...

bool	allow_time_bar
	Show process time bar. More...

bool	input_is_metadata
	Input is a metadata. More...

bool	single_image
	Input is a single image. More...

bool	input_is_stack
	Input is a stack. More...

bool	output_is_stack
	Output is a stack. More...

bool	create_empty_stackfile

bool	delete_mdIn

size_t	time_bar_step
	Some time bar related counters. More...

size_t	time_bar_size

size_t	time_bar_done

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

Additional Inherited Members
Public Member Functions inherited from XmippMetadataProgram
MetaData *	getInputMd ()

MetaDataVec &	getOutputMd ()

	XmippMetadataProgram ()
	Empty constructor. More...

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

virtual void	init ()

virtual void	setup (MetaData *md, const FileName &o="", const FileName &oroot="", bool applyGeo=false, MDLabel label=MDL_IMAGE)

virtual	~XmippMetadataProgram ()

void	setMode (WriteModeMetaData _mode)

void	setupRowOut (const FileName &fnImgIn, const MDRow &rowIn, const FileName &fnImgOut, MDRow &rowOut) const
	Prepare rowout. More...

virtual void	wait ()
	Wait for the distributor to finish. More...

virtual void	checkPoint ()
	For very long programs, it may be needed to write checkpoints. More...

virtual void	run ()
	Run over all images. More...

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)

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	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 ()

Detailed Description

Definition at line 201 of file normalize.h.

Member Enumeration Documentation

◆ BackgroundMode

enum ProgNormalize::BackgroundMode

protected

Possible background modes

Enumerator
NOBACKGROUND
FRAME
CIRCLE

Definition at line 231 of file normalize.h.

                         {
         NOBACKGROUND,
         FRAME,
         CIRCLE
     };

◆ NormalizationMode

enum ProgNormalize::NormalizationMode

protected

Possible normalization modes

Enumerator
NONE
OLDXMIPP
NEAR_OLDXMIPP
NEWXMIPP
MICHAEL
NEWXMIPP2
ROBUST
RANDOM
RAMP
NEIGHBOUR
TOMOGRAPHY
TOMOGRAPHY0

Definition at line 205 of file normalize.h.

                            {
         NONE,
         OLDXMIPP,
         NEAR_OLDXMIPP,
         NEWXMIPP,
         MICHAEL,
         NEWXMIPP2,
         ROBUST,
         RANDOM,
         RAMP,
         NEIGHBOUR,
         TOMOGRAPHY,
         TOMOGRAPHY0
     };

Member Function Documentation

◆ defineParams()

void ProgNormalize::defineParams ( )

protectedvirtual

Function in which the param of each Program are defined.

Reimplemented from XmippMetadataProgram.

Reimplemented in BasicMpiMetadataProgram< ProgNormalize >.

Definition at line 520 of file normalize.cpp.

 {
     each_image_produces_an_output = true;
     allow_apply_geo = true;
     save_metadata_stack = true;
     keep_input_columns = true;
     addUsageLine("Change the range of intensity values of pixels.");
     addUsageLine("In general, most of the methods requires a background to separate "
                  "particles from noise");
     addKeywords("mask,normalization,normalize");
     XmippMetadataProgram::defineParams();
     addParamsLine(" [--method <mth=NewXmipp>]     : Normalizing method.");
     addParamsLine("           where <mth>");
     addParamsLine("           OldXmipp            : I=(I-m(I))/stddev(I)");
     addParamsLine("                               : Avg(I)=0, Stddev(I)=1, does not need background");
     addParamsLine("           Near_OldXmipp       : I=(I-m(I))/stddev(bg)");
     addParamsLine("           NewXmipp            : I=(I-m(bg))/stddev(bg)");
     addParamsLine("                               : Avg(bg)=0, Stddev(I)=1");
     addParamsLine("                               : Positivity constraints can be added in reconstruction");
     addParamsLine("           Tomography          : I=(I-mean(I))/(stddev(I)*cos(tilt))");
     addParamsLine("                               : does not need background, it assumes the tilt series is vertically aligned");
     addParamsLine("                               : Similar to OldXmipp but with an extra division by the cos(tilt)");
     addParamsLine("           Tomography0         : I=(I-mean(I(0 degrees)))/(stddev(I)*cos(tilt))");
     addParamsLine("                               : does not need background");
     addParamsLine("                               : Similar to Tomography but the average at 0 degrees is used for all images");
     addParamsLine("           NewXmipp2           : I=(I-m(bg))/(m(I)-m(bg))");
     addParamsLine("           Robust              : I=(I-m(bg))/P95(I)");
     addParamsLine("           Michael             : I=(I-m(bg))/stddev(bg)");
     addParamsLine("           None                   : Used for removing only dust");
     addParamsLine("           Random                 : I=aI+b");
     addParamsLine("           Ramp                   : Subtract ramp and then NewXmipp");
     addParamsLine("           Neighbour              : Replace pixels in the background with random noise");
     addParamsLine(" [--invert]                       : Invert contrast.");
     addParamsLine(" [--thr_black_dust <sblack=-3.5>] : Remove black dust particles with sigma threshold sblack.");
     addParamsLine(" [--thr_white_dust <swhite=3.5>]  : Remove white dust particles with sigma threshold swhite.");
     addParamsLine(" [--thr_neigh <value=1.2>]        : Sigma threshold for neighbour removal.");
     addParamsLine(" [--prm <a0> <aF> <b0> <bF>]      : Requires --method Random. I=aI+b.");
     addParamsLine(" [--clip]                         : Requires --method Robust. Constrain maximum values in normalize volume.");
     //    addParamsLine("      requires -method Random;");
     addParamsLine(" [--tiltMask]                     : Apply a mask depending on the tilt");
     addParamsLine("                                  : requires --method Tomography or Tomography0");
     addParamsLine(" [--background <mode>] ");
     addParamsLine("        where <mode>");
     addParamsLine("           frame <r>              : Rectangular background of r pixels.");
     addParamsLine("           circle <r>             : Circular background outside radius r.");
     mask_prm.defineParams(this,INT_MASK, "or", "Use an alternative type of background mask.");
     addExampleLine("Normalize using OldXmipp method",false);
     addExampleLine("xmipp_transform_normalize -i images.sel --method OldXmipp",true);
     addExampleLine("Normalize 64x64 images using NewXmipp method",false);
     addExampleLine("xmipp_transform_normalize -i images.sel --method NewXmipp --background circle 29",true);
     addExampleLine("Normalize 64x64 images using NewXmipp method and a crown mask",false);
     addExampleLine("xmipp_transform_normalize -i images.sel --method NewXmipp --mask crown 29 32",true);
     addExampleLine("Normalize a volume to have zero mean and unit variance",false);
     addExampleLine("xmipp_transform_normalize -i volume.vol --method OldXmipp",true);
     addExampleLine("Normalize a volume so that the noise outside a sphere of radius 29 has zero mean and unit variance",false);
     addExampleLine("xmipp_transform_normalize -i volume.vol --background circle 29",true);
 }

◆ preProcess()

void ProgNormalize::preProcess ( )

protectedvirtual

Reimplemented from XmippMetadataProgram.

Reimplemented in BasicMpiMetadataProgram< ProgNormalize >.

Definition at line 769 of file normalize.cpp.

 {
     if (!enable_mask)
     {
         bg_mask.resizeNoCopy(zdimOut, ydimOut, xdimOut);
         bg_mask.setXmippOrigin();
 
         switch (background_mode)
         {
         case FRAME:
             BinaryFrameMask(bg_mask, xdimOut - 2 * r, ydimOut - 2 * r, zdimOut - 2 * r,
                             OUTSIDE_MASK);
             break;
         case CIRCLE:
             if (r>(int)(xdimOut/2))
                 REPORT_ERROR(ERR_ARG_INCORRECT,"Given radius is larger than half the output size");
             BinaryCircularMask(bg_mask, r, OUTSIDE_MASK);
             break;
         case NOBACKGROUND:
             break;
         }
     }
     else
     {
         mask_prm.generate_mask(zdimOut, ydimOut, xdimOut);
         bg_mask = mask_prm.imask;
     }
     // backup a copy of the mask for apply_geo mode
     bg_mask_bck = bg_mask;
 
     //#define DEBUG
 #ifdef DEBUG
 
     Image<int> tt;
     tt()=bg_mask;
     tt.write("PPPmask.xmp");
     std::cerr<<"DEBUG info: written PPPmask.xmp"<<std::endl;
 #endif
 
     // Get the parameters from the 0 degrees
     if (method==TOMOGRAPHY0)
     {
         // Look for the image at 0 degrees
         double bestTilt=1000;
         double tiltTemp;
         FileName bestImage;
         FileName fn_img;
         ImageGeneric Ig;
         MetaData * md = getInputMd();
         for (size_t objId: md->ids())
         {
             md->getValue(image_label, fn_img, objId);
 
             if (fn_img.empty())
                 break;
 
             if (!md->getValue(MDL_ANGLE_TILT,tiltTemp, objId))
             {
                 Ig.readMapped(fn_img);
                 tiltTemp = ABS(Ig.tilt());
             }
             if (tiltTemp < bestTilt)
             {
                 bestTilt = tiltTemp;
                 bestImage = fn_img;
             }
         }
         if (bestImage=="")
             REPORT_ERROR(ERR_VALUE_EMPTY,"Cannot find the image at 0 degrees");
 
         // Compute the mu0 and sigma0 for this image
         Image<double> I;
         I.read(bestImage);
         normalize_tomography(I(), I.tilt(), mu0, sigma0, tiltMask);
     }
 }

◆ processImage()

void ProgNormalize::processImage	(	const FileName &	fnImg,
		const FileName &	fnImgOut,
		const MDRow &	rowIn,
		MDRow &	rowOut
	)

protectedvirtual

Implements XmippMetadataProgram.

Definition at line 846 of file normalize.cpp.

 {
     Image<double> I;
     if (apply_geo)
         I.readApplyGeo(fnImg, rowIn);
     else
         I.read(fnImg);
 
     I().setXmippOrigin();
 
     MultidimArray<double> &img=I();
 
     if (apply_geo)
     {
         Matrix2D<double> A;
         // Applygeo only valid for 2D images for now...
         img.checkDimension(2);
 
         MultidimArray< double > tmp;
         // get copy of the mask
         tmp.resizeNoCopy(bg_mask_bck);
         typeCast(bg_mask_bck, tmp);
 
         double outside = DIRECT_A2D_ELEM(tmp, 0, 0);
 
         // Instead of IS_INV for images use IS_NOT_INV for masks!
         I.getTransformationMatrix(A);
         selfApplyGeometry(xmipp_transformation::BSPLINE3, tmp, A, xmipp_transformation::IS_NOT_INV, xmipp_transformation::DONT_WRAP, outside);
 
         FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY(bg_mask)
         dAi(bg_mask,n)=(int)round(dAi(tmp,n));
     }
 
     double a;
     double b;
     if (invert_contrast)
         img *= -1.;
 
     if (remove_black_dust || remove_white_dust)
     {
         double avg=0.;
         double stddev=0.;
         double min=0.;
         double max=0.;
         double zz;
         img.computeStats(avg, stddev, min, max);
 
         if ((min - avg) / stddev < thresh_black_dust && remove_black_dust)
         {
             FOR_ALL_ELEMENTS_IN_ARRAY3D(img)
             {
                 zz = (A3D_ELEM(img, k, i, j) - avg) / stddev;
                 if (zz < thresh_black_dust)
                     A3D_ELEM(img, k, i, j) = rnd_gaus(avg,stddev);
             }
         }
 
         if ((max - avg) / stddev > thresh_white_dust && remove_white_dust)
         {
             FOR_ALL_ELEMENTS_IN_ARRAY3D(img)
             {
                 zz = (A3D_ELEM(img, k, i, j) - avg) / stddev;
                 if (zz > thresh_white_dust)
                     A3D_ELEM(img, k, i, j) = rnd_gaus(avg,stddev);
             }
         }
     }
 
     double mui;
     double sigmai;
     switch (method)
     {
     case OLDXMIPP:
         normalize_OldXmipp(img);
         break;
     case NEAR_OLDXMIPP:
         normalize_Near_OldXmipp(img, bg_mask);
         break;
     case NEWXMIPP:
         normalize_NewXmipp(img, bg_mask);
         break;
     case NEWXMIPP2:
         normalize_NewXmipp2(img, bg_mask);
         break;
     case ROBUST:
         normalize_Robust(img, bg_mask, clip);
         break;
     case RAMP:
         normalize_ramp(img, &bg_mask);
         break;
     case NEIGHBOUR:
         normalize_remove_neighbours(img, bg_mask, thresh_neigh);
         break;
     case TOMOGRAPHY:
         normalize_tomography(img, I.tilt(), mui, sigmai, tiltMask);
         break;
     case TOMOGRAPHY0:
         normalize_tomography(img, I.tilt(), mui, sigmai, tiltMask,
                              true, mu0, sigma0);
         break;
     case MICHAEL:
         normalize_Michael(img, bg_mask);
         break;
     case RANDOM:
         a = rnd_unif(a0, aF);
         b = rnd_unif(b0, bF);
         FOR_ALL_ELEMENTS_IN_ARRAY3D(img)
         A3D_ELEM(img, k, i, j) = a * A3D_ELEM(img, k, i, j) + b;
         break;
     case NONE:
         break;
     }
     I.write(fnImgOut);
 }

◆ readParams()

void ProgNormalize::readParams ( )

protectedvirtual

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

Reimplemented from XmippMetadataProgram.

Reimplemented in BasicMpiMetadataProgram< ProgNormalize >.

Definition at line 578 of file normalize.cpp.

 {
     XmippMetadataProgram::readParams();
 
     // Get normalizing method
     std::string aux;
     aux = getParam("--method");
 
     if (aux == "OldXmipp")
         method = OLDXMIPP;
     else if (aux == "Near_OldXmipp")
         method = NEAR_OLDXMIPP;
     else if (aux == "NewXmipp")
         method = NEWXMIPP;
     else if (aux == "NewXmipp2")
         method = NEWXMIPP2;
     else if (aux ==  "Robust")
         method = ROBUST;
     else if (aux == "Michael")
         method = MICHAEL;
     else if (aux == "Random")
         method = RANDOM;
     else if (aux == "None")
         method = NONE;
     else if (aux == "Ramp")
         method = RAMP;
     else if (aux == "Neighbour")
         method = NEIGHBOUR;
     else if (aux == "Tomography")
         method = TOMOGRAPHY;
     else if (aux == "Tomography0")
         method = TOMOGRAPHY0;
     else
         REPORT_ERROR(ERR_VALUE_INCORRECT, "Normalize: Unknown normalizing method");
 
     // Invert contrast?
     invert_contrast = checkParam("--invert");
 
     // Constrain values?
     clip = checkParam("--clip");
 
     // Apply a mask depending on the tilt
     tiltMask = checkParam("--tiltMask");
 
     // Remove dust particles?
     remove_black_dust = checkParam("--thr_black_dust");
     remove_white_dust = checkParam("--thr_white_dust");
     thresh_black_dust = getDoubleParam("--thr_black_dust");
     thresh_white_dust = getDoubleParam("--thr_white_dust");
     thresh_neigh      = getDoubleParam("--thr_neigh");
 
     // Get background mask
     background_mode = NOBACKGROUND;
     if (method == NEWXMIPP || method == NEWXMIPP2 || method == MICHAEL ||
         method == NEAR_OLDXMIPP || method == RAMP || method == NEIGHBOUR)
     {
         enable_mask = checkParam("--mask");
         if (enable_mask)
         {
             mask_prm.allowed_data_types = INT_MASK;
             mask_prm.readParams(this);
         }
         else
         {
             if (!checkParam("--background"))
                 REPORT_ERROR(ERR_ARG_MISSING,
                              "Normalize: --background or --mask parameter required.");
 
             aux = getParam("--background",0);
             r  =  getIntParam("--background",1);
 
             if (aux == "frame")
                 background_mode = FRAME;
             else if (aux == "circle")
                 background_mode = CIRCLE;
             else
                 REPORT_ERROR(ERR_VALUE_INCORRECT, "Normalize: Unknown background mode");
         }
     }
 
     if (method == ROBUST)
     {
         enable_mask = checkParam("--mask");
         if (enable_mask)
         {
             mask_prm.allowed_data_types = INT_MASK;
             mask_prm.readParams(this);
         }
     }
 
     if (method == RANDOM)
     {
         if (!checkParam("--prm"))
             REPORT_ERROR(ERR_ARG_MISSING,
                          "Normalize_parameters: -prm parameter required.");
 
         a0 = getDoubleParam("--prm", 0);
         aF = getDoubleParam("--prm", 1);
         b0 = getDoubleParam("--prm", 2);
         bF = getDoubleParam("--prm", 3);
     }
 }

◆ show()

void ProgNormalize::show ( )

protected

Definition at line 681 of file normalize.cpp.

 {
     XmippMetadataProgram::show();
 
     std::cout << "Normalizing method: ";
     switch (method)
     {
     case OLDXMIPP:
         std::cout << "OldXmipp\n";
         break;
     case NEAR_OLDXMIPP:
         std::cout << "Near_OldXmipp\n";
         break;
     case NEWXMIPP:
         std::cout << "NewXmipp\n";
         break;
     case NEWXMIPP2:
         std::cout << "NewXmipp2\n";
         break;
     case ROBUST:
         std::cout << "Robust\n";
         break;
     case MICHAEL:
         std::cout << "Michael\n";
         break;
     case NONE:
         std::cout << "None\n";
         break;
     case RAMP:
         std::cout << "Ramp\n";
         break;
     case NEIGHBOUR:
         std::cout << "Neighbour\n";
         break;
     case TOMOGRAPHY:
         std::cout << "Tomography\n";
         break;
     case TOMOGRAPHY0:
         std::cout << "Tomography0\n";
         break;
     case RANDOM:
         std::cout << "Random a=[" << a0 << "," << aF << "], " << "b=[" <<
         b0 << "," << bF << "]\n";
         break;
     }
 
     if (method == NEWXMIPP || method == NEWXMIPP2 ||
         method == NEAR_OLDXMIPP || method == MICHAEL ||
         method == RAMP || method == NEIGHBOUR || method == ROBUST)
     {
         std::cout << "Background mode: ";
         switch (background_mode)
         {
         case NOBACKGROUND :
             std::cout << "None\n";
             break;
         case FRAME:
             std::cout << "Frame, width=" << r << std::endl;
             std::cout << "Apply transformation to mask: " << apply_geo <<
             std::endl;
             break;
         case CIRCLE:
             std::cout << "Circle, radius=" << r << std::endl;
             std::cout << "Apply transformation to mask: " << apply_geo <<
             std::endl;
             break;
         }
     }
 
     if (invert_contrast)
         std::cout << "Invert contrast "<< std::endl;
 
     if (tiltMask)
         std::cout << "Applying a mask depending on tilt "<< std::endl;
 
     if (remove_black_dust)
         std::cout << "Remove black dust particles, using threshold " <<
         floatToString(thresh_black_dust) << std::endl;
 
     if (remove_white_dust)
         std::cout << "Remove white dust particles, using threshold " <<
         floatToString(thresh_white_dust) << std::endl;
 
     if (method == NEWXMIPP && enable_mask)
         mask_prm.show();
 }

Member Data Documentation

◆ a0

double ProgNormalize::a0

protected

Lower limit of a in y=ax+b.

Definition at line 252 of file normalize.h.

◆ aF

double ProgNormalize::aF

protected

Upper limit of a in y=ax+b.

Definition at line 248 of file normalize.h.

◆ b0

double ProgNormalize::b0

protected

Lower limit of b in y=ax+b.

Definition at line 260 of file normalize.h.

◆ background_mode

BackgroundMode ProgNormalize::background_mode

protected

Background mode. Valid modes are NONE, FRAME, CIRCLE.

Definition at line 240 of file normalize.h.

◆ bF

double ProgNormalize::bF

protected

Upper limit of b in y=ax+b.

Definition at line 256 of file normalize.h.

◆ bg_mask

MultidimArray<int> ProgNormalize::bg_mask

protected

Definition at line 288 of file normalize.h.

◆ bg_mask_bck

MultidimArray<int> ProgNormalize::bg_mask_bck

protected

Definition at line 289 of file normalize.h.

◆ clip

bool ProgNormalize::clip

protected

Flag for clipping

Definition at line 268 of file normalize.h.

◆ enable_mask

bool ProgNormalize::enable_mask

protected

Definition at line 290 of file normalize.h.

◆ invert_contrast

bool ProgNormalize::invert_contrast

protected

Flag for inverting contrast

Definition at line 264 of file normalize.h.

◆ mask_prm

Mask ProgNormalize::mask_prm

protected

Definition at line 294 of file normalize.h.

◆ method

NormalizationMode ProgNormalize::method

protected

Normalizing method. Valid methods are OLDXMIPP, NEAR_OLDXMIPP, NEWXMIPP, NEWXMIPP2, MICHAEL, NONE, RANDOM, RAMP, NEIGHBOUR, TOMOGRAPHY, TOMOGRAPHY0.

Definition at line 224 of file normalize.h.

◆ mu0

double ProgNormalize::mu0

Definition at line 298 of file normalize.h.

◆ r

int ProgNormalize::r

protected

Frame width or circle radius.

Definition at line 244 of file normalize.h.

◆ remove_black_dust

bool ProgNormalize::remove_black_dust

protected

Flags for removing balck/white spots due to dust.

Definition at line 276 of file normalize.h.

◆ remove_white_dust

bool ProgNormalize::remove_white_dust

protected

Definition at line 277 of file normalize.h.

◆ sigma0

double ProgNormalize::sigma0

Definition at line 299 of file normalize.h.

◆ thresh_black_dust

double ProgNormalize::thresh_black_dust

protected

Threshold for removing black/white (dust) spots.

Definition at line 281 of file normalize.h.

◆ thresh_neigh

double ProgNormalize::thresh_neigh

protected

Sigma threshold for neighbour removal.

Definition at line 286 of file normalize.h.

◆ thresh_white_dust

double ProgNormalize::thresh_white_dust

protected

Definition at line 282 of file normalize.h.

◆ tiltMask

bool ProgNormalize::tiltMask

protected

Flag for applying a mask depending on the tilt

Definition at line 272 of file normalize.h.

◆ volume

bool ProgNormalize::volume

protected

Normalization of volumes.

Definition at line 228 of file normalize.h.

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

xmipp/libraries/data/normalize.h
xmipp/libraries/data/normalize.cpp

Public Attributes

Protected Types

Protected Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ BackgroundMode

◆ NormalizationMode

Member Function Documentation

◆ defineParams()

◆ preProcess()

◆ processImage()

◆ readParams()

◆ show()

Member Data Documentation

◆ a0

◆ aF

◆ b0

◆ background_mode

◆ bF

◆ bg_mask

◆ bg_mask_bck

◆ clip

◆ enable_mask

◆ invert_contrast

◆ mask_prm

◆ method

◆ mu0

◆ r

◆ remove_black_dust

◆ remove_white_dust

◆ sigma0

◆ thresh_black_dust

◆ thresh_neigh

◆ thresh_white_dust

◆ tiltMask

◆ volume