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

---

InterestPointProc.h

Go to the documentation of this file.

#ifndef Impala_Core_ImageSet_InterestPointProc_h
#define Impala_Core_ImageSet_InterestPointProc_h

#include "Core/ImageSet/Reporter.h"
#include "Core/ImageSet/MakeImageSet.h"
#include "Core/Array/MakeFromValue.h"
#include "Core/Array/ArrayListDelete.h"
#include "Core/Array/WriteRaw.h"
#include "Core/Feature/FeatureTable.h"
#include "Core/Feature/InterestPointFeature.h"
#include "Core/Feature/DumpFeatureTableHistogram.h"

namespace Impala
{
namespace Core
{
namespace ImageSet
{

class InterestPointProc : public Listener
{
public:

    InterestPointProc(Reporter* reporter, CmdOptions& options) 
        : mInterestPointFeature(options), mOptions(options), mNoZIP(false),
          mSkipThisFolder(false)
    {
        mReporter = reporter;
        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",     "");
        options.AddOption(0, "useDetectorCache",         "name",        "");
    }

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

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

    virtual void
    HandleNewWalk(ImageSet* is, String walkType)
    {
        mWalkType = walkType;
    }

    virtual void
    HandleNewDir(ImageSet* is, int dirId)
    {
        // Make the feature data folder
        ILOG_INFO("HandleNewDir: " << dirId);
        int fileId = is->GetFirstFileId(dirId);
        is->MakeDirId("FeatureData", mInterestPointFeature.GetFeatureNameShort(),
                      fileId, false);
        mTempFilenames.clear();
        mSkipThisFolder = false;
        if(!CmdOptions::GetInstance().GetBool("override")) 
        {
            // only support skipping if override is off
            if(!mNoZIP) 
            {
                // does the ZIP exist already?
                String serverName = is->GetFilePathFeatureData
                    (mInterestPointFeature.GetFeatureName(), dirId, false, -1,
                     true, false) + ".zip";
                String temp =
                    is->GetDatabase()->GetFilePath(serverName, false, true);
                if(!temp.empty())
                {
                    mSkipThisFolder = true;
                    ILOG_WARNING("Skipping folder " << dirId <<
                                 "; ZIP file already exists");
                }
            }
            else
            {
                if(mInterestPointFeature.mClusterInput)
                {
                    // clusterInput mode
                    Feature::FeatureDefinition def = mInterestPointFeature.GetFeatureName();
                    def.AddParameter("clusterinput", "2");
                    String tableName = is->GetFilePathFeatureData
                        (def, dirId, false, -1, false, true);
                    if(!tableName.empty())
                    {
                        mSkipThisFolder = true;
                        ILOG_WARNING("Skipping folder " << dirId <<
                                     "; FeatureData:ClusterInput file already exists");
                    }
                }
                else
                {
                    // does the featuretable exist already?
                    String tableName = is->GetFilePathFeatureData
                        (mInterestPointFeature.mFeatureDefinition, dirId, false,
                         -1, false, true);
                    if(!tableName.empty())
                    {
                        mSkipThisFolder = true;
                        ILOG_WARNING("Skipping folder " << dirId <<
                                     "; FeatureData file already exists");
                    }
                }
            }
        }
    }

    virtual void
    HandleNewFile(ImageSet* is, int fileId, Array::Array2dVec3UInt8* im)
    {
        if(mSkipThisFolder)
            return;
        int dirId = is->GetDirIdOfFile(fileId);
        // silent failures - we might be reading from ImageArchives
        String fileName = is->GetAsPath(fileId);
        // create temporary output filename
        String outputFilename =
            PathJoin(GetTmpPath(), is->GetFileBase(fileId) + "." +
                     mInterestPointFeature.GetFeatureName());
        ILOG_DEBUG(" outputFilename=" << outputFilename  << "; fileId=" << fileId
                   << "; dirId=" << dirId);
        if (im == 0)
        {
            ILOG_ERROR("No image " << fileName);
            return;
        }
        
        String detectorCacheFilename = "";
        if(mOptions.GetString("useDetectorCache") != "")
        {
            detectorCacheFilename = is->GetFilePathId
                ("FeatureData", mOptions.GetString("useDetectorCache"), fileId,
                 false, false, is->GetFileBase(fileId) + "." +
                 mOptions.GetString("useDetectorCache"), false);
            ILOG_INFO("detectorCacheFilename = " << detectorCacheFilename);
        }
        if(mNoZIP) {
            outputFilename = "";
        }
        mInterestPointFeature.mClusterInputImage =
            QuidObj(is->GetQuidImage(fileId)).ToString();

        if(!mInterestPointFeature.FindInterestPoints(mOptions, im, 
                                                     is->GetQuidImage(fileId),
                                                     outputFilename,
                                                     true, detectorCacheFilename))
        {
            ILOG_ERROR("Extracting interest points/descriptors failed: "<<fileName);
        }

        if(mInterestPointFeature.mLastCodebookVectors.size() != 0)
        {
            // we have a projected feature vector
            std::vector<Vector::VectorTem<Real64>*>& featureVectors =
                mInterestPointFeature.mLastCodebookVectors;
            if(mFeatureTables.size() < featureVectors.size())
            {
                // first valid vector: allocate the table
                for(int i = mFeatureTables.size(); i < featureVectors.size(); i++)
                {
                    String name = mInterestPointFeature.GetFeatureName();
                    Feature::FeatureTable* t = new Feature::FeatureTable(name, 500,
                                                  featureVectors[i]->Size());
                    mFeatureTables.push_back(t);
                }
            }
            for(int i = 0; i < featureVectors.size(); i++)
            {
                Quid quid = is->GetQuidImage(fileId);
                mFeatureTables[i]->Add(quid, *featureVectors[i]);
            }
        }
        
        // post-processing functionality
        if(mOptions.GetString("interestPointPostProcess") != "")
        {
            String cmd = mOptions.GetString("interestPointPostProcess")
                + " " + outputFilename;
            ILOG_DEBUG("Post-processing = " << cmd);
            system(cmd.c_str());
        }
        if(!mNoZIP)
        {
            mTempFilenames.push_back(outputFilename);
        }
    }

    virtual void
    HandleDoneDir(ImageSet* is, int dirId)
    {
        if(mSkipThisFolder) return;
        int fileId = is->GetFirstFileId(dirId);

        // Feature table logic
        Feature::FeatureDefinition fdef = mInterestPointFeature.mFeatureDefinition;
        String tableName = is->GetFilePathFeatureData
            (fdef, dirId, false, -1, true, false);
        if(mFeatureTables.size() != 0)
        {
            for(int i = 0; i < mFeatureTables.size(); i++)
            {
                Feature::FeatureDefinition tempDef(fdef.AsString());
                if(i != 0)
                    tempDef.AddParameter("sub", MakeString(i));
                String tempTableName = is->GetFilePathFeatureData
                    (tempDef, dirId, false, -1, true, false);
                mFeatureTables[i]->SetInfo(mTableInfoString);
                Write(mFeatureTables[i], tempTableName, is->GetDatabase(), true);
                //for debugging:
                //Feature::DumpFeatureTableHistogram(mFeatureTables[i], tempDef, dirId);
                delete mFeatureTables[i];
                mFeatureTables[i] = 0;
            }
            mFeatureTables.clear();
        }
        
        // ZIP-file logic
        if(!mNoZIP)
        {
            String featureName = mInterestPointFeature.GetFeatureName();
            String fName = PathJoin(GetTmpPath(), "tmp-" + featureName +
                                         "-" + MakeString(dirId) + ".zip");
            String txtName = StringReplace(fName, ".zip", ".txt");
            String serverName = is->GetFilePathFeatureData
                (featureName + ".zip", dirId, false, -1, true, false);
            if (fName == String(""))
            {
                ILOG_ERROR("Empty file name");
            }
            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 != 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);
            Util::Database* database = is->GetDatabase();
            Util::IOBuffer* destination = database->GetIOBuffer
                (serverName, false, false, "tmp", 0, true);
            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 = is->GetFilePathFeatureData
                (mInterestPointFeature.mClusterInputData->GetFeatureDefinition(),
                 dirId, false, -1, true, false);
            Write(mInterestPointFeature.mClusterInputData, tableName,
                  is->GetDatabase(), true);
            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("HandleDoneDir: " << dirId);
    }


private:

    Reporter* mReporter;
    std::vector<Feature::FeatureTable*> mFeatureTables;
    Feature::InterestPointFeature mInterestPointFeature;
    CmdOptions& mOptions;
    String mCodebookSet;
    std::vector<String> mTempFilenames;
    bool mNoZIP;
    bool mSkipThisFolder;
    String mTableInfoString;
    String mWalkType;
    
    ILOG_VAR_DEC;

};

ILOG_VAR_INIT(InterestPointProc, Impala.Core.ImageSet);

} // namespace ImageSet
} // namespace Core
} // namespace Impala

#endif

---