Rect.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_RECT_H_
#define _MIRA_RECT_H_

#include <boost/geometry/algorithms/intersects.hpp>
#include <boost/geometry/algorithms/within.hpp>
#include <boost/geometry/geometries/box.hpp>

#include <geometry/Line.h>
#include <geometry/Size.h>

#include <utils/IsCheapToCopy.h>

namespace mira
{


template<typename T, int D, typename Derived>
class RectBase
{
public:
    typedef Point<T,D> PointType;
    typedef Size<T,D> SizeType;
    typedef boost::geometry::model::box<PointType> BoxType;

public:

    RectBase()
    {
        for(int d=0; d<D; ++d)  {
            minCorner[d] = 0;
            maxCorner[d] = -1;
        }
    }

    RectBase(T x, T y, T z, T width, T height, T depth) :
        minCorner(x, y, z), maxCorner(x+width, y+height, z+depth) {}

    RectBase(T x, T y, T width, T height) :
        minCorner(x, y), maxCorner(x+width, y+height) {}

    explicit RectBase(const PointType& pos, T width, T height) :
        minCorner(pos), maxCorner(pos.x()+width, pos.y()+height) {}

    explicit RectBase(const PointType& pos, T width, T height, T depth) :
        minCorner(pos), maxCorner(pos.x()+width, pos.y()+height, pos.z()+depth) {}

    explicit RectBase(const PointType& pos, const SizeType& s) :
        minCorner(pos), maxCorner(pos+s) {}

    explicit RectBase(const BoxType& box) :
        minCorner(box.min_corner()), maxCorner(box.max_corner()) {}

    explicit RectBase(const PointType& p1, const PointType& p2,
                      bool makeValid)
    {
        for(int d=0; d<D; ++d)
        {
            if(makeValid && (p1[d]>p2[d])) {
                minCorner[d]=p2[d];
                maxCorner[d]=p1[d];
            } else {
                minCorner[d]=p1[d];
                maxCorner[d]=p2[d];
            }
        }
    }


public:
    template<typename Reflector>
    void reflect(Reflector& reflector)
    {
        reflector.property("MinCorner", minCorner, "The minimum corner");
        reflector.property("MaxCorner", maxCorner, "The maximum corner");
    }

public:

    operator BoxType() const {
        return BoxType(minCorner, maxCorner);
    }


public:
    SizeType size() const {
        return SizeType(maxCorner-minCorner);
    }

public:

    template <typename OtherDerived>
    bool operator==(const RectBase<T,D, OtherDerived>& other) const {
        return minCorner == other.minCorner && maxCorner == other.maxCorner;
    }

    template <typename OtherDerived>
    bool operator!=(const RectBase<T,D, OtherDerived>& other) const {
        return !this->operator==(other);
    }


public:

    template <typename OtherGeometry>
    bool contains(const OtherGeometry& otherGeometry) const {
        return boost::geometry::within(otherGeometry, *this);
    }

    template <typename OtherGeometry>
    bool intersects(const OtherGeometry& otherGeometry) const {
        return boost::geometry::intersects(otherGeometry, *this);
    }

    template <typename OtherGeometry>
    bool disjoint(const OtherGeometry& otherGeometry) const {
        return boost::geometry::disjoint(otherGeometry, *this);
    }


public:

    bool isValid() const {
        for(int d=0; d<D; ++d)
            if(maxCorner[d]<minCorner[d])
                return false;
        return true;
    }

    static Derived invalid() {
        return Derived();
    }

    Derived normalized() const
    {
        Derived r;
        for(int d=0; d<D; ++d)
        {
            if(maxCorner[d]<minCorner[d]) {
                r.maxCorner[d] = minCorner[d];
                r.minCorner[d] = maxCorner[d];
            } else {
                r.maxCorner[d] = maxCorner[d];
                r.minCorner[d] = minCorner[d];
            }
        }
        return r;
    }

    bool isNull() const {
        for(int d=0; d<D; ++d)
            if(maxCorner[d]!=minCorner[d])
                return false;
        return true;
    }

    static Derived null() {
        Derived r;
        r.minCorner = Eigen::Matrix<T,D,1>::Zero(D,1);
        r.maxCorner = Eigen::Matrix<T,D,1>::Zero(D,1);
        return r;
    }

    static Derived zero() {
        return null();
    }

public:

    Derived operator|(const Derived& other) const
    {
        if(!this->isValid())
            return other;
        if(!other.isValid())
            return *((Derived*)this); // we are of type Derived

        Derived r;
        for(int d=0; d<D; ++d) {
            r.minCorner[d] = std::min(minCorner[d], other.minCorner[d]);
            r.maxCorner[d] = std::max(maxCorner[d], other.maxCorner[d]);
        }
        return r;
    }

    const Derived& operator|=(const Derived& other)
    {
        if(!isValid()) {
            *this = other;
        } else if(other.isValid()) {
            for(int d=0; d<D; ++d) {
                if(other.minCorner[d]<minCorner[d])
                    minCorner[d] = other.minCorner[d];
                if(other.maxCorner[d]>maxCorner[d])
                    maxCorner[d] = other.maxCorner[d];
            }
        }
        return *((Derived*)this); // we are of type Derived
    }

    const Derived& operator|=(const PointType& p)
    {
        if(!isValid()) {
            minCorner = p;
            maxCorner = p;
        } else {
            for(int d=0; d<D; ++d) {
                if(p[d]<minCorner[d])
                    minCorner[d] = p[d];
                if(p[d]>maxCorner[d])
                    maxCorner[d] = p[d];
            }
        }
        return *((Derived*)this); // we are of type Derived
    }

    Derived operator&(const Derived& other) const
    {
        if(!isValid())
            return invalid();
        if(!other.isValid())
            return invalid();

        Derived r;
        for(int d=0; d<D; ++d) {
            r.minCorner[d] = std::max(minCorner[d], other.minCorner[d]);
            r.maxCorner[d] = std::min(maxCorner[d], other.maxCorner[d]);
        }
        return r;
    }

    const Derived& operator&=(const Derived& other)
    {
        if(!isValid())
            return *((Derived*)this);

        if(!other.isValid()) {
            *this = other;
        } else {
            for(int d=0; d<D; ++d) {
                minCorner[d] = std::max(minCorner[d], other.minCorner[d]);
                maxCorner[d] = std::min(maxCorner[d], other.maxCorner[d]);
            }
        }
        return *((Derived*)this);
    }

    template<typename U, typename OtherDerived>
    static Derived convertFrom(const RectBase<U,D, OtherDerived>& other) {
        return Derived(PointType(other.minCorner.template cast<T>()),
                       PointType(other.maxCorner.template cast<T>()));
    }

    const Derived& operator+=(const PointType& displacement)
    {
        minCorner+=displacement;
        maxCorner+=displacement;
        return *((Derived*)this);
    }

    Derived operator+(const PointType& displacement) const
    {
        return Derived((PointType)(minCorner+displacement), (PointType)(maxCorner+displacement));
    }

public:
    PointType minCorner;
    PointType maxCorner;
};


template<typename T, int D>
class Rect : public RectBase<T,D, Rect<T,D> >
{
public:
    typedef RectBase<T,D, Rect<T,D> > Base;
    typedef typename Base::PointType PointType;
    typedef typename Base::SizeType SizeType;
    typedef typename Base::BoxType BoxType;

public:
    Rect() {}

    Rect(const PointType& p1, const PointType& p2,
         bool makeValid = true) :
        Base(p1, p2, makeValid) {}
};


template<typename T>
class Rect<T,2> : public RectBase<T,2, Rect<T,2> >
{
public:
    typedef RectBase<T,2, Rect<T,2> > Base;
    typedef typename Base::PointType PointType;
    typedef typename Base::SizeType SizeType;
    typedef typename Base::BoxType BoxType;

public:

    Rect() {}

    Rect(T x, T y, T width, T height) :
        Base(x, y, width, height) {}

    Rect(const PointType& pos, T width, T height) :
        Base(pos, width, height) {}

    Rect(const PointType& pos, const SizeType& s) :
        Base(pos, s) {}

    explicit Rect(const BoxType& box) :
        Base(box) {}

    explicit Rect(const cv::Rect_<T>& rect) :
        Base(rect.x, rect.y, rect.width, rect.height) {}

    Rect(const PointType& p1, const PointType& p2,
         bool makeValid = true) :
        Base(p1, p2, makeValid) {}


public:

    operator cv::Rect_<T>() const
    {
        return cv::Rect_<T>(Base::minCorner, Base::size());
    }


public:

    T& x0() { return this->minCorner[0]; }
    T  x0() const { return this->minCorner[0]; }

    T& y0() { return this->minCorner[1]; }
    T  y0() const { return this->minCorner[1]; }

    T& x1() { return this->maxCorner[0]; }
    T  x1() const { return this->maxCorner[0]; }

    T& y1() { return this->maxCorner[1]; }
    T  y1() const { return this->maxCorner[1]; }

    T width()  const { return this->maxCorner[0] - this->minCorner[0]; }
    T height() const { return this->maxCorner[1] - this->minCorner[1]; }


    std::list<Rect<T,2>> operator-(const Rect<T,2>& other) const
    {
        if(!this->isValid())
            return std::list<Rect<T,2>>();

        if(!other.isValid())
            return std::list<Rect<T,2>>( {*this} );

//      if (this->disjoint(other)) // unfortunately, "touching" (intersections of width or
                                   // height = 0) is considered intersecting by the boost
                                   // geometry base (particularly irritating with T = int)
        Rect<T,2> inter = *this & other;
        if ((inter.width() <= 0) || (inter.height() <= 0))
            return std::list<Rect<T,2>>( {*this} );

        if (other.contains(*this))
            return std::list<Rect<T,2>>();

        std::list<Rect<T,2>> result;

        PointType tl(this->x0(), this->y1());  // this top left
        PointType br(this->x1(), this->y0());  // this bottom right
        const PointType& bl = this->minCorner; // this bottom left
        const PointType& tr = this->maxCorner; // this top right

        PointType otl(other.x0(), other.y1());  // other top left
        PointType obr(other.x1(), other.y0());  // other bottom right
        const PointType& obl = other.minCorner; // other bottom left
        const PointType& otr = other.maxCorner; // other top right

        Rect<T,2> rtl = Rect<T,2>(tl, otr) & *this;
        Rect<T,2> rbl = Rect<T,2>(bl, otl) & *this;
        Rect<T,2> rbr = Rect<T,2>(br, obl) & *this;
        Rect<T,2> rtr = Rect<T,2>(tr, obr) & *this;

        if ((rtl.width() > 0) && (rtl.height() > 0)) result.push_back(rtl);
        if ((rbl.width() > 0) && (rbl.height() > 0)) result.push_back(rbl);
        if ((rbr.width() > 0) && (rbr.height() > 0)) result.push_back(rbr);
        if ((rtr.width() > 0) && (rtr.height() > 0)) result.push_back(rtr);

        return result;
    }
};


template<typename T>
class Rect<T,3> : public RectBase<T,3, Rect<T,3> >
{
public:
    typedef RectBase<T,3, Rect<T,3> > Base;
    typedef typename Base::PointType PointType;
    typedef typename Base::SizeType SizeType;
    typedef typename Base::BoxType BoxType;

public:

    Rect() {} 

    Rect(T x, T y, T z, T width, T height, T depth) :
        Base(x, y, z, width, height, depth) {}

    Rect(const PointType& pos, T width, T height, T depth) :
        Base(pos, width, height, depth) {}

    Rect(const PointType& pos, const SizeType& s) :
        Base(pos, s) {}

    explicit Rect(const BoxType& box) :
        Base(box) {}

    Rect(const PointType& p1, const PointType& p2,
         bool makeValid = true) :
        Base(p1, p2, makeValid) {}


public:

    T& x0() { return this->minCorner[0]; }
    T  x0() const { return this->minCorner[0]; }

    T& y0() { return this->minCorner[1]; }
    T  y0() const { return this->minCorner[1]; }

    T& z0() { return this->minCorner[2]; }
    T  z0() const { return this->minCorner[2]; }

    T& x1() { return this->maxCorner[0]; }
    T  x1() const { return this->maxCorner[0]; }

    T& y1() { return this->maxCorner[1]; }
    T  y1() const { return this->maxCorner[1]; }

    T& z1() { return this->maxCorner[2]; }
    T  z1() const { return this->maxCorner[2]; }

    T width()  const { return this->maxCorner[0] - this->minCorner[0]; }
    T height() const { return this->maxCorner[1] - this->minCorner[1]; }
    T depth()  const { return this->maxCorner[2] - this->minCorner[2]; }
};


typedef Rect<int, 2> Rect2i;

typedef Rect<float, 2> Rect2f;

typedef Rect<double, 2> Rect2d;

typedef Rect<int, 3> Box3i;

typedef Rect<float, 3> Box3f;

typedef Rect<double, 3> Box3d;


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

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

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

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

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

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


}

// BOOST specialization on Rect to accept them as geometry entity
namespace boost { namespace geometry { namespace traits {


template <typename T, int D, typename Derived>
struct tag<mira::RectBase<T,D, Derived> > { typedef box_tag type; };

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

template <typename T, int D, std::size_t Dimension, typename Derived>
struct indexed_access<mira::RectBase<T,D, Derived>, min_corner, Dimension>
{
    typedef typename geometry::coordinate_type<mira::Point<T,D> >::type coordinate_type;
    static inline coordinate_type get(mira::RectBase<T,D,Derived> const& b) {
        return geometry::get<Dimension>(b.minCorner);
    }
    static inline void set(mira::RectBase<T,D,Derived>& b, coordinate_type const& value) {
        geometry::set<Dimension>(b.minCorner, value);
    }
};

template <typename T, int D, std::size_t Dimension, typename Derived>
struct indexed_access<mira::RectBase<T,D, Derived>, max_corner, Dimension>
{
    typedef typename geometry::coordinate_type<mira::Point<T,D>>::type coordinate_type;
    static inline coordinate_type get(mira::RectBase<T,D, Derived> const& b) {
        return geometry::get<Dimension>(b.maxCorner);
    }
    static inline void set(mira::RectBase<T,D, Derived>& b, coordinate_type const& value) {
        geometry::set<Dimension>(b.maxCorner, value);
    }
};

template <typename T, int D>
struct tag<mira::Rect<T,D> > : public tag<mira::RectBase<T,D, mira::Rect<T,D>>> {};

template <typename T, int D>
struct point_type<mira::Rect<T,D> > : public point_type<mira::RectBase<T,D,mira::Rect<T,D>>> {};

template <typename T, int D, std::size_t Dimension>
struct indexed_access<mira::Rect<T,D>, min_corner, Dimension> :
    public indexed_access<mira::RectBase<T,D,mira::Rect<T,D>>, min_corner, Dimension> {};

template <typename T, int D, std::size_t Dimension>
struct indexed_access<mira::Rect<T,D>, max_corner, Dimension> :
    public indexed_access<mira::RectBase<T,D,mira::Rect<T,D>>, max_corner, Dimension> {};


}}}


#endif