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

---

VxRectangle.h

Go to the documentation of this file.

#ifndef Impala_Core_Geometry_VxRectangle_h
#define Impala_Core_Geometry_VxRectangle_h

#include <string>
#include "Core/Geometry/Rectangle.h"

namespace Impala
{
namespace Core
{
namespace Geometry
{


// Video rectangle (+ annotation)
class VxRectangle
{
public:

    std::string mVideoName; // dbFile
    std::string mSection; // dbSection
    std::string mDir; // dbDir
    int         mStartFrame;
    int         mEndFrame;
    Rectangle   mRect;
    std::string mAnno;
    std::string mExtra;

    int
    operator==(const VxRectangle& r) const
    {
        return ((mVideoName == r.mVideoName) && (mSection == r.mSection) &&
                (mDir == r.mDir) && (mStartFrame == r.mStartFrame) &&
                (mEndFrame == r.mEndFrame) && (mRect == r.mRect) &&
                (mAnno == r.mAnno) && (mExtra == r.mExtra));
    }

    bool
    EqualInTime(const VxRectangle& v) const
    {
        return ((mStartFrame == v.mStartFrame) &&
                (mEndFrame   == v.mEndFrame) &&
                (mVideoName  == v.mVideoName));
    }

    bool
    MeetsInTime(const VxRectangle& v) const
    {
        return ((mEndFrame  == v.mStartFrame + 1) &&
                (mVideoName == v.mVideoName));
    }

    bool
    BeforeInTime(const VxRectangle& v) const
    {
        return ((mEndFrame < v.mStartFrame) && !MeetsInTime(v));
    }

    bool
    OverlapsInTime(const VxRectangle& v) const
    {
        return ((mStartFrame <  v.mStartFrame) &&
                (mEndFrame   >= v.mStartFrame) &&
                (mEndFrame   <  v.mEndFrame)   &&
                (mVideoName  == v.mVideoName));
    }

    bool
    During(const VxRectangle& v) const
    {
        return (!EqualInTime(v) &&
                (mStartFrame >= v.mStartFrame) &&
                (mEndFrame   <= v.mEndFrame) &&
                (mVideoName  == v.mVideoName));
    }

    bool
    ContainsInTime(const VxRectangle& v) const
    {
        return (v.During(*this));
    }

    bool
    MeetsAnywhereInTime(const VxRectangle& v) const
    {
        return (MeetsInTime(v) || v.MeetsInTime(*this));
    }

    bool
    BeforeAfterInTime(const VxRectangle& v) const
    {
        return (BeforeInTime(v) || v.BeforeInTime(*this));
    }

    bool
    OverlapsAnywhereInTime(const VxRectangle& v) const
    {
        return (OverlapsInTime(v) || v.OverlapsInTime(*this));
    }

};

inline std::ostream&
operator<<(std::ostream& os, const VxRectangle& r)
{
    os << "anno=\"" << r.mAnno << "\", frames: " << r.mStartFrame
       << " to " << r.mEndFrame << ", rect=" << r.mRect << ", extra="
       << r.mExtra << std::endl;
    return os;
}

} // namespace Geometry
} // namespace Core
} // namespace Impala

#endif

---