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

---

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 "Core/Feature/InterestPointFeature.h"

namespace Impala
{
namespace Core
{
namespace VideoSet
{

class InterestPointProc : public Listener
{
public:

    InterestPointProc(Reporter* reporter, CmdOptions& options)
        : mInterestPointFeature(options), mOptions(options), mNoZIP(false), 
          mSkipThisVideo(false)
    {
        mReporter = reporter;
        mKeyframes = 0;
        mNoZIP = options.GetBool("noZIP");
        mTableInfoString = "codebook=" + options.GetString("codebook");
        mCodebookSet = "";
        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())
                bookSet = Database::MakeRawDataSet(mCodebookSet);

            mInterestPointFeature.SetCodebook(mOptions.GetString("codebook"),
                                              bookSet->GetDatabase());
        }
    }

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

    virtual void
    HandleNewWalk(VideoSet* vs, Keyframes* keyframes, bool* keyframeMask)
    {
        mKeyframes = keyframes;
    }

    virtual void
    HandleNewFile(VideoSet* vs, int fileId, Stream::RgbDataSrc* src)
    {
        // Make the feature data folder
        ILOG_INFO("HandleNewFile: " << fileId);
        String folder = vs->GetFilePathFeatureData(mWalkType, mInterestPointFeature.GetFeatureName(), fileId, false, -1, true, false);
        ILOG_DEBUG("Storage folder: " << folder);
        String folder2 = vs->GetFilePathFeatureData(mWalkType, mInterestPointFeature.GetFeatureNameShort(), fileId, false, -1, true, false);
        ILOG_DEBUG("Storage folder (#2): " << folder2);
        mTemporaryFilenames.clear();
        mSkipThisVideo = false;
        if(!CmdOptions::GetInstance().GetBool("override")) 
        {
            // only support skipping if override is off
            if(!mNoZIP) 
            {
                // does the ZIP exist already?
                String serverName = vs->GetFilePathFeatureData(mWalkType, mInterestPointFeature.GetFeatureName(), fileId, false, -1, true, false) + ".zip";
                String temp = vs->GetDatabase()->GetFilePath(serverName, false, true);
                if(!temp.empty()) {
                    mSkipThisVideo = true;
                    ILOG_INFO("Skipping video " << fileId << "; ZIP file already exists");
                }
            } else {
                if(mInterestPointFeature.mClusterInput)
                {
                    // clusterInput mode
                    Feature::FeatureDefinition def = mInterestPointFeature.GetFeatureName();
                    def.AddParameter("clusterinput", "2");
                    String tableName = vs->GetFilePathFeatureData(mWalkType, def, fileId, false, -1, false, true);
                    if(!tableName.empty())
                    {
                        mSkipThisVideo = true;
                        ILOG_INFO("Skipping folder " << fileId << "; FeatureData:ClusterInput file already exists");
                    }
                }
                else
                {
                    // does the featuretable exist already?
                    String tableName = vs->GetFilePathFeatureData(mWalkType, mInterestPointFeature.mFeatureDefinition, fileId, false, -1, false, true);
                    if(!tableName.empty())
                    {
                        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);
        }

        if(mInterestPointFeature.mLastCodebookVectors.size() != 0) {
            // we have a projected feature vector
            if(mFeatureTables.size() < mInterestPointFeature.mLastCodebookVectors.size()) {
                // first valid vector: allocate the table
                for(int i = mFeatureTables.size(); i < mInterestPointFeature.mLastCodebookVectors.size(); i++) {
                    mFeatureTables.push_back(new Feature::FeatureTable(mInterestPointFeature.GetFeatureName(), 500, mInterestPointFeature.mLastCodebookVectors[i]->Size()));
                }
            }
            for(int i = 0; i < mInterestPointFeature.mLastCodebookVectors.size(); i++) {
                Quid quid = vs->GetQuidFrame(fileId, src->FrameNr());
                mFeatureTables[i]->Add(quid, *mInterestPointFeature.mLastCodebookVectors[i]);
            }
        }

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

        delete im;
    }

    virtual void
    HandleDoneFile(VideoSet* vs, int fileId, Stream::RgbDataSrc* src)
    {
        if(mSkipThisVideo) return;
        // Feature table logic
        String tableName = vs->GetFilePathFeatureData(mWalkType, mInterestPointFeature.mFeatureDefinition, fileId, false, -1, true, false);
        if(mFeatureTables.size() != 0) {
            for(int i = 0; i < mFeatureTables.size(); i++) {
                Feature::FeatureDefinition tempDef(mInterestPointFeature.mFeatureDefinition.AsString());
                if(i != 0) tempDef.AddParameter("sub", MakeString(i));
                String tempTableName = vs->GetFilePathFeatureData(mWalkType, tempDef, fileId, false, -1, true, false);
                mFeatureTables[i]->SetInfo(mTableInfoString);
                Write(mFeatureTables[i], tempTableName, vs->GetDatabase(), true);
                delete mFeatureTables[i];
                mFeatureTables[i] = 0;
            }
            mFeatureTables.clear();
        }
        
        // ZIP-file logic
        if(!mNoZIP) {
            String serverPath = vs->GetFilePathFeatureData(mWalkType, mInterestPointFeature.GetFeatureName(), fileId, false, -1, true, false);
            String fName = PathJoin(GetTmpPath(), "tmp-" + mInterestPointFeature.GetFeatureName() + "-" + MakeString(fileId) + ".zip");
            String txtName = StringReplace(fName, ".zip", ".txt");
            String serverName = serverPath + ".zip";

            ILOG_DEBUG("fName:      " << fName);
            ILOG_DEBUG("txtName:    " << txtName);
            ILOG_DEBUG("serverName: " << serverName);
            if (fName == String("")) {
                ILOG_ERROR("Empty file name");
            }
            
            // put it all in fName
            std::ofstream fs(txtName.c_str());
            for(std::vector<String>::iterator iter = mTemporaryFilenames.begin(); iter != mTemporaryFilenames.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 (fName != String("")) {
                // 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
            Util::IOBuffer* zip = new Util::IOBufferFile(fName, true, false);
            Impala::Util::Database& database(Impala::Util::Database::GetInstance());
            Util::IOBuffer* destination = database.GetIOBuffer(serverName, false, false, "tmp", 0, true);
            ILOG_INFO("ZIP file to copy to dataserver has " << zip->Available() << " bytes");
            static const int bufSize = 1024 * 1024;
            static unsigned char buffer[bufSize];
            while(true) {
                int bytesread = zip->Read(buffer, bufSize);
                if(bytesread == 0) break;
                destination->Write(buffer, bytesread);
            }
            delete zip;
            delete destination;      // this will force a write through a channel, if needed

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

        // clusterInput mode
        if(mInterestPointFeature.mClusterInput && mInterestPointFeature.mClusterInputData)
        {
            String tableName = vs->GetFilePathFeatureData(mWalkType, mInterestPointFeature.mClusterInputData->GetFeatureDefinition(), fileId, false, -1, true, false);
            Write(mInterestPointFeature.mClusterInputData, tableName, vs->GetDatabase(), true);
            delete mInterestPointFeature.mClusterInputData;
            mInterestPointFeature.mClusterInputData = 0;
        }
        
        // cleanup
        for(std::vector<String>::iterator iter = mTemporaryFilenames.begin(); iter != mTemporaryFilenames.end(); iter++) {
            if(std::remove((*iter).c_str()) != 0) {
                ILOG_WARN("Could not cleanup intermediate file: " << (*iter));
            }
        }
        mTemporaryFilenames.clear();

        ILOG_INFO("HandleDoneFile: " << fileId);
    }

private:

    Reporter*          mReporter;
    Keyframes*         mKeyframes;
    std::vector<Feature::FeatureTable*> mFeatureTables;
    Feature::InterestPointFeature mInterestPointFeature;
    CmdOptions& mOptions;
    String mCodebookSet;
    std::vector<String> mTemporaryFilenames;
    bool mNoZIP;
    bool mSkipThisVideo;
    String mTableInfoString;
    String mWalkType;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(InterestPointProc, Core.VideoSet);

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

#endif

---