forward_zernike_images_priors.h

Go to the documentation of this file.

/***************************************************************************
 *
 * Authors:    Carlos Oscar Sanchez Sorzano (coss@cnb.csic.es)
 *             David Herreros Calero (dherreros@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 _PROG_FORWARD_ZERNIKE_IMAGES_PRIORS
#define _PROG_FORWARD_ZERNIKE_IMAGES_PRIORS

#include "core/xmipp_metadata_program.h"
#include "core/rerunable_program.h"
#include "core/matrix1d.h"
#include <data/blobs.h>
#include "core/xmipp_image.h"
#include "data/fourier_filter.h"
#include "data/fourier_projection.h"


class ProgForwardZernikeImagesPriors: public XmippMetadataProgram, public Rerunable
{
public:
    FileName fnVolR;
    FileName fnMaskR;
    FileName fnPriors;
    FileName fnOutDir;
    int L1, L2;
    Matrix1D<int> vL1, vN, vL2, vM;
    double maxShift;
    double maxAngularChange;
    double maxResol;
    double Ts;
    int Rmax;
    // Optimize alignment
    bool optimizeAlignment;
    //Optimize defocus
    bool optimizeDefocus;
    // Ignore CTF
    bool ignoreCTF;
    //Radius optimization
    bool optimizeRadius;
    // Phase Flipped
    bool phaseFlipped;
    // Regularization weight
    double lambda;
    // Maximum radius for the deformation
    int RmaxDef;
    // Number of images (execution mode) (single image == 1, pair == 2, or triplet == 3)
    int num_images;
    // Number alignment parameters to minimize
    int algn_params;
    // Number CTF parameters to minimize
    int ctf_params;
    Matrix1D<double> p;
    int flagEnabled;
    int image_mode;
    bool useCTF;

public:
    bool resume;
    // 2D and 3D masks in real space
    MultidimArray<int> mask2D, V_mask;
    std::vector<std::vector<double>> priors;
    // Volume size
    size_t Xdim;
    // Images Filename
    std::vector<FileName> fnImage;
    // Input image
    Image<double> V, Vdeformed;
    std::vector<Image<double>> I;
    std::vector<Image<double>> Ifiltered;
    std::vector<Image<double>> Ifilteredp;
    // Theoretical projections
    std::vector<Image<double>> P;
    // Filter
    FourierFilter filter;
    // Transformation matrix
    Matrix2D<double> A1, A2, A3;
    // Original angles
    std::vector<double> old_rot, old_tilt, old_psi, deltaRot, deltaTilt, deltaPsi;
    // Original shift
    std::vector<double> old_shiftX, old_shiftY, deltaX, deltaY;
    // Original flip
    bool old_flip;
    // CTF Check
    bool hasCTF;
    // Original defocus
    std::vector<double> old_defocusU, old_defocusV, old_defocusAngle, deltaDefocusU, deltaDefocusV, deltaDefocusAngle;
    // Current defoci
    std::vector<double> currentDefocusU, currentDefocusV, currentAngle;
    // CTF filter
    FourierFilter FilterCTF1;
    FourierFilter FilterCTF2;
    FourierFilter FilterCTF3;
    // Vector Size
    int vecSize;
    // Vector containing the linear combination coefficients for the priors
    Matrix1D<double> c_priors;
    // Deformation coefficients
    Matrix1D<double> clnm;
    //Copy of Optimizer steps
    Matrix1D<double> steps_cp;
    //Total Deformation
    double totalDeformation, prior_deformation;
    std::vector<double> prior_deformations;
    // Show optimization
    bool showOptimization;
    // Correlation
    double correlation;
    // Loop step
    int loop_step;
    // Blob
    struct blobtype blob;
    double blob_r;
    bool do_not_init;

public:
    enum class Direction { ROTATE, UNROTATE };
    
    ProgForwardZernikeImagesPriors();

    ~ProgForwardZernikeImagesPriors();

    void readParams();

    void show();

    void defineParams();

    void preProcess();

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

    void numCoefficients(int l1, int l2, int &vecSize);

    // void minimizepos(Matrix1D<double> &vectpos);
    void minimizepos(Matrix1D<double> &steps);

    void fillVectorTerms(int l1, int l2, Matrix1D<int> &vL1, Matrix1D<int> &vN, 
                         Matrix1D<int> &vL2, Matrix1D<int> &vM);

    void deformVol(MultidimArray<double> &mVD, const MultidimArray<double> &mV, double &def,
                   double rot, double tilt, double psi);

    void updateCTFImage(double defocusU, double defocusV, double angle);

    double transformImageSph(double *pc_priors);

    //AJ new
    virtual void finishProcessing();

    virtual void writeImageParameters(MDRow &row);
    //END AJ

    virtual void checkPoint();

    Matrix1D<double> weightsInterpolation3D(double x, double y, double z);
    
    void splattingAtPos(std::array<double, 3> r, double weight, MultidimArray<double> &mP, const MultidimArray<double> &mV);

    std::vector<double> string2vector(std::string const &s) const;

    void linearCombinationClnm();

    void optimalPowellOrder();

    double bspline1(double x);

protected:
    void createWorkFiles() { return Rerunable::createWorkFiles(resume, getInputMd()); }

private:
    std::vector<MDLabel> getLabelsForEmpty() override
    {
        std::vector<MDLabel> labels = getInputMd()->getActiveLabels();
        labels.push_back(MDL_SPH_DEFORMATION);
        labels.push_back(MDL_SPH_COEFFICIENTS);
        labels.push_back(MDL_COST);
        return labels;
    }
};
#endif