Alignment::ShiftCorrEstimator< T > Class Template Reference

#include <shift_corr_estimator.h>

Inheritance diagram for Alignment::ShiftCorrEstimator< T >:

Collaboration diagram for Alignment::ShiftCorrEstimator< T >:

Public Member Functions
	ShiftCorrEstimator ()
virtual	~ShiftCorrEstimator ()
void	release () override
void	init2D (const std::vector< HW *> &hw, AlignType type, const FFTSettings< T > &dims, size_t maxShift, bool includingBatchFT, bool includingSingleFT, bool allowDataOverwrite) override
void	load2DReferenceOneToN (const std::complex< T > *ref) override
void	load2DReferenceOneToN (const T *ref) override
void	computeShift2DOneToN (T *others) override
void	computeCorrelations2DOneToN (std::complex< T > *inOut, bool center) override
void	computeCorrelations2DOneToN (const HW &hw, std::complex< T > *inOut, const std::complex< T > *ref, const Dimensions &dims, bool center) override
HW &	getHW () const override
template<bool CENTER>
void	sComputeCorrelations2DOneToN (const HW &hw, std::complex< T > *__restrict inOut, const std::complex< T > *__restrict ref, const Dimensions &__restrict dims)
Public Member Functions inherited from Alignment::AShiftCorrEstimator< T >
	AShiftCorrEstimator ()
	AShiftCorrEstimator (const AShiftCorrEstimator &)=delete
	AShiftCorrEstimator (const AShiftCorrEstimator &&)=delete
virtual	~AShiftCorrEstimator ()
AShiftCorrEstimator &	operator= (const AShiftCorrEstimator &)=delete
AShiftCorrEstimator &	operator= (const AShiftCorrEstimator &&)=delete
Public Member Functions inherited from Alignment::AShiftEstimator< T >
	AShiftEstimator ()
	AShiftEstimator (const AShiftEstimator &)=delete
	AShiftEstimator (const AShiftEstimator &&)=delete
virtual	~AShiftEstimator ()
AShiftEstimator &	operator= (const AShiftEstimator &)=delete
AShiftEstimator &	operator= (const AShiftEstimator &&)=delete
std::vector< Point2D< float > >	getShifts2D ()
constexpr bool	isInitialized () const
constexpr Dimensions	getDimensions () const
constexpr AlignType	getAlignType () const

Static Public Member Functions
static std::vector< Point2D< float > >	computeShifts2DOneToN (const CPU &cpu, std::complex< T > *othersF, T *othersS, std::complex< T > *ref, const FFTSettings< T > &settings, void *plan, size_t maxShift)
static void	sComputeCorrelations2DOneToN (const HW &hw, std::complex< T > *inOut, const std::complex< T > *ref, const Dimensions &dims, bool center)
template<bool CENTER>
static void	sComputeCorrelations2DOneToN (const HW &hw, std::complex< T > *inOut, const std::complex< T > *ref, const Dimensions &dims)

Additional Inherited Members
Protected Member Functions inherited from Alignment::AShiftCorrEstimator< T >
virtual void	init2D (AlignType type, const FFTSettings< T > &dims, size_t maxShift, bool includingBatchFT, bool includingSingleFT, bool allowDataOverwrite)
void	init2D (const std::vector< HW *> &hw, AlignType type, const Dimensions &dims, size_t batch, size_t maxShift)
Protected Member Functions inherited from Alignment::AShiftEstimator< T >
virtual void	init2D (AlignType type, const Dimensions &dims, size_t batch, size_t maxShift)
Protected Attributes inherited from Alignment::AShiftCorrEstimator< T >
FFTSettings< T > *	m_settingsInv
size_t	m_centerSize
bool	m_includingBatchFT
bool	m_includingSingleFT
bool	m_is_ref_FD_loaded
bool	m_allowDataOverwrite
Protected Attributes inherited from Alignment::AShiftEstimator< T >
AlignType	m_type
const Dimensions *	m_dims
size_t	m_batch
size_t	m_maxShift
std::vector< Point2D< float > >	m_shifts2D
bool	m_is_ref_loaded
bool	m_is_shift_computed
bool	m_isInit

Detailed Description

template<typename T>
class Alignment::ShiftCorrEstimator< T >

Definition at line 42 of file shift_corr_estimator.h.

Constructor & Destructor Documentation

ShiftCorrEstimator()

template<typename T>

Alignment::ShiftCorrEstimator< T >::ShiftCorrEstimator ( )

inline

Definition at line 44 of file shift_corr_estimator.h.

                         {
        setDefault();
    }

~ShiftCorrEstimator()

template<typename T>

virtual Alignment::ShiftCorrEstimator< T >::~ShiftCorrEstimator ( )

inlinevirtual

Definition at line 48 of file shift_corr_estimator.h.

                                  {
        release();
    }

Member Function Documentation

computeCorrelations2DOneToN() [1/2]

template<typename T >

void Alignment::ShiftCorrEstimator< T >::computeCorrelations2DOneToN ( std::complex< T > *  inOut, bool  center  )

overridevirtual

Implements Alignment::AShiftCorrEstimator< T >.

Definition at line 141 of file shift_corr_estimator.cpp.

                                           {
    bool isReady = (this->m_isInit && (AlignType::OneToN == this->m_type) && this->m_is_ref_FD_loaded);

    if ( ! isReady) {
        REPORT_ERROR(ERR_LOGIC_ERROR, "Not ready to execute. Call init() before");
    }

    sComputeCorrelations2DOneToN(
        *m_cpu,
        inOut, m_single_FD,
        this->m_settingsInv->fDim(),
        center);
}

computeCorrelations2DOneToN() [2/2]

template<typename T >

void Alignment::ShiftCorrEstimator< T >::computeCorrelations2DOneToN ( const HW &  hw, std::complex< T > *  inOut, const std::complex< T > *  ref, const Dimensions &  dims, bool  center  )

overridevirtual

Implements Alignment::AShiftCorrEstimator< T >.

Definition at line 157 of file shift_corr_estimator.cpp.

                     {
    const CPU *cpu;
    try {
        cpu = &dynamic_cast<const CPU&>(hw);
    } catch (std::bad_cast&) {
        REPORT_ERROR(ERR_ARG_INCORRECT, "Instance of CPU expected");
    }
    return sComputeCorrelations2DOneToN(*cpu, inOut, ref, dims, center);
}

computeShift2DOneToN()

template<typename T >

void Alignment::ShiftCorrEstimator< T >::computeShift2DOneToN ( T *  others )

overridevirtual

Implements Alignment::AShiftEstimator< T >.

Definition at line 212 of file shift_corr_estimator.cpp.

                   {
    bool isReady = (this->m_isInit && (AlignType::OneToN == this->m_type)
            && this->m_is_ref_FD_loaded && this->m_includingBatchFT);

    if ( ! isReady) {
        REPORT_ERROR(ERR_LOGIC_ERROR, "Not ready to execute. Call init() before");
    }

    // reserve enough space for shifts
    this->m_shifts2D.reserve(this->m_settingsInv->fDim().n());
    // process signals
    for (size_t offset = 0; offset < this->m_settingsInv->fDim().n(); offset += this->m_settingsInv->batch()) {
        // how many signals to process
        size_t toProcess = std::min(this->m_settingsInv->batch(), this->m_settingsInv->fDim().n() - offset);

        T *batchStart;
        if (toProcess == this->m_settingsInv->batch()) {
            // we process whole batch, so we don't need to copy data
            batchStart = others + offset * this->m_settingsInv->sDim().xyPadded();
        } else {
            assert(this->m_settingsInv->batch() <= this->m_settingsInv->sDim().n());
            // less than 'batch' signals are left, so we need to process last 'batch'
            // signals to avoid invalid memory access
            batchStart = others
                    + (this->m_settingsInv->sDim().n() - this->m_settingsInv->batch())
                    * this->m_settingsInv->sDim().xy();
        }

        // perform FT
        FFTwT<T>::fft(m_batchToFD, batchStart, m_batch_FD);

        // compute shifts
        auto shifts = computeShifts2DOneToN(
                *m_cpu,
                m_batch_FD,
                m_batch_SD,
                m_single_FD,
                this->m_settingsInv->createBatch(), // always process whole batch, as we do it to avoid copying memory
                m_batchToSD,
                this->m_maxShift);

        // append shifts to existing results
        this->m_shifts2D.insert(this->m_shifts2D.end(),
                // in case of the last iteration, take only the shifts we actually need
                shifts.begin() + this->m_settingsInv->batch() - toProcess,
                shifts.end());
    }

    // update state
    this->m_is_shift_computed = true;
}

computeShifts2DOneToN()

template<typename T >

std::vector< Point2D< float > > Alignment::ShiftCorrEstimator< T >::computeShifts2DOneToN ( const CPU &  cpu, std::complex< T > *  othersF, T *  othersS, std::complex< T > *  ref, const FFTSettings< T > &  settings, void *  plan, size_t  maxShift  )

static

Definition at line 266 of file shift_corr_estimator.cpp.

                         {
    // we need even input in order to perform the shift (in FD, while correlating) properly
    assert(0 == (settings.sDim().x() % 2));
    assert(0 == (settings.sDim().y() % 2));
    assert(1 == settings.sDim().zPadded());

    // correlate signals and shift FT so that it will be centered after IFT
    sComputeCorrelations2DOneToN(cpu,
            othersF, ref,
            settings.fDim(), true);

    // perform IFT
    FFTwT<T>::ifft(plan, othersF, othersS);

    // compute shifts
    auto maxIndices = std::vector<float>(settings.sDim().n(), -1.f);
    ExtremaFinder::SingleExtremaFinder<T>::sFindMax2DAroundCenter(cpu, settings.sDim(),
            othersS, maxIndices.data(), nullptr, maxShift);
    // convert absolute indices to 2D position
    // FIXME DS extract this to some indexing utils or sth
    int cX = settings.sDim().x() / 2;
    int cY = settings.sDim().y() / 2;
    auto result = std::vector<Point2D<float>>();
    const int x = settings.sDim().x();
    for (auto i : maxIndices) {
        result.emplace_back(((int)i % x) - cX, ((int)i / x) - cY);
    }
    return result;
}

getHW()

template<typename T>

HW& Alignment::ShiftCorrEstimator< T >::getHW ( ) const

inlineoverridevirtual

Implements Alignment::AShiftEstimator< T >.

Definition at line 102 of file shift_corr_estimator.h.

                               {
        return *m_cpu;
    }

init2D()

template<typename T >

void Alignment::ShiftCorrEstimator< T >::init2D ( const std::vector< HW *> &  hw, AlignType  type, const FFTSettings< T > &  dims, size_t  maxShift, bool  includingBatchFT, bool  includingSingleFT, bool  allowDataOverwrite  )

overridevirtual

Implements Alignment::AShiftCorrEstimator< T >.

Definition at line 33 of file shift_corr_estimator.cpp.

                                 {
    if (1 != hw.size()) {
        REPORT_ERROR(ERR_ARG_INCORRECT, "A single CPU thread expected");
    }
    release();
    try {
        m_cpu = dynamic_cast<CPU*>(hw.at(0));
    } catch (std::bad_cast&) {
        REPORT_ERROR(ERR_ARG_INCORRECT, "Instance of CPU expected");
    }

    AShiftCorrEstimator<T>::init2D(type, settings, maxShift,
        includingBatchFT, includingSingleFT, allowDataOverwrite);

    this->m_isInit = true;
}

load2DReferenceOneToN() [1/2]

template<typename T >

void Alignment::ShiftCorrEstimator< T >::load2DReferenceOneToN ( const std::complex< T > *  ref )

overridevirtual

Implements Alignment::AShiftCorrEstimator< T >.

Definition at line 125 of file shift_corr_estimator.cpp.

                                                                          {
    auto isReady = (this->m_isInit && (AlignType::OneToN == this->m_type));
    if ( ! isReady) {
        REPORT_ERROR(ERR_LOGIC_ERROR, "Not ready to load a reference signal");
    }

    // simply remember the pointer. Expect that nobody will change it meanwhile
    // We won't change it, but since generally speaking, we do change this pointer
    // remove the const
    m_single_FD = const_cast<std::complex<T>*>(ref);

    // update state
    this->m_is_ref_FD_loaded = true;
}

load2DReferenceOneToN() [2/2]

template<typename T >

void Alignment::ShiftCorrEstimator< T >::load2DReferenceOneToN ( const T *  ref )

overridevirtual

Implements Alignment::AShiftEstimator< T >.

Definition at line 54 of file shift_corr_estimator.cpp.

                                                              {
    auto isReady = (this->m_isInit && (AlignType::OneToN == this->m_type) && this->m_includingSingleFT);
    if ( ! isReady) {
        REPORT_ERROR(ERR_LOGIC_ERROR, "Not ready to load a reference signal");
    }

    // perform FT
    FFTwT<T>::fft(m_singleToFD, ref, m_single_FD);

    // update state
    this->m_is_ref_FD_loaded = true;
}

release()

template<typename T >

void Alignment::ShiftCorrEstimator< T >::release ( )

overridevirtual

Reimplemented from Alignment::AShiftCorrEstimator< T >.

Definition at line 86 of file shift_corr_estimator.cpp.

                                    {
    // host memory
    if (this->m_includingSingleFT) {
        delete[] m_single_FD;
    }
    if (this->m_includingBatchFT) {
        delete[] m_batch_FD;
        delete[] m_batch_SD;
    }

    // FT plans
    FFTwT<T>::release(m_singleToFD);
    FFTwT<T>::release(m_batchToFD);
    FFTwT<T>::release(m_batchToSD);

    AShiftCorrEstimator<T>::release();

    ShiftCorrEstimator<T>::setDefault();
}

sComputeCorrelations2DOneToN() [1/3]

template<typename T>

static void Alignment::ShiftCorrEstimator< T >::sComputeCorrelations2DOneToN ( const HW &  hw, std::complex< T > *  inOut, const std::complex< T > *  ref, const Dimensions &  dims, bool  center  )

inlinestatic

Definition at line 82 of file shift_corr_estimator.h.

                     {
        if (center) {
            sComputeCorrelations2DOneToN<true>(hw, inOut, ref, dims);
        } else {
            sComputeCorrelations2DOneToN<false>(hw, inOut, ref, dims);
        }
    }

sComputeCorrelations2DOneToN() [2/3]

template<typename T>

template<bool CENTER>

static void Alignment::ShiftCorrEstimator< T >::sComputeCorrelations2DOneToN ( const HW &  hw, std::complex< T > *  inOut, const std::complex< T > *  ref, const Dimensions &  dims  )

static

sComputeCorrelations2DOneToN() [3/3]

template<typename T>

template<bool CENTER>

void Alignment::ShiftCorrEstimator< T >::sComputeCorrelations2DOneToN	(	const HW &	hw,
		std::complex< T > *__restrict	inOut,
		const std::complex< T > *__restrict	ref,
		const Dimensions &__restrict	dims
	)

Definition at line 174 of file shift_corr_estimator.cpp.

                                           {
    if (CENTER) {
        // we cannot assert xDim, as we don't know if the spatial size was even
        assert(0 == (dims.y() % 2));
    }
    assert(0 < dims.x());
    assert(0 < dims.y());
    assert(1 == dims.z());
    assert(0 < dims.n());

    const size_t maxN = dims.n();
    const size_t maxY = dims.y();
    const size_t maxX = dims.x();

    for (size_t n = 0; n < maxN; ++n) {
        size_t offsetN = n * dims.xyzPadded();
        for (size_t y = 0; y < maxY; ++y) {
            int centerCoeff = (0 == y % 2) ? 1 : -1;
            size_t offsetY = y * dims.xPadded();
            for (size_t x = 0; x < maxX; ++x) {
                size_t destIndex = offsetN + offsetY + x;
                auto r = ref[offsetY + x];
                auto o = r * std::conj(inOut[destIndex]);
                inOut[destIndex] = o;
                if (CENTER) {
                    inOut[destIndex] *= centerCoeff;
                    centerCoeff *= -1;
                }
            }
        }
    }
}

---

The documentation for this class was generated from the following files:

• xmipp/libraries/reconstruction/shift_corr_estimator.h
• xmipp/libraries/reconstruction/shift_corr_estimator.cpp