psf_xr.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 _PSF_XR_HH
#define _PSF_XR_HH

#include "core/matrix2d.h"
#include "core/xmipp_image.h"
#include "core/xmipp_image_generic.h"

class XmippProgram;


enum PsfxrAdjust
{
    PSFXR_STD, 
    PSFXR_INT, 
    PSFXR_ZPAD 
} ;

// PSF Generation algorithm
/* ANALITIC_ZP is based on  O. Mendoza-Yero et als."PSF analysis of nanometric Fresnel
 * zone plates," EOS Topical Meeting on Diffractive Optics 2010,
 * ISBN 978-3-00-024193-2, 14th-18th February
 * 2010, Koli, Finland. (contact email:omendoza@uji.es)
 */
enum PsfType
{
    IDEAL_FRESNEL_LENS,
    ANALYTIC_ZP
};


class XRayPSF
{
public:

    // Operation modes
    typedef enum
    {
        GENERATE_PSF,
        PSF_FROM_FILE
    } operMode;

    operMode mode;

    PsfType type;

//    /// Current OTF
//    MultidimArray< std::complex<double> > OTF;
    ImageGeneric psfGen;
    Image<double>  psfVol;
    MultidimArray<double> PSF;
//    /// Axial intensity
//    MultidimArray<float> axialInt;
    double slabThr;
    std::vector<int> slabIndex;
    // Transformation Matrix when reading PSF from file
    Matrix2D<double>  T;

    MultidimArray<double> *mask; // This class should use applyOTF simultaneously from several threads

    /* RX Microscope configuration */
    double Rlens;
    double Zo;
//    double Z;
    double Zi;
    double DoF;

    /* Digital Parameters */
    size_t Nox;
    size_t Noy;
    size_t Noz;
    /* Maximum pixel size in image plane (Minimum resolution condition).
     The same for both axis x-y, due to the symmetry of the lens aperture */
    double dxiMax;
    double dxl;
    double dyl;
    double deltaZMaxX;
    double deltaZMaxY;
    double deltaZMinX;
    double deltaZMinY;

    PsfxrAdjust AdjustType;
    double pupileSizeMin;

//    // Fourier Transformer to generate OTF, declared in class to avoid copy output
//    FourierTransformer ftGenOTF;

public:
    double lambda;

    /* RX Microscope configuration */
    double Flens;
    double Nzp;
    double deltaR;
    double Ms;
    double DeltaZo;


    /* Digital Parameters */
    double dxo;
    double dxi;
    double dzo;
    size_t Nix;
    size_t Niy;

    double dxoPSF;
    double dzoPSF;

    int verbose;

    // Number of threads
    int nThr;

public:
    XRayPSF();

    XRayPSF(const XRayPSF&)=delete; // Removal of copy constructor
    XRayPSF(const XRayPSF&&)=delete; // Removal of move constructor
    XRayPSF& operator = (const XRayPSF&)=delete; // Removal of copy assignment
    XRayPSF& operator = (const XRayPSF&&)=delete; // Removal of move assignment

    /* Destructor
     */
    ~XRayPSF();

    /* Initialization of parameters
     */
    void init();

    void clear();

    /* Definition of params to be read from command line
     */
    static void defineParams(XmippProgram * program);

    /* Read of params from command line
     */
    void readParams(XmippProgram * program);

    void read(const FileName &fn, bool readVolume = true);

    void write(const FileName &fn);

    void show();

    friend std::ostream & operator <<(std::ostream &out, const XRayPSF &psf);

    void setFocalShift(double zShift);

    void calculateParams(double _dxo, double _dzo = -1, double threshold = 0.);

    void reducePSF2Slabs(double threshold);

    void applyOTF(MultidimArray<double> &Im, const double sliceOffset) const;

    void generateOTF(MultidimArray<std::complex<double> > &OTF, double Zpos) const;

    void generatePSF();

    void adjustParam();
    void adjustParam(MultidimArray<double> &Vol);

protected:
    void generatePSFIdealLens(MultidimArray<double> &PSFi, double Zpos) const;
};

void lensPD(MultidimArray<std::complex<double> > &Im, double Flens, double lambda, double dx, double dy);

#endif