|| || || || || ||

---

BasicTypes.h

Go to the documentation of this file.

#ifndef Imapala_Core_Tracking_BasicTypes_h
#define Imapala_Core_Tracking_BasicTypes_h

#include <stdlib.h>

namespace Impala
{
namespace Core
{
namespace Tracking
{

inline int Random(int range)
{
    return rand() % range;
}

class Point
{
public:
    int x,y;
    Point() : x(0),y(0) {}
    Point(int ax, int ay) : x(ax),y(ay) {}
    Point(const Point& p) : x(p.x),y(p.y) {}
    Point& operator=(const Point& p)
    {
        x=p.x;
        y=p.y;
        return *this;
    }

    Point& operator+=(int i)
    {
        x+=i;
        y+=i;
        return *this;
    }
    Point& operator-=(int i)
    {
        x-=i;
        y-=i;
        return *this;
    }
    Point& operator-=(const Point& p)
    {
        x-=p.x;
        y-=p.y;
        return *this;
    }
    Point& operator/=(int i)
    {
        if(i!=0)
        {
            x/=i;
            y/=i;
            return *this;
        }
    }
    Point& operator*=(int i)
    {
        if(i!=0)
        {
            x*=i;
            y*=i;
            return *this;
        }
    }

    int Inproduct()
    {
        return x*y;
    }
};

class Rect
{
public:
    int left,top,right,bottom;
    Rect()
        :left(0),
        top(0),
        right(0),
        bottom(0)
    {
    }
    Rect(int l,int t,int r,int b)
        :left(l),
        top(t),
        right(r),
        bottom(b)
    {
    }
    Rect(const Rect& r)
        :left(r.left),
        top(r.top),
        right(r.right),
        bottom(r.bottom)
    {
    }
    Rect(const Point& p)
        :left(p.x),
        top(p.y),
        right(p.x),
        bottom(p.y)
    {
    }

    int width() const
    {
        return right-left+1;
    }
    int height() const
    {
        return bottom-top+1;
    }
    Point size() const
    {
        return Point(width(), height());
    }
    Point mid() const
    {
        //in case of an even number of pixels width or height there is no
        //'middle pixel' so in that case a choice has to be made... we take
        //the pixel left and below the mathematical mid to be the middle pixel
        //because this works well with convolutions
        return Point((left+right+1)/2, (top+bottom+1)/2);
    }
    void clip(const Rect& clip)
    {
        if(left<clip.left)
        {
            left=clip.left;
            if(right<left)
                right=left;
        }
        if(top<clip.top)
        {
            top=clip.top;
            if(bottom<top)
                bottom=top;
        }
        if(right>clip.right)
        {
            right=clip.right;
            if(left>right)
                left=right;
        }
        if(bottom>clip.bottom)
        {
            bottom=clip.bottom;
            if(top>bottom)
                top=bottom;
        }
    }
    void operator-=(const Rect& r)
    {
        left -= r.left;
        top -= r.top;
        right -= r.right;
        bottom -= r.bottom;
    }
    void operator+=(const Rect& r)
    {
        left += r.left;
        top += r.top;
        right += r.right;
        bottom += r.bottom;
    }
    void operator+=(const Point& p)
    {
        left += p.x;
        top += p.y;
        right += p.x;
        bottom += p.y;
    }
    void operator*=(int i)
    {
        left *= i;
        top *= i;
        right *= i;
        bottom *= i;
    }
    void AddBorder(const Point& p)
    {
        left -= p.x;
        top -= p.y;
        right += p.x;
        bottom += p.y;
    }
    bool operator==(const Rect& r)
    {
        if(left==r.left && top==r.top && right==r.right && bottom==r.bottom)
            return true;
        return false;
    }
};

class Position
{
public:
    Point translation;
    Point size;
    double rotation;
    double scale;
    Position() : rotation(0), scale(0) {}
    Position& operator=(const Position& p)
    {
        translation = p.translation;
        size = p.size;
        rotation = p.rotation;
        scale = p.scale;
        return *this;
    }
};

} // namespace Tracking
} // namespace Core
} // namespace Impala

#endif //Imapala_Core_Tracking_BasicTypes_h

---