angular_projection_matching.h

Go to the documentation of this file.

/***************************************************************************
 *
 * Authors:    Sjors Scheres            scheres@cnb.csic.es (2004)
 * Authors:    Roberto Marabini            roberto@cnb.csic.es (2012)
 *
 * 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 _angular_projection_matching_H
#define _angular_projection_matching_H

#include "core/metadata_db.h"
#include "core/multidim_array.h"
#include "core/xmipp_program.h"
#include "core/xmipp_threads.h"
#include "data/polar.h"
#include "data/sampling.h"

template<typename T>
class Image;

constexpr int MY_OUPUT_SIZE = 10;

class ProgAngularProjectionMatching;

// Thread declaration
void * threadRotationallyAlignOneImage( void * data );

// This structure is needed to pass parameters to threadRotationallyAlignOneImage
typedef struct{
    size_t thread_id;
    ProgAngularProjectionMatching *prm;
    MultidimArray<double> *img;
    size_t this_image;
    int * opt_refno;
    double * opt_psi;
    bool * opt_flip;
    double * maxcorr;
    size_t numOrientations;
} structThreadRotationallyAlignOneImage ;

class ProgAngularProjectionMatching : public XmippProgram
{

public:

    FileName fn_exp, fn_ref, fn_out, fn_ctf;
    MetaDataDb DFexp;
    MetaDataDb DFo;
    size_t dim, paddim;
    double pad;
    double max_shift;
    int Ri, Ro;
    double avail_memory;
    int max_nr_refs_in_memory;
    int max_nr_imgs_in_memory;
    int total_nr_refs;
    int counter_refs_in_memory;
    std::vector<int> pointer_allrefs2refsinmem;   //order after removing redundant
    std::vector<int> pointer_refsinmem2allrefs;   //order in memory
    std::vector <size_t> convert_refno_to_stack_position;
    std::vector<size_t> ids;
    Polar<std::complex<double> >   *fP_ref, *fP_img, *fPm_img;
    MultidimArray<double> *proj_ref;
    Polar_fftw_plans global_plans;
    double *stddev_ref, *stddev_img;
    Sampling mysampling;
    bool loop_forward_refs;
    int search5d_shift;
    int search5d_step;
    std::vector<int> search5d_xoff, search5d_yoff;
    MultidimArray<double> Mctf;
    bool phase_flipped;
    int threads;
    //Numbre of possible orientations
    int numOrientations;
    size_t nr_trans;
    barrier_t thread_barrier;

    bool do_scale;
    WriteModeMetaData do_overwrite;
    double scale_step;
    double scale_nsteps;

    int progress_bar_step;
public:

    virtual void readParams();

    virtual void defineParams();

    void show();

    void run();

    virtual void produceSideInfo();

    void rotationallyAlignOneImage(Matrix2D<double> &img, int imgno, int &opt_samplenr,
            double &opt_psi, bool &opt_flip, double &maxcorr);

    void translationallyAlignOneImage(MultidimArray<double> &img,
            const int &samplenr, const double &psi, const bool &opt_flip,
            double &opt_xoff, double &opt_yoff, double &maxcorr);

    void scaleAlignOneImage(MultidimArray<double> &img,
                const int &samplenr, const double &psi, const bool &opt_flip,
                const double &opt_xoff, const double &opt_yoff, const double &old_scale, double &opt_scale, double &maxcorr);

    void getCurrentReference(int refno, Polar_fftw_plans &local_plans);

    virtual void processAllImages();

    void processSomeImages(const std::vector<size_t> &imagesToProcess);

    void getCurrentImage(size_t imgid, Image<double> &img);

    virtual void writeOutputFiles();

    void destroyAndClean();
};              
#endif