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

---

InterestPointProc.h

Go to the documentation of this file.

#ifndef Impala_Core_VideoSet_InterestPointProc_h
#define Impala_Core_VideoSet_InterestPointProc_h

#include "Core/VideoSet/Reporter.h"
#include "Core/VideoSet/Keyframes.h"
#include "Core/Array/MakeFromValue.h"
#include "Core/Array/ArrayListDelete.h"
#include "Core/Array/WriteRaw.h"
#include "Persistency/FeatureTableRepository.h"
#include "Core/Feature/InterestPointFeature.h"

namespace Impala
{
namespace Core
{
namespace VideoSet
{

class InterestPointProc : public Listener
{
public:

    typedef Persistency::FeatureLocator FeatureLocator;
    typedef Persistency::FeatureTableRepository FeatureTableRepository;
    typedef Persistency::FileLocator FileLocator;
    typedef Persistency::File File;

    InterestPointProc(Reporter* reporter, CmdOptions& options)
        : mInterestPointFeature(options), mOptions(options), mNoZIP(false), 
          mSkipThisVideo(false)
    {
        mNoZIP = options.GetBool("noZIP");
        mCodebookSet = "";
        mFeatureTableResult.SetInfo("codebook=" + options.GetString("codebook"));
        mInterestPointFeature.SetResultOutput(&mFeatureTableResult);
        if (options.GetNrArg() > 2)
            mCodebookSet = options.GetArg(2);
        if (mNoZIP)
        {
            ILOG_INFO("NOT creating ZIP output files");
        }
        else
        {
            ILOG_INFO("Creating ZIP output files");
        }
    }

    static void
    AddCmdOptions()
    { 
        Feature::InterestPointFeature::AddCmdOptions();

        CmdOptions& options = CmdOptions::GetInstance();
        options.AddOption(0, "noZIP",                    "",        "0");
        options.AddOption(0, "interestPointPostProcess", "command", "");
    }

    virtual void
    HandleNewWalk(VideoSet* vs)
    {
        if (!mOptions.GetString("codebook").empty())
        {
            Database::RawDataSet* bookSet = vs;
            if (!mCodebookSet.empty())
            {
                ILOG_INFO("Using separate codebook set: " << mCodebookSet);
                bookSet = Database::MakeRawDataSet(mCodebookSet);
            }

            mInterestPointFeature.SetCodebook(mOptions.GetString("codebook"),
                                              bookSet->GetLocator());
            mFeatureTableResult.SetFeatureDefinition(
                                mInterestPointFeature.GetFeatureDefinition());
        }
    }

    virtual void
    HandleNewWalk(VideoSet* vs, String walkType)
    {
        mWalkType = walkType;
    }

    virtual void
    HandleNewFile(VideoSet* vs, int fileId, Stream::RgbDataSrc* src)
    {
        ILOG_INFO("HandleNewFile: " << fileId);
        mTempFilenames.clear();
        mSkipThisVideo = false;
        if (CmdOptions::GetInstance().GetBool("override"))
            return; // only support skipping if override is off
            
        if (!mNoZIP) 
        {
            // does the ZIP exist already?
            FeatureLocator loc(vs->GetLocator(), false, false, mWalkType,
                               mInterestPointFeature.GetFeatureName(),
                               vs->GetContainer(fileId));
            loc.ExtendSuffix(".zip");
            if (FeatureTableRepository().Exists(loc))
            {
                mSkipThisVideo = true;
                ILOG_INFO("Skipping video " << fileId <<
                          "; ZIP file already exists");
            }
            return;
        }

        if (mInterestPointFeature.mClusterInput)
        {
            // clusterInput mode
            Feature::FeatureDefinition def = mInterestPointFeature.GetFeatureName();
            def.AddParameter("clusterinput", "2");
            FeatureLocator loc(vs->GetLocator(), false, false, mWalkType,
                               def.AsString(), vs->GetContainer(fileId));
            if (FeatureTableRepository().Exists(loc))
            {
                mSkipThisVideo = true;
                ILOG_INFO("Skipping folder " << fileId <<
                          "; FeatureData:ClusterInput file already exists");
            }
        }
        else
        {
            // does the featuretable exist already?
            String f = mInterestPointFeature.GetFeatureDefinition().AsString();
            FeatureLocator loc(vs->GetLocator(), false, false, mWalkType, f,
                               vs->GetContainer(fileId));
            if (FeatureTableRepository().Exists(loc))
            {
                mSkipThisVideo = true;
                ILOG_INFO("Skipping video " << fileId <<
                          "; FeatureData file already exists");
            }
        }
    }

    virtual void
    HandleNewFrame(VideoSet* vs, int fileId, Stream::RgbDataSrc* src)
    {
        if (mSkipThisVideo)
            return;
        // get frame and friendly frame name
        Array::Array2dVec3UInt8* im = Array::ArrayCreate<Array::Array2dVec3UInt8>
            (src->FrameWidth(), src->FrameHeight(), 0, 0, src->DataPtr(), true);
        String videoName = src->GetName();
        String::size_type p = videoName.rfind("/");
        if (p != String::npos)
            videoName = videoName.substr(p+1, videoName.size());

        String imName = FileNameCtor(videoName, "frame", src->FrameNr(), "");
        imName = StringReplaceAll(imName, ".", "_");

        // verify image is not null
        if (!im)
        {
            ILOG_ERROR("No image: fileId=" << fileId << "; imName=" << imName);
            return;
        }

        // create temporary output filename
        String outputFilename = PathJoin(GetTmpPath(), imName + "." +
                                         mInterestPointFeature.GetFeatureName());

        // clean up the filename: remove .jpg and ./ paths
        outputFilename = StringReplace(outputFilename, ".jpg", "");
        outputFilename = StringReplace(outputFilename, "/./", "/");
        outputFilename = StringReplace(outputFilename, "/./", "/");
        ILOG_DEBUG("fileId=" << fileId << "; imName=" << imName <<
                   "; outputFilename=" << outputFilename);
        
        // compute feature
        if (mNoZIP)
        {
            outputFilename = "";
        }
        mInterestPointFeature.mClusterInputImage =
            QuidObj(vs->GetQuidFrame(fileId, src->FrameNr())).ToString();

        if (!mInterestPointFeature.FindInterestPoints(mOptions, im, 
               vs->GetQuidFrame(fileId, src->FrameNr()), outputFilename, true))
        {
            ILOG_ERROR("Extracting interest points/descriptors failed: " <<
                       imName);
        }

        // post-processing functionality
        if (mOptions.GetString("interestPointPostProcess") != "")
        {
            String cmd = mOptions.GetString("interestPointPostProcess")
                + " " + outputFilename;
            ILOG_INFO("Post-processing = " << cmd);
            system(cmd.c_str());
        }
        if (!mNoZIP)
        {
            mTempFilenames.push_back(outputFilename);
        }

        delete im;
    }

    virtual void
    HandleDoneFile(VideoSet* vs, int fileId, Stream::RgbDataSrc* src)
    {
        if (mSkipThisVideo)
            return;

        FeatureLocator loc(vs->GetLocator(), false, false, mWalkType, "empty",
                           vs->GetContainer(fileId));
        // Feature table logic
        if (mFeatureTableResult.GetTableSize() != 0)
        {
            for(int i = 0; i < mFeatureTableResult.Size(); i++)
            {
                loc.SetFeatureDef(mFeatureTableResult.GetFeatureDefinition(i));
                FeatureTableRepository().Add(loc, mFeatureTableResult.GetTable(i));
            }
            mFeatureTableResult.Delete();
        }
        
        // ZIP-file logic
        if (!mNoZIP)
        {
            String featureName = mInterestPointFeature.GetFeatureName();
            String fName = PathJoin(GetTmpPath(), "tmp-" + featureName +
                                    "-" + MakeString(fileId) + ".zip");
            String txtName = StringReplace(fName, ".zip", ".txt");
            loc.SetFeatureString(featureName + ".zip");
            String serverName = FeatureTableRepository().ExposeFilePath(loc,
                                                                        true);
            serverName = StringReplace(serverName, ".zip.tab", ".tab.zip");

            // put it all in fName
            std::ofstream fs(txtName.c_str());
            for (std::vector<String>::iterator iter = mTempFilenames.begin();
                 iter != mTempFilenames.end(); iter++)
            {
                fs << (*iter) << std::endl;
            }
            fs.close();
    
            String cmd = "zip ";
            cmd += fName;
            cmd += " -@ <";
            cmd += txtName;
            //TODO: call toZip.py here? Instead of Shell scripting?
            if (!serverName.empty())
            {
                // without override, fName will be empty if zip file already
                // exists, so we cannot ZIP!
                system(cmd.c_str());
            }
            
            // cleanup
            if (std::remove(txtName.c_str()) != 0)
            {
                ILOG_WARN("Could not cleanup intermediate file: " << txtName);
            }
            
            // copy ZIP file to its final destination
            File srcFile = Persistency::RepositoryGetFile(fName, false, false);
            FileLocator dstLoc(vs->GetLocator(), serverName);
            File dstFile = Persistency::RepositoryGetFile(dstLoc, true, false);
            dstFile.CopyFrom(srcFile);

            // cleanup
            if (std::remove(fName.c_str()) != 0)
            {
                ILOG_WARN("Could not cleanup temporary ZIP file: " << fName);
            }
        }

        // clusterInput mode
        if (mInterestPointFeature.mClusterInput &&
            mInterestPointFeature.mClusterInputData)
        {
            loc.SetFeatureDef(mInterestPointFeature.mClusterInputData->GetFeatureDefinition());
            FeatureTableRepository().Add(loc, mInterestPointFeature.mClusterInputData);
            delete mInterestPointFeature.mClusterInputData;
            mInterestPointFeature.mClusterInputData = 0;
        }
        
        // cleanup
        for (std::vector<String>::iterator iter = mTempFilenames.begin();
             iter != mTempFilenames.end(); iter++)
        {
            if (std::remove((*iter).c_str()) != 0)
            {
                ILOG_WARN("Could not cleanup intermediate file: " << (*iter));
            }
        }
        mTempFilenames.clear();
        ILOG_INFO("HandleDoneFile: " << fileId);
    }

private:

    Feature::FeatureTableResult mFeatureTableResult;
    Feature::InterestPointFeature mInterestPointFeature;
    CmdOptions& mOptions;
    String mCodebookSet;
    std::vector<String> mTempFilenames;
    bool mNoZIP;
    bool mSkipThisVideo;
    String mWalkType;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(InterestPointProc, Core.VideoSet);

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

#endif

---