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

---

ClusterFeatures.h

Go to the documentation of this file.

#ifndef Impala_Core_VideoSet_ClusterFeatures_h
#define Impala_Core_VideoSet_ClusterFeatures_h

#include "Core/Feature/ClusterorFactory.h"
#include "Core/Feature/Computor.h"
#include "Core/VideoSet/Reporter.h"

namespace Impala
{
namespace Core
{
namespace VideoSet
{


class ClusterFeatures : public Listener
{
public:

    typedef Feature::Computor Computor;
    typedef Feature::Clusteror Clusteror;
    typedef Feature::FeatureTable FeatureTable;

    ClusterFeatures(Computor* computor, String clusteror, Reporter* reporter,
                    CmdOptions& options)
    {
        mReporter = reporter;
        mComputor = computor;

        if (options.GetNrArg() < 7)
            ILOG_ERROR("missing argument");
        String mode = options.GetArg(4);
        int nrWantedClusters = atoi(options.GetArg(5));
        int nrSamplesAtime = atoi(options.GetArg(6));
        ILOG_INFO("mode = " << mode << ", wanted = " << nrWantedClusters <<
                  ", samplesAtime = " << nrSamplesAtime);

        mComputor->MakeRegionFeatureTableSet();

        for (int p=0 ; p<mComputor->GetNrPixelFeatureSets() ; p++)
        {
            for (int r=0 ; r<mComputor->GetNrRegionFeatureSets() ; r++)
            {
                //int minElemsInCluster = mComputor->GetRegionFeatureSetSize(r)+1;
                int minElemsInCluster = 2;
                Feature::ClusterorFactory::Instance().Construct
                    (mClusterors, p, r, nrWantedClusters, nrSamplesAtime,
                     minElemsInCluster, clusteror, options);
            }
        }

        /* todo ??
        if ((mode == "next") || (mode == "count"))
        {
            mComputor->ReadProtoFeatureTableSet("all");
            mComputor->GetProtoFeatureTableSet()->Dump(false);
            for (int i=0 ; i<mClusterors.size() ; i++)
            {
                Clusteror* c = mClusterors[i];
                FeatureTable* tab = mComputor->GetProtoFeatureTable
                    (c->GetPixelFeatureSet(), c->GetRegionFeatureSet(),
                     c->GetClusterType(), c->GetClusterVal());
                c->InitClusterVec(tab, mode, nrWantedClusters);
            }
        }
        */
    }

    virtual void
    HandleNewFrame(VideoSet* vs, int fileId, Stream::RgbDataSrc* src)
    {
        Quid quid = vs->GetQuidFrame(fileId, src->FrameNr());
        Array::Array2dVec3UInt8* im = Array::ArrayCreate<Array::Array2dVec3UInt8>
            (src->FrameWidth(), src->FrameHeight(), 0, 0, src->DataPtr(), true);

        mComputor->ComputeRegionFeatures(im, quid);

        for (int p=0 ; p<mComputor->GetNrPixelFeatureSets() ; p++)
        {
            for (int r=0 ; r<mComputor->GetNrRegionFeatureSets() ; r++)
            {
                FeatureTable* tab = mComputor->GetRegionFeatureTable(p, r);
                for (int clustID=0 ; clustID<mClusterors.size() ; clustID++)
                {
                    if (mClusterors[clustID]->GetPixelFeatureSet() == p
                        && mClusterors[clustID]->GetRegionFeatureSet() == r)
                    {
                        mClusterors[clustID]->Cluster(tab);
                    }
                }
            }
        }

        mComputor->GetRegionFeatureTableSet()->SetEmpty();
        delete im;

        // experimental
        bool allDone = true;
        for (int i=0 ; i<mClusterors.size() ; i++)
        {
            if (mReporter->DoPrint())
                mClusterors[i]->PrintStatus();
            allDone = allDone && mClusterors[i]->HadEnough();
        }
        if (allDone)
        {
            ILOG_INFO("all clusterors had enough");
            HandleDoneWalk(vs);
            ILOG_INFO("had enough, bye");
            exit(0);
        }
    }

    virtual void
    HandleDoneWalk(VideoSet* vs)
    {
        ILOG_INFO("Done Walk");
        for (int i=0 ; i<mClusterors.size() ; i++)
            mClusterors[i]->FinishBuffer();
        std::cout << std::endl;

        for (int i=0 ; i<mClusterors.size() ; i++)
        {
            Clusteror* c = mClusterors[i];
            FeatureTable* tab = mComputor->MakeProtoFeatureTable
                (c->GetPixelFeatureSet(), c->GetRegionFeatureSet(),
                 c->GetClusterType(), c->GetClusterVal());
            c->Clusters2FeatureTable(tab);
        }

        mComputor->WriteProtoFeatureTableSet(vs);
    }

private:

    Reporter*               mReporter;
    Feature::Computor*      mComputor;
    std::vector<Clusteror*> mClusterors;

    ILOG_VAR_DEC;

};

ILOG_VAR_INIT(ClusterFeatures, Impala.Core.VideoSet);

} // namespace VideoSet
} // namespace Core
} // namespace Impala

#endif

---