Point.h

Go to the documentation of this file.

/*
 * Copyright (C) 2012 by
 *   MetraLabs GmbH (MLAB), GERMANY
 * and
 *   Neuroinformatics and Cognitive Robotics Labs (NICR) at TU Ilmenau, GERMANY
 * All rights reserved.
 *
 * Contact: info@mira-project.org
 *
 * Commercial Usage:
 *   Licensees holding valid commercial licenses may use this file in
 *   accordance with the commercial license agreement provided with the
 *   software or, alternatively, in accordance with the terms contained in
 *   a written agreement between you and MLAB or NICR.
 *
 * GNU General Public License Usage:
 *   Alternatively, this file may be used under the terms of the GNU
 *   General Public License version 3.0 as published by the Free Software
 *   Foundation and appearing in the file LICENSE.GPL3 included in the
 *   packaging of this file. Please review the following information to
 *   ensure the GNU General Public License version 3.0 requirements will be
 *   met: http://www.gnu.org/copyleft/gpl.html.
 *   Alternatively you may (at your option) use any later version of the GNU
 *   General Public License if such license has been publicly approved by
 *   MLAB and NICR (or its successors, if any).
 *
 * IN NO EVENT SHALL "MLAB" OR "NICR" BE LIABLE TO ANY PARTY FOR DIRECT,
 * INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF
 * THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF "MLAB" OR
 * "NICR" HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * "MLAB" AND "NICR" SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING,
 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
 * ON AN "AS IS" BASIS, AND "MLAB" AND "NICR" HAVE NO OBLIGATION TO
 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS OR MODIFICATIONS.
 */

#ifndef _MIRA_POINT_H_
#define _MIRA_POINT_H_

#if CV_MAJOR_VERSION >= 3
# include <opencv2/core/types.hpp>
#else
# include <opencv2/core/core.hpp>
#endif

#ifndef Q_MOC_RUN
#include <boost/geometry/core/cs.hpp>
#include <boost/geometry/geometries/point.hpp>
#endif

#include <utils/PParam.h>
#include <math/Eigen.h>

#include <utils/IsCheapToCopy.h>

namespace mira {


template <typename T, int D, typename Derived>
class PointBase : public Eigen::Matrix<T,D,1>
{
    typedef Eigen::Matrix<T,D,1> Base;

public:
    typedef T Type;
    enum { Dim = D};

public:
    PointBase() : Base(Eigen::Matrix<T,D,1>::Zero()) {}

    PointBase(const boost::geometry::model::point<T,D,boost::geometry::cs::cartesian>& other) {
        operator=(other);
    }

    template <typename DerivedMatrix>
    PointBase(const Eigen::MatrixBase<DerivedMatrix>& other) : Base(other) {}

    template <typename DerivedMatrix>
    Derived& operator=(const Eigen::MatrixBase<DerivedMatrix>& other) {
        Base::operator=(other);
        return *this;
    }

    Derived& operator=(const boost::geometry::model::point<T,D,boost::geometry::cs::cartesian>& other)
    {
        for(int i=0; i < D; i++) // compiler will unroll loop
            (*this)[i] = other(i);
        return *this;
    }

    operator boost::geometry::model::point<T,D,boost::geometry::cs::cartesian>() const
    {
        boost::geometry::model::point<T,D,boost::geometry::cs::cartesian> r;
        for(int i=0; i < D; i++) // compiler will unroll loop
            r(i) = (*this)[i];
        return r;
    }
};


template <typename T, int D>
class Point : public PointBase<T,D, Point<T,D> >
{
    typedef PointBase<T,D, Point<T,D> > Base;

public:
    Point() {}

    template <typename DerivedMatrix>
    Point(const Eigen::MatrixBase<DerivedMatrix>& other) : Base(other) {}

    Point(const boost::geometry::model::point<T,D,boost::geometry::cs::cartesian>& other) {
        operator=(other);
    }
};


template <typename T, int D, typename SerializerTag>
class IsTransparentSerializable<Point<T,D>,SerializerTag> : public std::true_type {};


template <typename T>
class Point<T,2> : public PointBase<T,2, Point<T,2> >
{
    typedef PointBase<T,2, Point<T,2> > Base;

public:
    Point() {}

    Point(T x, T y)
    {
        (*this)[0] = x;
        (*this)[1] = y;
    }

    template <typename DerivedMatrix>
    Point(const Eigen::MatrixBase<DerivedMatrix>& other) : Base(other) {}

    Point(const boost::geometry::model::point<T,2,boost::geometry::cs::cartesian>& other) {
        operator=(other);
    }

    explicit Point<T,2>(const cv::Point_<T> & other) {
        operator=(other);
    }

    Point& operator=(const cv::Point_<T>& other) {
        (*this)[0] = other.x;
        (*this)[1] = other.y;
        return *this;
    }

    operator cv::Point_<T>() const
    {
        return cv::Point_<T>( this->x(), this->y() );
    }

    template<typename Reflector>
    void reflect(Reflector& reflector)
    {
        reflector.property("X", this->x(), "The x-coordinate");
        reflector.property("Y", this->y(), "The y-coordinate");
    }
};


template <typename T, typename SerializerTag>
class IsTransparentSerializable<Point<T,2>,SerializerTag> : public std::false_type {};


typedef Point<int,2> Point2i; 
typedef Point<float,2> Point2f; 
typedef Point<double,2> Point2d; 


template <>
class IsCheapToCopy<Point2i> : public std::true_type {};

template <>
class IsCheapToCopy<Point2f> : public std::true_type {};

template <>
class IsCheapToCopy<Point2d> : public std::true_type {};


template <typename T>
class Point<T,3> : public PointBase<T,3, Point<T,3> >
{
    typedef PointBase<T,3, Point<T,3> > Base;

public:
    Point(){}

    Point(T x, T y, T z)
    {
        (*this)[0] = x;
        (*this)[1] = y;
        (*this)[2] = z;
    }

    template <typename DerivedMatrix>
    Point(const Eigen::MatrixBase<DerivedMatrix>& other) : Base(other) {}

    Point(const boost::geometry::model::point<T,3,boost::geometry::cs::cartesian>& other) {
        operator=(other);
    }

    explicit Point(const cv::Point3_<T> & other) {
        operator=(other);
    }

    Point& operator=(const cv::Point3_<T>& other) {
        (*this)[0] = other.x;
        (*this)[1] = other.y;
        (*this)[2] = other.z;
        return *this;
    }

    operator cv::Point3_<T>() const
    {
        return cv::Point3_<T>(this->x(),this->y(),this->z());
    }

    template<typename Reflector>
    void reflect(Reflector& reflector)
    {
        reflector.property("X", this->x(), "The x-coordinate");
        reflector.property("Y", this->y(), "The y-coordinate");
        reflector.property("Z", this->z(), "The z-coordinate");
    }

};


template <typename T, typename SerializerTag>
class IsTransparentSerializable<Point<T,3>,SerializerTag> : public std::false_type {};


typedef Point<int,3> Point3i;    
typedef Point<float,3> Point3f;  
typedef Point<double,3> Point3d; 


template <>
class IsCheapToCopy<Point3i> : public std::true_type {};

template <>
class IsCheapToCopy<Point3f> : public std::true_type {};

template <>
class IsCheapToCopy<Point3d> : public std::true_type {};


} // namespace MIRA

// BOOST specialization on mira::point to accept them as geometry entity
namespace boost { namespace geometry { namespace traits {


template<typename T, int D>
struct tag<mira::Point<T, D> >
{ typedef point_tag type; };

template<typename T, int D>
struct dimension<mira::Point<T, D> > : boost::mpl::int_<D>
{};

template<typename T, int D>
struct coordinate_type<mira::Point<T, D> >
{ typedef T type; };

template<typename T, int D>
struct coordinate_system<mira::Point<T, D> >
{ typedef cs::cartesian type; };

template<typename T, int D, std::size_t Dimension>
struct access<mira::Point<T, D>, Dimension>
{
    static inline T get(mira::Point<T, D> const& p)
    {
        return p(Dimension, 0);
    }
    static inline void set(mira::Point<T, D>& p, T const& value)
    {
        p(Dimension, 0) = value;
    }
};


}}} // namespace boost { namespace geometry { namespace traits {



#endif