ProgIDRXrayTomo Class Reference

#include <idr_xray_tomo.h>

Inheritance diagram for ProgIDRXrayTomo:

Collaboration diagram for ProgIDRXrayTomo:

Public Types
enum	{ RECONS_ART, RECONS_FOURIER, RECONS_TOMO3D }

Public Member Functions
virtual void	run ()
void	reconstruct (const FileName &fnProjs, const FileName &fnVol)
ProgReconsBase *	createReconsProgram (const FileName &input, const FileName &output)
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	fnInputProjMD
	Metadafile with angles and projection file names. More...
FileName	fnRootInter
	Rootname for intermediate/exchange projections metadatas and files. More...
FileName	fnInterProjs
FileName	fnInterProjsMD
FileName	fnInterAngles
FileName	fnOutVol
	Reconstructed output volume file name. More...
FileName	fnStart
	Initial volume. More...
FileName	fnPSF
	Xray Microscope PSF Parameters. More...
XRayPSF	psf
	Xray PSF Object. More...
double	psfThr
	threshold for psfSlabs More...
double	sampling
int	nThr
	Number of threads;. More...
int	itNum
	Number of iterations. More...
Matrix1D< double >	lambda_list
	Relaxation parameter. More...
enum ProgIDRXrayTomo:: { ... }	reconsMethod
ProgReconsBase *	reconsProgram
Image< double >	muVol
MetaDataVec	projMD
MetaDataVec	interProjMD
XrayProjPhantom	phantom
Projection	proj
ParallelTaskDistributor *	td
Public Attributes inherited from XmippProgram
bool	doRun
bool	runWithoutArgs
int	verbose
	Verbosity level. More...
int	debug

Protected Member Functions
virtual void	defineParams ()
virtual void	readParams ()
void	preRun ()
void	postRun ()
Protected Member Functions inherited from XmippProgram
void	defineCommons ()

Additional Inherited Members
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 38 of file idr_xray_tomo.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

Enumerator
RECONS_ART
RECONS_FOURIER
RECONS_TOMO3D

Definition at line 74 of file idr_xray_tomo.h.

    {
        RECONS_ART,
        RECONS_FOURIER,
        RECONS_TOMO3D
    } reconsMethod;

Member Function Documentation

createReconsProgram()

ProgReconsBase * ProgIDRXrayTomo::createReconsProgram	(	const FileName &	input,
		const FileName &	output
	)

Definition at line 342 of file idr_xray_tomo.cpp.

{
    //get reconstruction extra params
    String arguments = getParam("--recons", 1) +
                       formatString(" -v 0 --thr %d -i %s -o %s", nThr, input.c_str(), output.c_str());
    ProgReconsBase * program;
    //    std::cerr << "DEBUG_JM: ProgMLRefine3D::createReconsProgram" <<std::endl;
    //    std::cerr << "DEBUG_JM: arguments: " << arguments << std::endl;
    //    std::cerr << "DEBUG_JM: input: " << input << std::endl;

    if (reconsMethod == RECONS_FOURIER)
    {
        program = new ProgRecFourier();
        //force use of weights and the verbosity will be the same of this program
        //-i and -o options are passed for avoiding errors, this should be changed
        //when reconstructing
        //        arguments += " --weight";
        program->read(arguments);
        return program;
    }
    else if (reconsMethod == RECONS_ART)//use of Art
    {
        //REPORT_ERROR(ERR_NOT_IMPLEMENTED,"not implemented reconstruction through wlsArt");
        program = new ProgReconsART();
        FileName fn_tmp(arguments);
        //        arguments += " --WLS";
        //        if (fn_symmask.empty() && checkParam("--sym"))
        //            arguments += " --sym " + fn_sym;
        if (!fn_tmp.contains("-n "))
            arguments += " -n 10";
        if (!fn_tmp.contains("-l "))
            arguments += " -l 0.2";
        //        if (!fn_tmp.contains("-k "))
        //            arguments += " -k 0.5";

        program->read(arguments);
        return program;
    }
    return nullptr;
}

defineParams()

void ProgIDRXrayTomo::defineParams ( )

protectedvirtual

Function in which the param of each Program are defined.

Reimplemented from XmippProgram.

Definition at line 32 of file idr_xray_tomo.cpp.

{
    addUsageLine("Iterative Data Refinement applied to the reconstruction of X-ray tomography projections.");
    //Params
    //    projParam.defineParams(this); // Projection parameters
    addParamsLine("-i <md_file>  : Metadata file with input projections");
    addParamsLine("alias --input;");
    addParamsLine(" [--oroot <rootname=\"idr_xray\">]  : Rootname used for refined projections");
    addParamsLine(" [-o <Vol_file=\"idr_recon_vol.mrc\">]  : Filename for refined output volume");
    addParamsLine("alias --output;");
    addParamsLine(" [--start <start_vol_file=\"\">]  : Start from this basis volume. The reconstruction is performed in the same grid as the one ");
    addParamsLine(" [-s <Ts>]          : Sampling rate (nm)");
    addParamsLine("alias --sampling_rate;");
    addParamsLine("[--thr <threads=1>]           : Number of concurrent threads.");

    addParamsLine("== Iterations options == ");
    addParamsLine("  [-l <...>]                  : Relaxation factor, by default 1.8 (recommended range 0.0 - 2.0). ");
    addParamsLine("                              : A list of lambda values is also accepted as \"-l lambda0 lambda1 ...\"");
    addParamsLine("  [-n <noit=1>]               : Number of iterations");

    addParamsLine("== Reconstruction options == ");
    addParamsLine("[--recons <recons_type=ART>]        : Reconstruction method to be used");
    addParamsLine("       where <recons_type>           ");
    addParamsLine("           ART  <params=\"\">        : wlsART parameters");
    addParamsLine("           fourier <params=\"\">     : fourier parameters");
    addParamsLine("           tomo3d  <params=\"\">     : tomo3d parameters");


    addParamsLine("== Xray options == ");
    addParamsLine("[--psf <psf_param_file=\"\">] : XRay-Microscope parameters file. If not set, then default parameters are chosen.");
    addParamsLine("[--threshold <thr=0.0>]       :+ Normalized threshold relative to maximum of PSF to reduce the volume into slabs");
    //Examples
    //Example projection file
    //    addExampleLine("In the following link you can find an example of projection parameter file:",false);
    //    addExampleLine(" ",false);
    //    addExampleLine("http://newxmipp.svn.sourceforge.net/viewvc/newxmipp/trunk/testXmipp/input/tomoProjection.param",false);
    //    addExampleLine(" ",false);
    //    addExampleLine("In the following link you can find an example of X-ray microscope parameters file:",false);
    //    addExampleLine(" ",false);
    //    addExampleLine("http://newxmipp.svn.sourceforge.net/viewvc/newxmipp/trunk/testXmipp/input/xray_psf.xmd",false);
}

postRun()

void ProgIDRXrayTomo::postRun ( )

protected

preRun()

void ProgIDRXrayTomo::preRun ( )

protected

Definition at line 122 of file idr_xray_tomo.cpp.

{
    psf.read(fnPSF);
    psf.verbose = verbose;
    psf.nThr = nThr;

    psf.calculateParams(sampling, sampling, psfThr);

    // Threads stuff
    barrier = new Barrier(nThr);
    //Create threads to start working
    thMgr = new ThreadManager(nThr);

    // Reading the input projections. Tilt angle values are needed
    projMD.read(fnInputProjMD);

    // Setting the intermediate filenames
    fnInterProjs = fnRootInter + "_inter_projs";
    fnInterProjs += (reconsMethod == RECONS_TOMO3D)? ".mrc" : ".stk";

    fnInterProjsMD = fnInterProjs.replaceExtension("xmd");
    fnInterAngles = fnRootInter + "_angles.txt";

    // We make sure to delete intermediate files
    fnInterProjs.deleteFile();
    fnInterProjsMD.deleteFile();

    FileName fnProjs;
    projMD.getValue(MDL_IMAGE, fnProjs, projMD.firstRowId());
    // We generate the MD of temporary projections to be used for further reconstructions
    interProjMD = projMD;
    interProjMD.replace(MDL_IMAGE, fnProjs.removePrefixNumber(), fnInterProjs);
    interProjMD.write(fnInterProjsMD);

    String arguments = formatString("-i %s -o %s -s",
                                    fnInputProjMD.c_str(), fnInterProjs.c_str());
    ProgConvImg conv;
    conv.read(arguments);
    conv.run();

    // Saving angles in plain text to pass to tomo3D
    if ( reconsMethod == RECONS_TOMO3D )
    {
        std::vector<MDLabel> desiredLabels;
        desiredLabels.push_back(MDL_ANGLE_TILT);
        projMD.writeText(fnInterAngles, &desiredLabels);
    }

    if (fnStart.empty()) // if initial volume is not passed,then we must calculate it
    {
        // Projections must be in an MRC stack to be passed
        if ( reconsMethod == RECONS_TOMO3D )
            reconstruct(fnInterProjsMD, fnOutVol);
        else
        {
            reconstruct(fnInputProjMD, fnOutVol);
            phantom.read(fnOutVol);
        }
    }
    else
        phantom.read(fnStart);
}

readParams()

void ProgIDRXrayTomo::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 XmippProgram.

Definition at line 75 of file idr_xray_tomo.cpp.

{
    fnInputProjMD = getParam("-i");
    fnOutVol = getParam("-o");
    fnRootInter = getParam("--oroot");
    fnStart = getParam("--start");
    //    projParam.readParams(this);

    fnPSF = getParam("--psf");
    sampling  = (checkParam("-s"))? getDoubleParam("-s")*1e-9 : -1 ;
    psfThr = getDoubleParam("--threshold");
    nThr = getIntParam("--thr");

    // Iteration parameters
    StringVector list;
    getListParam("-l", list);
    size_t listSize = list.size();

    if (listSize != 0)
    {
        lambda_list.resizeNoCopy(listSize);

        for (size_t k = 0; k < listSize; k++)
            VEC_ELEM(lambda_list, k) = textToFloat(list[k]);
    }
    else
    {
        lambda_list.resizeNoCopy(1);
        VEC_ELEM(lambda_list, 0) = 1.8;
    }

    itNum = getIntParam("-n");

    // Reconstruction
    if (STR_EQUAL(getParam("--recons"), "ART"))
        reconsMethod = RECONS_ART;
    else if (STR_EQUAL(getParam("--recons"), "fourier"))
        reconsMethod = RECONS_FOURIER;
    else if (STR_EQUAL(getParam("--recons"), "tomo3d"))
        reconsMethod = RECONS_TOMO3D;



}//readParams

reconstruct()

void ProgIDRXrayTomo::reconstruct	(	const FileName &	fnProjs,
		const FileName &	fnVol
	)

Definition at line 287 of file idr_xray_tomo.cpp.

{
    if (reconsMethod == RECONS_TOMO3D)
    {
        MetaDataVec MD(fnProjsMD);
        FileName fnProjs;
        MD.getValue(MDL_IMAGE, fnProjs, MD.firstRowId());

        reconsTomo3D(fnInterAngles, fnProjs.removePrefixNumber(), fnVol);
        phantom.read(fnVol);
        MULTIDIM_ARRAY(phantom.iniVol).resetOrigin();
        MULTIDIM_ARRAY(phantom.iniVol).reslice(VIEW_Y_NEG);
        //FIXME: this is a temporary fixing to match the reconstructed volume with phantom
        double factor = 1/13.734;
        MULTIDIM_ARRAY(phantom.iniVol) *= factor;
    }
    else
    {
        reconsProgram = createReconsProgram(fnProjsMD, fnVol);
        reconsProgram->run();
        delete reconsProgram;
    }
}

run()

void ProgIDRXrayTomo::run ( )

virtual

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

Reimplemented from XmippProgram.

Definition at line 185 of file idr_xray_tomo.cpp.

{
    preRun();

    Projection proj, stdProj;
    Image<double> fixedProj, prevFProj;
    MultidimArray<double> mFixedProj, mPrevFProj;


    double rot, tilt, psi;

    double lambda = VEC_ELEM(lambda_list, 0);

    FileName fnProj;

    for (int iter = 0; iter < itNum; iter++)
    {
        std::cout << "== Iteration " << iter << std::endl;
        std::cout << "Projecting ..." <<std::endl;

        // Fix the reconstructed volume to physical density values
        double factor = 1/sampling;
        MULTIDIM_ARRAY(phantom.iniVol) *= factor;
        // remove negative values
        forcePositive(MULTIDIM_ARRAY(phantom.iniVol));

        initProgress(projMD.size());
        size_t imgNo = 1; // Image number
        double meanError = 0.;

        for (size_t objId : projMD.ids())
        {
            projMD.getValue(MDL_IMAGE , fnProj, objId);
            projMD.getValue(MDL_ANGLE_ROT , rot, objId);
            projMD.getValue(MDL_ANGLE_TILT, tilt, objId);
            projMD.getValue(MDL_ANGLE_PSI , psi, objId);
            proj.setAngles(rot, tilt, psi);

            XrayRotateAndProjectVolumeOffCentered(phantom, psf, proj, stdProj, YSIZE(MULTIDIM_ARRAY(phantom.iniVol)),
                                                  XSIZE(MULTIDIM_ARRAY(phantom.iniVol)));

            /* Image normalization to optimize for reconstruction.
             * To correct for self-attenuation (without considering 3DPSF)
             * I = -ln(Iab)
             */
//            FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY(MULTIDIM_ARRAY(proj))
//            dAi(MULTIDIM_ARRAY(proj),n) = -log(1. - dAi(MULTIDIM_ARRAY(proj),n));


            fixedProj.read(fnProj);
            mFixedProj.alias(MULTIDIM_ARRAY(fixedProj));

            FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY(mFixedProj)
            dAi(mFixedProj, n) = (log(1. - dAi(MULTIDIM_ARRAY(proj),n)) - log(dAi(mFixedProj, n)))*lambda +  dAi(MULTIDIM_ARRAY(stdProj),n);

            prevFProj.read(fnInterProjs, DATA, imgNo); // To calculate meanError
            mPrevFProj.alias(MULTIDIM_ARRAY(prevFProj));

            // Write the refined projection
            fixedProj.write(fnInterProjs, imgNo, true, WRITE_REPLACE);

            // debug stuff //
            if (verbose > 5)
            {
                proj.write(fnRootInter + "_debug_proj.stk", imgNo , true, WRITE_REPLACE);
                stdProj.write(fnRootInter + "_debug_std_proj.stk", imgNo , true, WRITE_REPLACE);

                FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY(mFixedProj)
                dAi(mFixedProj, n) = dAi(MULTIDIM_ARRAY(stdProj),n) - dAi(MULTIDIM_ARRAY(proj),n)*lambda ;

                fixedProj.write(fnRootInter + "_debug_diff_proj.stk", imgNo , true, WRITE_REPLACE);
            }

            FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY(mFixedProj)
            meanError += fabs(dAi(mPrevFProj, n) - dAi(mFixedProj, n));

            ++imgNo;
            // Update progress bar
            setProgress();
        }
        // Once calculated all fixed projection, let reconstruct again
        endProgress();

        meanError /= (NZYXSIZE(mFixedProj)*projMD.size());

        std::cout << "Mean error = " << meanError <<std::endl;

        std::cout << "Reconstructing ..." << std::endl;
        reconstruct(fnInterProjsMD, fnOutVol);

        if ( (iter < itNum-1) && (reconsMethod != RECONS_TOMO3D) ) // Since we process the output of tomo3d, this is already read
            phantom.read(fnOutVol);

    }

    // Finish progress bar

    if (reconsMethod == RECONS_TOMO3D) // Trick to save the processed output of tomo3d
        phantom.iniVol.write(fnOutVol);

}

Member Data Documentation

fnInputProjMD

FileName ProgIDRXrayTomo::fnInputProjMD

Metadafile with angles and projection file names.

Definition at line 43 of file idr_xray_tomo.h.

fnInterAngles

FileName ProgIDRXrayTomo::fnInterAngles

Definition at line 48 of file idr_xray_tomo.h.

fnInterProjs

FileName ProgIDRXrayTomo::fnInterProjs

Definition at line 46 of file idr_xray_tomo.h.

fnInterProjsMD

FileName ProgIDRXrayTomo::fnInterProjsMD

Definition at line 47 of file idr_xray_tomo.h.

fnOutVol

FileName ProgIDRXrayTomo::fnOutVol

Reconstructed output volume file name.

Definition at line 50 of file idr_xray_tomo.h.

fnPSF

FileName ProgIDRXrayTomo::fnPSF

Xray Microscope PSF Parameters.

Definition at line 56 of file idr_xray_tomo.h.

fnRootInter

FileName ProgIDRXrayTomo::fnRootInter

Rootname for intermediate/exchange projections metadatas and files.

Definition at line 45 of file idr_xray_tomo.h.

fnStart

FileName ProgIDRXrayTomo::fnStart

Initial volume.

Definition at line 52 of file idr_xray_tomo.h.

interProjMD

MetaDataVec ProgIDRXrayTomo::interProjMD

Definition at line 85 of file idr_xray_tomo.h.

itNum

int ProgIDRXrayTomo::itNum

Number of iterations.

Definition at line 68 of file idr_xray_tomo.h.

lambda_list

Matrix1D<double> ProgIDRXrayTomo::lambda_list

Relaxation parameter.

Definition at line 70 of file idr_xray_tomo.h.

muVol

Image<double> ProgIDRXrayTomo::muVol

Definition at line 83 of file idr_xray_tomo.h.

nThr

int ProgIDRXrayTomo::nThr

Number of threads;.

Definition at line 64 of file idr_xray_tomo.h.

phantom

XrayProjPhantom ProgIDRXrayTomo::phantom

Definition at line 86 of file idr_xray_tomo.h.

proj

Projection ProgIDRXrayTomo::proj

Definition at line 87 of file idr_xray_tomo.h.

projMD

MetaDataVec ProgIDRXrayTomo::projMD

Definition at line 84 of file idr_xray_tomo.h.

psf

XRayPSF ProgIDRXrayTomo::psf

Xray PSF Object.

Definition at line 58 of file idr_xray_tomo.h.

psfThr

double ProgIDRXrayTomo::psfThr

threshold for psfSlabs

Definition at line 60 of file idr_xray_tomo.h.

reconsMethod

enum { ... } ProgIDRXrayTomo::reconsMethod

reconsProgram

ProgReconsBase* ProgIDRXrayTomo::reconsProgram

Definition at line 81 of file idr_xray_tomo.h.

sampling

double ProgIDRXrayTomo::sampling

Definition at line 62 of file idr_xray_tomo.h.

td

ParallelTaskDistributor* ProgIDRXrayTomo::td

Definition at line 88 of file idr_xray_tomo.h.

---

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

• xmipp/legacy/libraries/reconstruction/idr_xray_tomo.h
• xmipp/legacy/libraries/reconstruction/idr_xray_tomo.cpp