D:/Programmierung/C/TRTK/include/TRTK/FitCircleInOrigin.hpp

Go to the documentation of this file.

/*
    Estimates the parameters of a circle with center in the origin from a set
    of 2D points lying on the circle.

    Copyright (C) 2010 - 2014 Fabian Killus, Christoph Haenisch

    Chair of Medical Engineering (mediTEC)
    RWTH Aachen University
    Pauwelsstr. 20
    52074 Aachen
    Germany

    Version 0.2.0 (2012-03-20)
*/

#ifndef FIT_CIRCLE_IN_ORIGIN_HPP_9483758184
#define FIT_CIRCLE_IN_ORIGIN_HPP_9483758184


#include <cmath>
#include <Eigen/Core>
#include <Eigen/Dense>
#include <Eigen/StdVector>
#include <Eigen/SVD>
#include <vector>

#include "ErrorObj.hpp"
#include "Coordinate.hpp"
#include "Fit2D.hpp"


namespace TRTK
{


template <class T>
class FitCircleInOrigin : public Fit2D<T>
{
private:
    typedef Fit2D<T> super;

public:
    EIGEN_MAKE_ALIGNED_OPERATOR_NEW

    typedef T value_type;
    typedef typename super::Vector2T Vector2T;
    typedef typename super::Vector3T Vector3T;

    FitCircleInOrigin();
    FitCircleInOrigin(const std::vector<Coordinate<T> > & points);
    FitCircleInOrigin(const std::vector<Vector2T, Eigen::aligned_allocator<Vector2T> > & points);
    FitCircleInOrigin(const std::vector<Vector3T> & points);

    virtual ~FitCircleInOrigin();

    void compute();

    unsigned getNumberPointsRequired() const;

    const Coordinate<T> & getCenterPoint() const;
    T getDistanceTo(const Coordinate<T> & point) const;
    T getRadius() const;
    T getRMS() const;

    using super::NOT_ENOUGH_POINTS;
    using super::UNKNOWN_ERROR;
    using super::WRONG_POINT_SIZE;

private:
    Coordinate<T> m_center_point;
    T m_radius;
};


template <class T>
FitCircleInOrigin<T>::FitCircleInOrigin() :
    m_center_point(0, 0),
    m_radius(0)
{
}


template <class T>
FitCircleInOrigin<T>::FitCircleInOrigin(const std::vector<Coordinate<T> > & points) :
    m_center_point(0, 0),
    m_radius(0)
{
    super::setPoints(points);
}


template <class T>
FitCircleInOrigin<T>::FitCircleInOrigin(const std::vector<Vector2T, Eigen::aligned_allocator<Vector2T> > & points) :
    m_center_point(0, 0),
    m_radius(0)
{
    super::setPoints(points);
}


template <class T>
FitCircleInOrigin<T>::FitCircleInOrigin(const std::vector<Vector3T> & points) :
    m_center_point(0, 0),
    m_radius(0)
{
    super::setPoints(points);
}


template <class T>
FitCircleInOrigin<T>::~FitCircleInOrigin()
{
}


template <class T>
void FitCircleInOrigin<T>::compute()
{
    /*

    Explanation of the algorithm:

    A point (x, y) on the circle with radius R fullfills the following
    equation:

    R = sqrt(x^2 + y^2) = |(x, y)| = norm((x, y))

    Because there are possibly more than just one known point on the circle,
    regard the mean value as the best fit for R.

    */

    if (super::m_points.cols() == 0)
    {
        ErrorObj error;
        error.setClassName("FitCircleInOrigin<T>");
        error.setFunctionName("compute");
        error.setErrorMessage("Not enough points to fit the circle.");
        error.setErrorCode(NOT_ENOUGH_POINTS);
        throw error;
    }


    // Calculate radius of the circle.

    m_radius = super::m_points.colwise().norm().mean();
}


template <class T>
const Coordinate<T> & FitCircleInOrigin<T>::getCenterPoint() const
{
    return m_center_point;
}


template <class T>
T FitCircleInOrigin<T>::getDistanceTo(const Coordinate<T> & point) const
{
    assert(point.size() == 2);

    using std::abs;
    return abs(point.norm() - m_radius);
}


template <class T>
inline unsigned FitCircleInOrigin<T>::getNumberPointsRequired() const
{
    return 1;
}


template <class T>
T FitCircleInOrigin<T>::getRadius() const
{
    return m_radius;
}


template <class T>
T FitCircleInOrigin<T>::getRMS() const
{
    using std::sqrt;

    const int number_points = super::m_points.cols();

    T sum_of_squared_errors = 0.0;

    for (int i = 0; i < number_points; ++i)
    {
        T error = m_radius - super::m_points.col(i).norm();
        sum_of_squared_errors +=  error * error;
    }

    return sqrt(sum_of_squared_errors / number_points);
}


} // namespace TRTK


#endif // FIT_CIRCLE_IN_ORIGIN_HPP_9483758184