project_xray.h

Go to the documentation of this file.

/***************************************************************************
 * Authors:     Joaquin Oton (joton@cnb.csic.es)
 *
 *
 * Unidad de  Bioinformatica of Centro Nacional de Biotecnologia , CSIC
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
 * 02111-1307  USA
 *
 *  All comments concerning this program package may be sent to the
 *  e-mail address 'xmipp@cnb.csic.es'
 ***************************************************************************/

#ifndef _PROJECTXRAY_H_
#define _PROJECTXRAY_H_

#include "core/metadata_vec.h"
#include "core/xmipp_program.h"
#include "core/xmipp_threads.h"
#include "data/fourier_projection.h"
#include "data/projection.h"
#include "data/psf_xr.h"


struct XrayThreadArgument
{
    XRayPSF               *psf;
    MultidimArray<double> *muVol;
    MultidimArray<double> *IgeoVol;
    MultidimArray<double> *IgeoZb;
    Projection            *projOut;
    MultidimArray<double> *projNorm;
    int        forw;
    std::vector<int>    *phantomSlabIdx;
    std::vector<int>    *psfSlicesIdx;
    ParallelTaskDistributor * td;
    Barrier     * barrier;
};

class XrayProjPhantom
{
public:
    Image<double>          iniVol;
    MultidimArray<double> rotVol;

    void read(const ParametersProjectionTomography &prm);

    void read(const FileName &fnVol);
};

/* Projection XR Program -------------------------------- */
class ProgXrayProject: public virtual XmippProgram
{

public:
    FileName fn_proj_param;
    FileName fn_sel_file;
    FileName fn_psf_xr;
    // Projection parameters
    ParametersProjectionTomography projParam;
    // Microscope optics parameters
    XRayPSF psf;
    double psfThr;
    // Input volume sampling
    double dxo;
    int nThr;
    bool save_std_projs;

    XrayProjPhantom phantom;
    Projection   proj, stdProj;
    MetaDataVec  projMD;
    ParallelTaskDistributor * td;

protected:
    virtual void defineParams();
    virtual void readParams();

public:

    virtual void run();

protected:

    void preRun();
    void postRun();
};

void XrayRotateAndProjectVolumeOffCentered(XrayProjPhantom &side, XRayPSF &psf, Projection &P, Projection &standardP,
        int Ydim, int Xdim);

void projectXrayVolume(MultidimArray<double> &muVol,
                       MultidimArray<double> &IgeoVol,
                       XRayPSF &psf, Projection &P, MultidimArray<double> * projNorm=nullptr, ThreadManager * ThrMgr=nullptr);

//Some global threads management variables
extern Mutex mutex;
extern Barrier * barrier;
extern ThreadManager * thMgr;

void threadXrayProject(ThreadArgument &thArg);

struct CIGTArgument
{
    double samplingZ;
    MultidimArray<double> *muVol;   
    MultidimArray<double> *cumMu;   
    MultidimArray<double> *IgeoVol; 
    MultidimArray<double> *IgeoZb;  
    ParallelTaskDistributor * td;

    CIGTArgument()
    {
        samplingZ = 0;
        muVol = cumMu = IgeoVol = IgeoZb = nullptr;
        td = nullptr;
    }
};

void calculateIgeo(MultidimArray<double> &muVol, double sampling, MultidimArray<double> &IgeoVol,
                   MultidimArray<double> &cumMu, MultidimArray<double> &IgeoZb,
                   int nThreads = 1 , ThreadManager * ThrMgr = nullptr);

void calculateIgeoThread(ThreadArgument &thArg);


void projectXrayGridVolume(
    MultidimArray<double> &muVol,                  // Volume
    XRayPSF &psf,                   // Basis
    MultidimArray<double> &IgeoVol,    
    Projection       &proj,               // Projection
    MultidimArray<double> *projNorm,     // Projection of a unitary volume
    int              FORW,                // 1 if we are projecting a volume
    //   norm_proj is calculated
    // 0 if we are backprojecting
    //   norm_proj must be valid
    ThreadManager * thMgr);

void projectXraySimpleGrid(MultidimArray<double> *vol,  const XRayPSF &psf,
                           MultidimArray<double> *IgeoVol,
                           Projection *proj, MultidimArray<double> &projNorm, int FORW,
                           int threadId = -1, int nThreads = 1);

struct PXSGTArgument
{
    double sampling;
    MultidimArray<double> *muVol;
    MultidimArray<double> *IgeoVol;
    MultidimArray<double> *IgeoZb;
    ParallelTaskDistributor * td;
};


void projectXraySimpleGridThread(ThreadArgument &thArg);


#endif /* _PROJECTXR_H_ */