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

---

SearcherPyramid.h

Go to the documentation of this file.

#ifndef Impala_Core_Tracking_SearcherPyramid_h
#define Impala_Core_Tracking_SearcherPyramid_h

#include "Core/Array/Pattern/PatSet.h"
#include "Core/Array/Pattern/FuncGenConv2d.h"

#include "Core/Tracking/SearcherBase.h"
#include "Core/Tracking/Functors.h"
#include "Core/Tracking/ObjectRepresentation.h"
#include "Core/Tracking/ImagePyramid.h"

namespace Impala
{
namespace Core
{
namespace Tracking
{

class SearcherPyramid : public SearcherBase
{
public:
    SearcherPyramid()
    {
        mTemplatePyramid = 0;
        mInputPyramid = 0;
    }

    virtual ~SearcherPyramid()
    {
        if(mTemplatePyramid)
            delete mTemplatePyramid;
        if(mInputPyramid)
            delete mInputPyramid;
    }

    virtual void
    SearchObject(Array::Array2dVec3Real64& image)
    {
        if(mTemplatePyramid == 0)
            return;

        mInputPyramid->PropagateBaseChanges();
        mTemplatePyramid->PropagateBaseChanges();

        //search in the highest level in both pyramids (template is always the
        //smaller)
        int level = mTemplatePyramid->Levels()-1;
        Point searchSize(mInputPyramid->GetSize(level));
        Point searchPos(0, 0);
        Point searchBorder(mInputPyramid->GetSize(0));

        Array::Array2dVec3Real64* searchArea;
        Array::Array2dVec3Real64* searchResult;
        searchArea =
            new Array::Array2dVec3Real64(searchSize.x + 2*searchBorder.x,
                                         searchSize.y + 2*searchBorder.y, 0, 0, 0);
        searchResult =
            new Array::Array2dVec3Real64(searchSize.x + 2*searchBorder.x,
                                         searchSize.y + 2*searchBorder.y, 0, 0, 0);

        Array::Trait::FuncExportMinMax<Array::Vec3Real64,
                                       Array::Array2dVec3Real64> minmax;
        Array::Trait::FuncBpoManhatDist dist;
        Array::Trait::FuncBpoAddAssignPtr bpoAss;

        while(level>=0)
        {
            searchBorder.x = mTemplatePyramid->GetLevel(level)->CW();
            searchBorder.y = mTemplatePyramid->GetLevel(level)->CH();

            searchArea->mCW = 2*searchBorder.x + searchSize.x;
            searchArea->mCH = 2*searchBorder.y + searchSize.y;
            searchArea->mBW = 0;
            searchArea->mBH = 0;
            Array::Pattern::PatSet(searchArea, mInputPyramid->GetLevel(level),
                                   searchPos.x - searchBorder.x,
                                   searchPos.y - searchBorder.y,
                                   searchSize.x + 2*searchBorder.x,
                                   searchSize.y + 2*searchBorder.y, 0, 0);
            searchArea->mCW = searchSize.x;
            searchArea->mCH = searchSize.y;
            searchArea->mBW = searchBorder.x;
            searchArea->mBH = searchBorder.y;
            searchResult->mCW = searchSize.x;
            searchResult->mCH = searchSize.y;
            searchResult->mBW = searchBorder.x;
            searchResult->mBH = searchBorder.y;

            Array::Pattern::FuncGenConv2dDispatch(searchResult, searchArea,
                                                  mTemplatePyramid->GetLevel(level),
                                                  dist, bpoAss);

            minmax.Reset();
            Array::Pattern::PatInOutOp(searchResult, minmax);

            minmax.minPos.mX += searchPos.x;
            minmax.minPos.mY += searchPos.y;

            if(level>0)
            {
                minmax.minPos *= 2;
                searchPos.x = minmax.minPos.mX - 1;
                searchPos.y = minmax.minPos.mY - 1;
                searchSize.x = 3;
                searchSize.y = 3;
                //clip
                Point max = mInputPyramid->GetSize(level-1);
                if(searchPos.x < 0)
                    searchPos.x = 0;
                if(searchPos.y < 0)
                    searchPos.y = 0;
                if(searchPos.x > max.x - 4)
                    searchPos.x = max.x - 4;
                if(searchPos.y > max.y - 4)
                    searchPos.y = max.y - 4;
            }
            level--;
        }
        mLastPos.translation.x = minmax.minPos.mX - mLastPos.size.x/2;
        mLastPos.translation.y = minmax.minPos.mY - mLastPos.size.y/2;

        delete searchResult;
        delete searchArea;
        
    }

    void
    Reset(Array::Array2dVec3Real64& image, ObjectRepresentation& object,
          const Position& pos)
    {
        if(mInputPyramid)
            delete mInputPyramid;
        mInputPyramid = new ImagePyramid(&image);
        mInputPyramid->ComputeLevels(0);

        if(mTemplatePyramid)
            delete mTemplatePyramid;
        mTemplatePyramid = 0;
        Array::Array2dVec3Real64* obj = object.GetImage();
        if(obj)
        {
            ILOG_DEBUG("obj not null");
            mTemplatePyramid = new ImagePyramid(object.GetImage());
            mTemplatePyramid->ComputeLevels(0);
        }
        else
        {
            ILOG_WARN("object image null!");
        }

        mLastPos = pos;
    }

    ImagePyramid* mInputPyramid;
    ImagePyramid* mTemplatePyramid;

    static log4cpp::Category& sLog;
};

ILOG_VAR_INIT(SearcherPyramid, Impala.Core.Tracking);

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

#endif //Impala_Core_Tracking_SearcherPyramid_h

---