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

---

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/Array/Mirror.h"
#include "Persistency/FeatureTableRepository.h"
#include "Core/Feature/InterestPointFeature.h"

namespace Impala
{
namespace Core
{
namespace ImageSet
{

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),
          mSkipThisFolder(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", "");
        options.AddOption(0, "useDetectorCache",         "name",    "");
        options.AddOption(0, "mirror",                   "mode",    "0");
    }

    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->GetLocator());
            mFeatureTableResult.SetFeatureDefinition(
                                mInterestPointFeature.GetFeatureDefinition());
        }
    }

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

    virtual void
    HandleNewDir(ImageSet* is, int dirId)
    {
        ILOG_INFO("HandleNewDir: " << dirId);
        int fileId = is->GetFirstFileId(dirId);
        mTempFilenames.clear();
        mSkipThisFolder = false;
        if (CmdOptions::GetInstance().GetBool("override"))
            return; // only support skipping if override is off
            
        if (!mNoZIP) 
        {
            // does the ZIP exist already?
            FeatureLocator loc(is->GetLocator(), false, false, "",
                               mInterestPointFeature.GetFeatureName(),
                               is->GetContainer(dirId));
            loc.ExtendSuffix(".zip");
            if (FeatureTableRepository().Exists(loc))
            {
                mSkipThisFolder = true;
                ILOG_WARNING("Skipping folder " << dirId <<
                             "; ZIP file already exists");
            }
            return;
        }

        if (mInterestPointFeature.mClusterInput)
        {
            // clusterInput mode
            Feature::FeatureDefinition def = mInterestPointFeature.GetFeatureName();
            def.AddParameter("clusterinput", "2");
            FeatureLocator loc(is->GetLocator(), false, false, "",
                               def.AsString(), is->GetContainer(dirId));
            if (FeatureTableRepository().Exists(loc))
            {
                mSkipThisFolder = true;
                ILOG_WARNING("Skipping folder " << dirId <<
                             "; FeatureData:ClusterInput file already exists");
            }
        }
        else
        {
            // does the featuretable exist already?
            String f = mInterestPointFeature.GetFeatureDefinition().AsString();
            FeatureLocator loc(is->GetLocator(), false, false, "", f,
                               is->GetContainer(dirId));
            if (FeatureTableRepository().Exists(loc))
            {
                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;
        }
        
        Util::IOBuffer* detectorCache = 0;
        if (mOptions.GetString("useDetectorCache") != "")
        {
            String udc = mOptions.GetString("useDetectorCache");
            String detectorCacheFilename = PathJoin
                ("FeatureData", udc, is->GetContainerDirOfFile(fileId),
                 is->GetFileBase(fileId) + "." + udc);
            FileLocator fLoc(is->GetLocator(), detectorCacheFilename);
            File file = RepositoryGetFile(fLoc, false, false);
            detectorCache = file.GetReadBuffer();
            ILOG_INFO("detectorCacheFilename = " << detectorCacheFilename);
        }
        if (mNoZIP)
        {
            outputFilename = "";
        }
        mInterestPointFeature.mClusterInputImage =
            QuidObj(is->GetQuidImage(fileId)).ToString();
            
        if (mOptions.GetInt("mirror"))
        {
            if (mOptions.GetInt("mirror") == 1)
            {
                Array::MirrorY(im, im);
            }
        }

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

        // 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);
        }
    }

    virtual void
    HandleDoneDir(ImageSet* is, int dirId)
    {
        if (mSkipThisFolder)
            return;

        FeatureLocator loc(is->GetLocator(), false, false, "", "empty",
                           is->GetContainer(dirId));
        // 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(dirId) + ".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(is->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("HandleDoneDir: " << dirId);
    }

private:

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

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(InterestPointProc, Impala.Core.ImageSet);

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

#endif

---