movie_alignment_correlation_base.h

Go to the documentation of this file.

/***************************************************************************
 *
 * Authors:    Carlos Oscar Sanchez Sorzano coss@cnb.csic.es
 *             David Strelak (davidstrelak@gmail.com)
 *
 * 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_MOVIE_ALIGNMENT_CORRELATION_BASE
#define _PROG_MOVIE_ALIGNMENT_CORRELATION_BASE

#include "data/alignment_result.h"
#include "data/local_alignment_result.h"
#include "core/xmipp_program.h"
#include "core/metadata_extension.h"
#include "core/xmipp_fftw.h"
#include "core/optional.h"
#include "eq_system_solver.h"
#include "bspline_helper.h"
#include "data/point2D.h"
#include <optional>

template<typename T>
class AProgMovieAlignmentCorrelation: public XmippProgram {
public:
    virtual void readParams();

    virtual void show();

    virtual void defineParams();

    void run();

protected:
    Dimensions getMovieSizeRaw();

    Dimensions getMovieSize();

    AlignmentResult<T> computeAlignment(
            Matrix1D<T> &bX, Matrix1D<T> &bY, Matrix2D<T> &A,
            const core::optional<size_t> &refFrame, size_t N, int verbose);

    int findReferenceImage(size_t N, const Matrix1D<T>& shiftX,
            const Matrix1D<T>& shiftY);

    void computeTotalShift(int iref, int j, const Matrix1D<T> &shiftX,
            const Matrix1D<T> &shiftY, T &totalShiftX, T &totalShiftY);

    MultidimArray<T> createLPF(T Ts, const Dimensions &dims);

    void loadFrame(const MetaData &movie, const Image<T> &dark,
            const Image<T> &igain, size_t objId,
            Image<T> &out) const;

    virtual void applyShiftsComputeAverage(const MetaData& movie,
            const Image<T>& dark, const Image<T>& igain, Image<T>& initialMic,
            size_t& Ninitial, Image<T>& averageMicrograph, size_t& N,
            const AlignmentResult<T> &globAlignment) = 0;

    virtual void applyShiftsComputeAverage(
            const MetaData& movie, const Image<T>& dark, const Image<T>& igain,
            Image<T>& initialMic, size_t& Ninitial, Image<T>& averageMicrograph,
            size_t& N, const LocalAlignmentResult<T> &alignment) = 0;

    virtual AlignmentResult<T> computeGlobalAlignment(const MetaData &movie,
            const Image<T> &dark, const Image<T> &igain) = 0;

    virtual LocalAlignmentResult<T> computeLocalAlignment(const MetaData &movie,
            const Image<T> &dark, const Image<T> &igain,
            const AlignmentResult<T> &globAlignment) = 0;

    virtual void releaseAll() = 0;

    void storeResults(const LocalAlignmentResult<T> &alignment);

    float getPixelResolution(float scaleFactor) const;

    float getScaleFactor() const;

    std::pair<size_t, size_t> getRequestedPatchSize() const {
        return {minLocalRes / Ts, minLocalRes / Ts};
    }


    auto getBinning() const {
        return binning;
    }

    bool applyBinning() const {
        return binning != 1.0;
    }

private:
    void setNoOfPatches();

    void checkSettings();
       
    void createLPF(T Ts, MultidimArray<T> &filter);

    void scaleLPF(const MultidimArray<T>& lpf, const Dimensions &dims, MultidimArray<T>& result);

    void storeGlobalShifts(const AlignmentResult<T> &alignment,
            MetaData &movie);

    void loadDarkCorrection(Image<T>& dark);

    void loadGainCorrection(Image<T>& igain);

    void readMovie(MetaData& movie);

    void storeResults(Image<T>& initialMic, size_t Ninitial,
            Image<T>& averageMicrograph, size_t N, const MetaData& movie,
            int bestIref);

    void correctLoopIndices(const MetaData& movie);

    void printGlobalShift(const AlignmentResult<T> &globAlignment);

    float getTsPrime() const;

    float getC() const;

protected:
    int nfirst, nlast;
    float maxShift;
    FileName fnAligned;
    FileName fnAvg;
    int nfirstSum, nlastSum;
    FileName fnInitialAvg;
    std::pair<size_t, size_t> localAlignPatches;
    Dimensions localAlignmentControlPoints = Dimensions(0);
    static constexpr int solverIterations = 2;

private:
    bool skipLocalAlignment;
    FileName fnOut;
    FileName fnMovie;
    size_t minLocalRes;
    float maxResForCorrelation; //
    float Ts;
    FileName fnDark, fnGain;
    float binning;
    std::optional<Dimensions> movieSizeRaw;
    std::optional<Dimensions> movieSize;
};
#endif