ExtremaFinder::SingleExtremaFinder< T > Class Template Reference

#include <single_extrema_finder.h>

Inheritance diagram for ExtremaFinder::SingleExtremaFinder< T >:

Collaboration diagram for ExtremaFinder::SingleExtremaFinder< T >:

Public Member Functions
	SingleExtremaFinder ()
virtual	~SingleExtremaFinder ()
	SingleExtremaFinder (SingleExtremaFinder &o)=delete
SingleExtremaFinder &	operator= (const SingleExtremaFinder &other)=delete
SingleExtremaFinder const &	operator= (SingleExtremaFinder &&o)=delete
	SingleExtremaFinder (SingleExtremaFinder &&o)
template<typename KERNEL >
void	findBasic (const T *__restrict__ data, const KERNEL &k)
Public Member Functions inherited from ExtremaFinder::AExtremaFinder< T >
	AExtremaFinder ()
virtual	~AExtremaFinder ()
void	init (const ExtremaFinderSettings &settings, bool reuse)
void	find (const T *data)
HW &	getHW () const
const ExtremaFinderSettings &	getSettings () const
const std::vector< T > &	getValues () const
const std::vector< float > &	getPositions () const

Static Public Member Functions
static void	sFindMax (const CPU &cpu, const Dimensions &dims, const T *data, float *positions, T *values)
static void	sFindLowest (const CPU &cpu, const Dimensions &dims, const T *data, float *positions, T *values)
template<typename C >
static void	sFindUniversal2DAroundCenter (const C &comp, T startVal, const CPU &cpu, const Dimensions &dims, const T *data, float *positions, T *values, size_t maxDist)
static void	sFindMax2DAroundCenter (const CPU &cpu, const Dimensions &dims, const T *data, float *positions, T *values, size_t maxDist)
static void	sFindLowest2DAroundCenter (const CPU &cpu, const Dimensions &dims, const T *data, float *positions, T *values, size_t maxDist)

Additional Inherited Members
Protected Member Functions inherited from ExtremaFinder::AExtremaFinder< T >
std::vector< T > &	getValues ()
std::vector< float > &	getPositions ()
constexpr bool	isInitialized () const

Detailed Description

template<typename T>
class ExtremaFinder::SingleExtremaFinder< T >

Definition at line 40 of file single_extrema_finder.h.

Constructor & Destructor Documentation

SingleExtremaFinder() [1/3]

template<typename T>

ExtremaFinder::SingleExtremaFinder< T >::SingleExtremaFinder ( )

inline

Definition at line 42 of file single_extrema_finder.h.

                          {
        setDefault();
    }

~SingleExtremaFinder()

template<typename T>

virtual ExtremaFinder::SingleExtremaFinder< T >::~SingleExtremaFinder ( )

inlinevirtual

Definition at line 46 of file single_extrema_finder.h.

                                   {
        release();
    }

SingleExtremaFinder() [2/3]

template<typename T>

ExtremaFinder::SingleExtremaFinder< T >::SingleExtremaFinder ( SingleExtremaFinder< T > &  o )

delete

SingleExtremaFinder() [3/3]

template<typename T>

ExtremaFinder::SingleExtremaFinder< T >::SingleExtremaFinder ( SingleExtremaFinder< T > &&  o )

inline

Definition at line 53 of file single_extrema_finder.h.

                                                 {
        m_cpu = o.m_cpu;
        // clean original
        o.setDefault();
    }

Member Function Documentation

findBasic()

template<typename T>

template<typename KERNEL >

void ExtremaFinder::SingleExtremaFinder< T >::findBasic	(	const T *__restrict__	data,
		const KERNEL &	k
	)

Definition at line 155 of file single_extrema_finder.cpp.

                                                                                  {
    bool isReady = this->isInitialized();
    if ( ! isReady) {
        REPORT_ERROR(ERR_LOGIC_ERROR, "Not ready to execute. Call init() first");
    }
    k(data);
}

operator=() [1/2]

template<typename T>

SingleExtremaFinder& ExtremaFinder::SingleExtremaFinder< T >::operator= ( const SingleExtremaFinder< T > &  other )

delete

operator=() [2/2]

template<typename T>

SingleExtremaFinder const& ExtremaFinder::SingleExtremaFinder< T >::operator= ( SingleExtremaFinder< T > &&  o )

delete

sFindLowest()

template<typename T>

void ExtremaFinder::SingleExtremaFinder< T >::sFindLowest ( const CPU &  cpu, const Dimensions &  dims, const T *  data, float *  positions, T *  values  )

static

Definition at line 199 of file single_extrema_finder.cpp.

                            {
    sFindUniversalChecks(dims, data, positions, values);

    if (dims.isPadded()) {
        REPORT_ERROR(ERR_NOT_IMPLEMENTED, "Not implemented");
    } else {
        // locate minima
        for (size_t n = 0; n < dims.n(); ++n) {
            auto start = data + (n * dims.sizeSingle());
            auto max = std::min_element(start, start + dims.sizeSingle());
            auto pos = std::distance(start, max);
            values[n] = *max;
            positions[n] = pos;
        }
    }
}

sFindLowest2DAroundCenter()

template<typename T>

void ExtremaFinder::SingleExtremaFinder< T >::sFindLowest2DAroundCenter ( const CPU &  cpu, const Dimensions &  dims, const T *  data, float *  positions, T *  values, size_t  maxDist  )

static

Definition at line 234 of file single_extrema_finder.cpp.

                        {
    sFindUniversal2DAroundCenter(std::less<T>(),
            std::numeric_limits<T>::max(),
            cpu, dims, data, positions, values, maxDist);
}

sFindMax()

template<typename T>

void ExtremaFinder::SingleExtremaFinder< T >::sFindMax ( const CPU &  cpu, const Dimensions &  dims, const T *  data, float *  positions, T *  values  )

static

Definition at line 177 of file single_extrema_finder.cpp.

                            {
    sFindUniversalChecks(dims, data, positions, values);

    if (dims.isPadded()) {
        REPORT_ERROR(ERR_NOT_IMPLEMENTED, "Not implemented");
    } else {
        // locate max
        for (size_t n = 0; n < dims.n(); ++n) {
            auto start = data + (n * dims.sizeSingle());
            auto max = std::max_element(start, start + dims.sizeSingle());
            auto pos = std::distance(start, max);
            values[n] = *max;
            positions[n] = pos;
        }
    }
}

sFindMax2DAroundCenter()

template<typename T>

void ExtremaFinder::SingleExtremaFinder< T >::sFindMax2DAroundCenter ( const CPU &  cpu, const Dimensions &  dims, const T *  data, float *  positions, T *  values, size_t  maxDist  )

static

Definition at line 221 of file single_extrema_finder.cpp.

                        {
    sFindUniversal2DAroundCenter(std::greater<T>(),
            std::numeric_limits<T>::lowest(),
            cpu, dims, data, positions, values, maxDist);
}

sFindUniversal2DAroundCenter()

template<typename T >

template<typename C >

void ExtremaFinder::SingleExtremaFinder< T >::sFindUniversal2DAroundCenter ( const C &  comp, T  startVal, const CPU &  cpu, const Dimensions &  dims, const T *  data, float *  positions, T *  values, size_t  maxDist  )

static

Definition at line 248 of file single_extrema_finder.cpp.

                        {
    // check input
    assert(dims.is2D());
    assert( ! dims.isPadded());
    assert(dims.sizeSingle() > 0);
    assert(dims.n() > 0);
    assert(nullptr != data);
    assert((nullptr != positions) || (nullptr != values));
    assert(0 < maxDist);
    const size_t xHalf = dims.x() / 2;
    const size_t yHalf = dims.y() / 2;
    assert((2 * xHalf) > maxDist);
    assert((2 * yHalf) > maxDist);

    const auto min = std::pair<size_t, size_t>(
        std::max((size_t)0, xHalf - maxDist),
        std::max((size_t)0, yHalf - maxDist)
    );

    const auto max = std::pair<size_t, size_t>(
        std::min(dims.x() - 1, xHalf + maxDist),
        std::min(dims.y() - 1, yHalf + maxDist)
    );

    const size_t maxDistSq = maxDist * maxDist;
    for (size_t n = 0; n < dims.n(); ++n) {
        size_t offsetN = n * dims.xyzPadded();
        T extrema = startVal;
        float pos = -1;
        // iterate through the center
        for (size_t y = min.second; y <= max.second; ++y) {
            size_t offsetY = y * dims.x();
            int logicY = (int)y - yHalf;
            size_t ySq = logicY * logicY;
            for (size_t x = min.first; x <= max.first; ++x) {
                int logicX = (int)x - xHalf;
                // continue if the Euclidean distance is too far
                if ((ySq + (logicX * logicX)) > maxDistSq) continue;
                // get current value and update, if necessary
                T tmp = data[offsetN + offsetY + x];
                if (comp(tmp, extrema)) {
                    extrema = tmp;
                    pos = offsetY + x;
                }
            }
        }
        // store results
        if (nullptr != positions) {
            positions[n] = pos;
        }
        if (nullptr != values) {
            values[n] = extrema;
        }
    }
}

---

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

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