#include <tomo_detect_missing_wedge.h>

Inheritance diagram for ProgDetectMissingWedge:

Collaboration diagram for ProgDetectMissingWedge:

Public Member Functions
void	readParams ()
	Read parameters from command line. More...

void	produceSideInfo ()
	Produce side info. More...

void	show () const
	Show parameters. More...

void	defineParams ()
	Usage. More...

void	run ()
	Run. 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)

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	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	fn_vol
	Input volume. More...

double	planeWidth
	Plane width. More...

double	maxFreq
	Maximum frequency of the plane. More...

bool	saveMarks
	Save marks. More...

bool	saveMask
	Save mask. More...

Image< double >	V

MultidimArray< double > *	Vmag

double	rotPos

double	tiltPos

double	rotNeg

double	tiltNeg

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

Parameters for the program detecting the missing wedge

Definition at line 37 of file tomo_detect_missing_wedge.h.

Member Function Documentation

◆ defineParams()

void ProgDetectMissingWedge::defineParams ( )

virtual

Usage.

Reimplemented from XmippProgram.

Definition at line 306 of file tomo_detect_missing_wedge.cpp.

 {
     addUsageLine("Detect the orientation of the missing wedge in a tomogram. ");
     addUsageLine("+For doing so it fits a couple of planes along which there is a maximum ");
     addUsageLine("+variation between the energy of the Fourier transform on its left and ");
     addUsageLine("+on its right. The missing wedge is coded with four angles (two for each ");
     addUsageLine("+plane). You may also produce a mask with 1 where the missing wedge is, ");
     addUsageLine("+and 0 where the data has been actually measured. Finally, you can also ");
     addUsageLine("+produce a marked magnitude volume (i.e., the magnitude of the Fourier ");
     addUsageLine("+transform where the position of the two planes have been marked). ");
     addParamsLine("  -i <file>           : Input tomogram");
     addParamsLine(" [--maxFreq <f=0.25>] : Maximum frequency to fit the plane (normalized to 0.5)");
     addParamsLine(" [--width <w=2>]      : Width of the probe plane");
     addParamsLine(" [--saveMarks]        : Save the magnitude of the FFT with");
     addParamsLine("                      : marks showing the two planes");
     addParamsLine(" [--saveMask]         : Save a mask for the FFT of this tomogram");
     addParamsLine("                      : 1=Missing wedge, 0=non missing wedge");
     addExampleLine("xmipp_tomo_detect_missing_wedge -i tomogram.vol");
 }

◆ produceSideInfo()

void ProgDetectMissingWedge::produceSideInfo ( )

Produce side info.

Definition at line 281 of file tomo_detect_missing_wedge.cpp.

 {
     V.read(fn_vol);
     FourierTransformer transformer;
     MultidimArray< std::complex<double> > Vfft;
     transformer.FourierTransform(MULTIDIM_ARRAY(V),Vfft,false);
     Vmag = new MultidimArray<double>();
     Vmag->resize(Vfft);
     FOR_ALL_ELEMENTS_IN_ARRAY3D(*Vmag)
     (*Vmag)(k,i,j)=20*log10(abs(Vfft(k,i,j)));
 }

◆ readParams()

void ProgDetectMissingWedge::readParams ( )

virtual

Read parameters from command line.

Reimplemented from XmippProgram.

Definition at line 271 of file tomo_detect_missing_wedge.cpp.

 {
     fn_vol  = getParam("-i");
     maxFreq = getDoubleParam("--maxFreq");
     planeWidth = getDoubleParam("--width");
     saveMarks = checkParam("--saveMarks");
     saveMask = checkParam("--saveMask");
 }

◆ run()

void ProgDetectMissingWedge::run ( )

virtual

Run.

Reimplemented from XmippProgram.

Definition at line 327 of file tomo_detect_missing_wedge.cpp.

 {
     produceSideInfo();
     FileName fn_root=V.name().withoutExtension();
 
     MultidimArray<double> * mdaV = &MULTIDIM_ARRAY(V);
 
     // Detect one of the planes
     lookForPlane(mdaV, Vmag, maxFreq, planeWidth, 1, rotPos, tiltPos);
 
     auto * Vdraw = new Image<double>();
 
     if (saveMarks)
     {
         (*Vdraw)()=(*Vmag);
 
         evaluatePlane(rotPos, tiltPos, mdaV, Vmag, maxFreq, planeWidth,
                       1, &(*Vdraw)());
     }
 
     // Detect the other plane
     lookForPlane(mdaV, Vmag, maxFreq, planeWidth, -1, rotNeg, tiltNeg, true, rotPos, tiltPos);
 
     if (saveMarks)
     {
         evaluatePlane(rotNeg, tiltNeg, mdaV, Vmag, maxFreq, planeWidth,
                       -1, &(*Vdraw)());
         Vdraw->write(fn_root+"_marks.vol");
     }
 
     if (saveMask)
     {
         Vdraw->clear();
         drawWedge(rotPos, tiltPos, rotNeg, tiltNeg, mdaV, Vmag, &(*Vdraw)());
         Vdraw->write(fn_root+"_mask.vol");
     }
 
     std::cout << "Plane1: " << rotPos << " " << tiltPos << std::endl;
     std::cout << "Plane2: " << rotNeg << " " << tiltNeg << std::endl;
 
     delete Vdraw;
     delete Vmag;
 }

◆ show()

void ProgDetectMissingWedge::show ( ) const

virtual

Show parameters.

Reimplemented from XmippProgram.

Definition at line 294 of file tomo_detect_missing_wedge.cpp.

 {
     std::cout << "Detecting a missing wedge\n";
     std::cout << "Input volume:   " << fn_vol     << std::endl
     << "Maximum Freq.:  " << maxFreq    << std::endl
     << "Plane width:    " << planeWidth << std::endl
     << "saveMarks:      " << saveMarks  << std::endl
     << "saveMask:       " << saveMask   << std::endl
     ;
 }