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

---

mainConstructCodebook.cpp

Go to the documentation of this file.

#include "Util/Channel.h"
#include "Basis/CmdOptions.h"
#include "Basis/ILog.h"
#include "Core/Matrix/KmeansClustering.h"
#include "Core/Array/ReadRaw.h"
#include "Core/Table/Write.h"
#include "Core/Feature/FeatureTable.h"
#include "Util/Database.h"
#include "Core/Database/MakeRawDataSet.h"

#include "Basis/Timer.h"

// cannot use log4cpp as library on sunos due to linker bug:
#ifdef LOG4CPP_USED
#ifdef LOG4CPPHACK
#include "Link/Log4cppLib.cpp"
#endif
#endif

#include <iostream> 
#include <fstream>
#include <sstream>

// CUDA toolkit <=2.1 really likes it when this line is here
using namespace std;

namespace Impala
{
namespace Application
{

using namespace Impala::Core::Array;
using namespace Impala::Core::Matrix;


int
mainConstructCodebook(int argc, char* argv[])
{
    CmdOptions& options = CmdOptions::GetInstance();
    options.Initialise(false, false, true);
    options.AddOption(0, "rawFile", "filename", "", 0, true);

    ILOG_VAR(Sandbox.koen.mainConstructCodebook);

    if (! options.ParseArgs(argc, argv, "dataset featurename codebookoutputname k", 4))
        return 1;

    Core::Database::RawDataSet* dataset = Core::Database::MakeRawDataSet(options.GetArg(0));
    if(!dataset)
    {
        ILOG_INFO_ONCE("failed to open dataset " << options.GetArg(0));
        return 0;
    }

    String feature = options.GetArg(1);
    String outputFilename = options.GetArg(2);
    int k = atoi(options.GetArg(3));

    String outputCheck = dataset->GetFilePath("", outputFilename, false, true);
    if(!outputCheck.empty())
    {
        ILOG_WARN("Output codebook file already exists: " << outputFilename << "; skipping...");
        return 0;
    }

    ILOG_INFO("Clustering from dataset: " << options.GetArg(0));
    ILOG_INFO("Feature: " << feature);
    ILOG_INFO("Output filename: " << outputFilename);
    ILOG_INFO("Clusters requested: " << k);

    Mat* codebook = 0;
    if(options.GetString("rawFile").empty())
    {
        Core::Feature::FeatureTable* clusterInput = 
                                    Core::Feature::FeatureTable::MakeFromDataSet(dataset, 
                                    Core::Feature::FeatureDefinition(feature),
                                    "Keyframes"); // always do keyframes for video sets
        ILOG_INFO("Clustering on: " << clusterInput->Size() << " points");
        codebook = KmeansClustering(clusterInput->GetColumn2()->GetStorage(), k);
        delete clusterInput;
    }
    else
    {
        String rawFilename = options.GetString("rawFile");
        Mat* rawData = 0;
        ReadRaw(rawData, rawFilename, dataset->GetDatabase());
        codebook = KmeansClustering(rawData, k);
        delete rawData;
    }

    Core::Feature::FeatureTable* codebookTable = new Core::Feature::FeatureTable(
                               String("kmeans-clustering_k_") + MakeString(k), k, 
                               MatNrCol(codebook));
    for(int i = 0; i < MatNrRow(codebook); i++)
    {
        Quid descr = MakeQuidCodebook(dataset->GetQuidClass(), dataset->GetSetId(), i);
        Core::Vector::VectorTem<Real64> v(MatNrCol(codebook));
        for(int j = 0; j < MatNrCol(codebook); j++)
        {
            v[j] = *MatE(codebook, i, j);
        }
        codebookTable->Add(descr, v);
    }
    delete codebook;

    dataset->MakeDir(FileNamePath(outputFilename));
    String output2 = dataset->GetFilePath("", outputFilename, true, false);
    Core::Table::Write(codebookTable, output2, dataset->GetDatabase(), true);
    delete codebookTable;
    
    return 0;
}


} // namespace Application
} // namespace Impala

int
main(int argc, char* argv[])
{
    return Impala::Application::mainConstructCodebook(argc, argv);
}

---