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

---

mainUtil.cpp

Go to the documentation of this file.

#include "Persistency/SimilarityTableSetRepository.h"
#include "Persistency/BestFileRepository.h"
#include "Persistency/SegmentationRepository.h"
#include "Persistency/FrameRepository.h"
#include "Persistency/KeywordListRepository.h"
#include "Persistency/AnnotationTableSetRepository.h"
#include "Persistency/QuidTableRepository.h"
#include "Util/SimpleMap.h"
#include "Util/StringParser.h"
#include "Core/Table/AveragePrecision.h"
#include "Core/Table/AveragePrecisionConfusion.h"
#include "Core/Table/SelectQuids.h"
#include "Core/Trec/TrecTopic.h"
#include "Core/Trec/Collection.h"
#include "Core/Trec/SearchJudge.h"
#include "Core/Array/Element/CheckNativeTypeSize.h"
#include "Core/Array/LimitCompressedImageSize.h"
#include "Core/Array/WritePng.h"
#include "Core/Array/ImageArchiveMemory.h"
#include "Core/Column/AddAssign.h"
#include "Core/Column/MulAssign.h"
#include "Core/Column/DivAssign.h"
#include "Core/Database/MakeRawDataSet.h"
#include "Core/VideoSet/Stills.h"
#include "Core/VideoSet/Keyframes.h"
#include "Core/VideoSet/Mpeg7DocWrite.h"


// since we are not using libraries:
#include "Link/ImpalaLib.cpp"

namespace Impala
{
namespace Application
{
namespace Util
{


using namespace Persistency;

void
DoCreateImageSet()
{
    typedef Core::ImageSet::ImageSet ImageSet;
    typedef Core::Array::Array2dScalarUInt8 Array2dScalarUInt8;
    typedef Core::Array::Array2dVec3UInt8 Array2dVec3UInt8;

    ILOG_VAR(Impala.Application.Util.DoCreateImageSet);
    CmdOptions& options = CmdOptions::GetInstance();
    if (options.GetNrArg() < 3)
    {
        ILOG_ERROR("Need more parameters");
        return;
    }

    String setName = options.GetArg(1);
    ImageSet imSet(setName);
    std::vector<Array2dScalarUInt8*> imList;

    String container("."); // Kill directory structure for now
    int a = 2;
    RepositoryInFileSystem& repFS = RepositoryInFileSystem::GetInstance();
    std::vector<String> input;
    String fName = options.GetArg(a);
    if (FileNameExt(fName) == "txt")
    {
        String fName = options.GetArg(a);
        FileLocator loc(fName);
        Persistency::File file = repFS.GetFile(loc, false, false);
        file.ReadStrings(input);
    }
    else
    {
        while (a < options.GetNrArg())
        {
            String fName = options.GetArg(a++);
            input.push_back(fName);
        }
    }
    ILOG_INFO("Input contains " << input.size() << " files");
    for (int i=0 ; i<input.size() ; i++)
    {
        String fName = input[i];
        String tail = FileNameTail(fName);
        //String container = FileNamePath2(fName);
        imSet.AddFile(tail, container);
        FileLocator loc(fName);
        Persistency::File file = repFS.GetFile(loc, false, false);
        if (!file.Valid())
            return;
        Impala::Util::IOBuffer* ioBuf = file.GetReadBuffer();
        Int64 bufSize = ioBuf->Size();
        Array2dScalarUInt8* bufIm =
            Core::Array::ArrayCreate<Array2dScalarUInt8>(bufSize, 1);
        Int64 nrRead = ioBuf->Read(bufIm->CPB(), ioBuf->Size());

        Core::Array::LimitCompressedImageSize(bufIm, 720);
        imList.push_back(bufIm);
    }
    ImageSetLocator setLoc(setName, options);
    ImageSetRepository().Add(setLoc, &imSet);

    ImageArchiveLocator arLoc(setLoc, false, container, "images.raw", 0);
    Core::Array::ImageArchiveMemory wrapper(&imList);
    ImageArchiveRepository().Add(arLoc, &wrapper);
    Core::Array::ArrayListDelete(&imList);
}

void
DoTrecTopicData()
{
    typedef Core::VideoSet::VideoSet VideoSet;
    typedef Core::VideoSet::Keyframes Keyframes;
    typedef Core::Array::Array2dVec3UInt8 Array2dVec3UInt8;

    ILOG_VAR(Impala.Application.Util.DoTrecTopicData);
    CmdOptions& options = CmdOptions::GetInstance();
    if (options.GetNrArg() < 4)
    {
        ILOG_ERROR("Need more parameters");
        return;
    }
    VideoSet* sVidSet = Core::VideoSet::MakeVideoSet(options.GetArg(1));
    Core::Trec::TrecTopic topic(options.GetArg(2));
    ILOG_DEBUG("Generating data sets");
    String dSetName = topic.GenerateDataSets(options.GetArg(3));
    bool doVideo = true;
    if (options.GetNrArg() > 4)
        if (options.GetArg(4) == "novideo")
            doVideo = false;
    VideoSet* dVidSet = Core::VideoSet::MakeVideoSet(dSetName);
    KeyframesLocator kLoc(dSetName, "keyframes", options);
    Keyframes* keyframes = KeyframesRepository().Get(kLoc, dVidSet);
    int curKey = -1;
    for (int i=0 ; i<topic.NrTopic() ; i++)
    //for (int i=0 ; i<1 ; i++)
    {
        for (int j=0 ; j<topic.GetNrExamples(i) ; j++)
        {
            curKey++;
            ILOG_INFO("nr " << curKey << " of " << keyframes->GetNrKeyframes());
            ILOG_DEBUG("topic = " << i << ", example = " << j);
            ILOG_DEBUG("topic = " << topic.GetTopicNum(i));
            String vidName = topic.GetVideoExampleSrcFile(i, j);
            ILOG_DEBUG("vidName = " << vidName);
            int vidId = sVidSet->GetFileId(vidName);
            if (vidId == -1)
            {
                ILOG_ERROR("Unable to locate video " << vidName);
                continue;
            }
            Core::Stream::RgbDataSrc* src = sVidSet->GetVideo(vidId);
            if (src == 0)
            {
                ILOG_ERROR("Unable to locate video " << vidName);
                continue;
            }
            int startFr = topic.GetVideoExampleStartFrame(i, j);
            int endFr = topic.GetVideoExampleEndFrame(i, j);
            src->GotoFrame((startFr + endFr) / 2);
            Array2dVec3UInt8* wrapper = Core::Array::ArrayCreate<Array2dVec3UInt8>
                (src->FrameWidth(), src->FrameHeight(), 0, 0, src->DataPtr(),
                 true);
            int frameNr = keyframes->GetFrameNr(curKey);
            String container = dVidSet->GetContainerFile(curKey);
            Persistency::FrameLocator loc(dVidSet->GetLocator(), container,
                                          frameNr, ".png");
            Persistency::FrameRepository().Add(loc, wrapper);
            delete wrapper;
            delete src;

            if (!doVideo)
                continue;

            // get video clip
            String exeName("mencoder -oac copy -ovc copy -of mpeg");
            Impala::Util::StringParser pStart(topic.GetVideoExampleStart(i, j));
            int startM = pStart.GetInt('m');
            pStart.AdvanceP();
            int startS = pStart.GetInt('.');
            pStart.AdvanceP();
            int startF = pStart.GetInt('s');
            String duration = topic.GetVideoExampleDuration(i, j);
            String vidFileName = sVidSet->GetResolvedVideoPath(vidId);
            char sysBuf[1024];
            sprintf(sysBuf, "%s %s -o %s -ss %d:%d.%d -endpos %s",
                    exeName.c_str(), vidFileName.c_str(),
                    topic.GetVideoExampleName(i, j, true).c_str(),
                    startM, startS, startF, duration.c_str());

            for (int c=0 ; c<1024 ; c++)
                if (sysBuf[c] == '/')
                    sysBuf[c] = '\\';
                
            ILOG_DEBUG("sysbuf = [" << sysBuf << "]");
            int sysRes = system(sysBuf);
            if (sysRes != 0)
            {
                ILOG_ERROR("system ["  << sysBuf << "]");
                return;
            }
        }
    }
    delete sVidSet;
    delete dVidSet;
}

void
DoTrecSet()
{
    ILOG_VAR(Impala.Application.Util.DoTrecSet);
    CmdOptions& options = CmdOptions::GetInstance();
    if (options.GetNrArg() != 6)
    {
        ILOG_ERROR("Need 6 arguments");
        return;
    }
    String setName = options.GetArg(1);
    String use = options.GetArg(2);
    String collName = options.GetArg(3);
    String clipsKeys = options.GetArg(4);
    if (clipsKeys == "nil")
        clipsKeys = "";
    bool vidSetOnly = StringToBool(options.GetArg(5));
    Persistency::FileLocator loc(collName);
    Core::Trec::Collection coll(loc);
    //coll.WriteTo(std::cout);
    Locator setLoc(setName, options);
    coll.WriteVideoSet(setLoc, use, clipsKeys, vidSetOnly);
}

void
DoTrecJudge()
{
    ILOG_VAR(Impala.Application.Util.DoTrecJudge);
    CmdOptions& options = CmdOptions::GetInstance();
    if (options.GetNrArg() < 4)
    {
        ILOG_ERROR("Need at least 4 arguments");
        return;
    }
    String judgeFile = options.GetArg(1);
    String shotFile = options.GetArg(2);
    String topic = options.GetArg(3);
    Core::Trec::SearchJudge judge(judgeFile);
    judge.Stats();
    std::vector<String> shots;
    Persistency::File file = RepositoryGetFile(shotFile, false, false);
    file.ReadStrings(shots);

    Real64 infAP = judge.Judge(topic, shots);
    std::cout << "infAP = " << infAP << std::endl;
}

void
DoTrecDropped()
{
    typedef Core::VideoSet::VideoSet VideoSet;
    typedef Core::VideoSet::Segmentation Segmentation;

    ILOG_VAR(Impala.Application.Util.DoTrecDropped);
    CmdOptions& options = CmdOptions::GetInstance();
    if (options.GetNrArg() < 2)
    {
        ILOG_ERROR("Need at least 2 arguments");
        return;
    }
    String setName = options.GetArg(1);
    String dropName = options.GetArg(2);

    VideoSet* vidSet = Core::VideoSet::MakeVideoSet(setName);
    SegmentationLocator sLoc(setName, "segmentation", options);
    Segmentation* seg = SegmentationRepository().Get(sLoc, vidSet);
    ILOG_INFO("nrVideos = " << seg->GetNrVideos());

    Persistency::FileLocator fLoc(vidSet->GetLocator(), dropName);
    typedef Persistency::RepositoryInFileSystem FS;
    Persistency::File file = FS::GetInstance().GetFile(fLoc, false, false);
    std::vector<String> dropped;
    file.ReadStrings(dropped);
    std::cout << "dropped size = " << dropped.size() << std::endl;

    int nrFiles = 0;
    int nrShots = 0;
    std::vector<int> ids;
    for (int i=0 ; i<dropped.size() ; i++)
    {
        int fileId = vidSet->GetFileId(dropped[i]);
        if (fileId == -1)
            continue;
        nrFiles++;
        nrShots += seg->GetNrShotsVideo(fileId);
        ids.push_back(fileId);
    }
    std::cout << "dropped " << nrFiles << " files and " << nrShots << " shots"
              << std::endl;
    std::sort(ids.begin(), ids.end());
    for (int i=0 ; i<ids.size() ; i++)
        std::cout << ids[i] << std::endl;
    delete seg;
    delete vidSet;
}

void
DoTrecMissing()
{
    typedef Core::VideoSet::VideoSet VideoSet;
    typedef Core::VideoSet::Keyframes Keyframes;
    typedef Core::Table::QuidTable QuidTable;

    ILOG_VAR(Impala.Application.Util.DoTrecMissing);
    CmdOptions& options = CmdOptions::GetInstance();
    if (options.GetNrArg() < 2)
    {
        ILOG_ERROR("Need at least 2 arguments");
        return;
    }
    String setName = options.GetArg(1);
    String missingName = options.GetArg(2);

    VideoSet* vidSet = Core::VideoSet::MakeVideoSet(setName);
    KeyframesLocator kLoc(setName, "keyframes", options);
    Keyframes* keyframes = KeyframesRepository().Get(kLoc, vidSet);

    Persistency::FileLocator fLoc(vidSet->GetLocator(), missingName);
    typedef Persistency::RepositoryInFileSystem FS;
    Persistency::File file = FS::GetInstance().GetFile(fLoc, false, false);
    std::vector<String> missing;
    file.ReadStrings(missing);
    std::cout << "missing size = " << missing.size() << std::endl;

    QuidTable* quids = new QuidTable();
    int nrFiles = 0;
    int nrShots = 0;
    for (int i=0 ; i<missing.size() ; i++)
    {
        int keyId = keyframes->GetFrameId(missing[i]);
        if (keyId == -1)
        {
            ILOG_ERROR("Could find keyframe " << missing[i]);
            continue;
        }
        Quid q = keyframes->GetQuidFrame(keyId);
        quids->Add(q);
    }
    ILOG_INFO("quid size = " << quids->Size());

    QuidTableLocator qLoc(vidSet->GetLocator(), "VideoIndex",
                          FileNameBase(missingName) + ".tab");
    QuidTableRepository().Add(qLoc, quids);
    delete quids;
    delete keyframes;
    delete vidSet;
}

void
DoExportShotMpeg7()
{
    typedef Core::VideoSet::VideoSet VideoSet;
    typedef Core::VideoSet::Segmentation Segmentation;
    typedef Core::VideoSet::Keyframes Keyframes;
    typedef Core::VideoSet::Mpeg7Doc Mpeg7Doc;

    ILOG_VAR(Impala.Application.Util.DoExportShotMpeg7);
    CmdOptions& options = CmdOptions::GetInstance();
    if (options.GetNrArg() < 5)
    {
        ILOG_ERROR("Need more parameters");
        return;
    }
    String videoSetName = options.GetArg(1);
    int fractions = Impala::atol(options.GetArg(2));
    if ((fractions != 25) && (fractions != 30000))
        ILOG_WARN("Never tried fractions = " << fractions);
    bool generateShotNames = Impala::atol(options.GetArg(3));
    bool withKeyframes = Impala::atol(options.GetArg(4));

    VideoSet* vidSet = Core::VideoSet::MakeVideoSet(videoSetName);
    SegmentationLocator sLoc(videoSetName, "segmentation", options);
    Segmentation* segmentation = SegmentationRepository().Get(sLoc, vidSet);
    KeyframesLocator kLoc(videoSetName, "keyframes", options);
    Keyframes* keyframes = KeyframesRepository().Get(kLoc, vidSet);
    for (int v=0 ; v<vidSet->NrFiles() ; v++)
    {
        String fileName = vidSet->GetFile(v);
        ILOG_INFO("doing file " << fileName);
        String id = fileName;
        int nrFrames = segmentation->GetNrFramesVideo(v);
        int frameRateNum = 0;
        int frameRateDen = 0;
        if (fractions == 0)
        {
            Core::Stream::RgbDataSrc* rgbSrc = vidSet->GetVideo(v);
            if ((!rgbSrc) || (rgbSrc->FrameRateNum() < 0)
                || (rgbSrc->FrameRateDen() < 0))
            {
                ILOG_ERROR("Need src with known frame rate");
                continue;
            }
            frameRateNum = rgbSrc->FrameRateNum();
            frameRateDen = rgbSrc->FrameRateDen();
            if (rgbSrc)
                delete rgbSrc;
        }
        Mpeg7Doc mp7(id, fileName, nrFrames, fractions, withKeyframes, "", "",
                     frameRateNum, frameRateDen);
        for (int s=0 ; s<segmentation->GetNrShotsVideo(v) ; s++)
        {
            int shot = segmentation->GetFirstShotVideo(v) + s;
            String shotName = (generateShotNames)
                ? "shot" + MakeString(v+1) + "_" + MakeString(s+1)
                : segmentation->GetName(shot);
            if (withKeyframes)
            {
                std::vector<String> names;
                std::vector<int> frames;
                for (int k=0 ; k<keyframes->GetNrKeyframesShot(shot) ; k++)
                {
                    int key = keyframes->GetFirstKeyframeShot(shot) + k;
                    String keyName = (generateShotNames)
                        ? "shot"+MakeString(v+1)+"_"+MakeString(s+1)+"_RKF"
                        : Impala::FileNameBase(keyframes->GetName(key));
                    names.push_back(keyName);
                    frames.push_back(keyframes->GetFrameNr(key));
                }
                mp7.AddShot(shotName, segmentation->GetStart(shot),
                            segmentation->GetEnd(shot), names, frames);
            }
            else
            {
                mp7.AddShot(shotName, segmentation->GetStart(shot),
                            segmentation->GetEnd(shot));
            }
        }
        Core::VideoSet::Mpeg7DocWrite(&mp7, vidSet, v);
    }
}

/* Create CA annotations from two datasets, one with positives (idash_annotator)
   and one with only negative examples.
   The latter is based on the middle keyframe of videos from the Ewijk set.
 */
void
DoCreateCaAnno()
{
    typedef Core::VideoSet::VideoSet VideoSet;
    typedef Core::VideoSet::Keyframes Keyframes;
    typedef Core::Table::AnnotationTable AnnotationTable;

    ILOG_VAR(Impala.Application.Util.DoCreateCaAnno);

    Core::Table::AnnotationTableSet tSet;
    AnnotationTable* tab = new AnnotationTable("CaMaterial", 0);
    tSet.Add(tab);

    VideoSet* vidSetPosi = Core::VideoSet::MakeVideoSet("idash_annotator.txt");
    KeyframesLocator kLocPosi(vidSetPosi->GetLocator(), "keyframes");
    Keyframes* keyframesPosi = KeyframesRepository().Get(kLocPosi, vidSetPosi);
    for (int v=0 ; v<vidSetPosi->NrFiles() ; v++)
    //for (int v=0 ; v<2 ; v++)
    {
        int nrKeys = keyframesPosi->GetNrKeyframesVideo(v);
        int keyId = keyframesPosi->GetFirstKeyframeVideo(v) + nrKeys - 1;
        Quid q = keyframesPosi->GetQuidFrame(keyId);
        tab->AddPositive(q);
    }

    //VideoSet* vidSetNega = Core::VideoSet::MakeVideoSet("idashtest4.txt");
    VideoSet* vidSetNega = Core::VideoSet::MakeVideoSet("EwijkMID.txt");
    KeyframesLocator kLocNega(vidSetNega->GetLocator(), "keyframes");
    Keyframes* keyframesNega = KeyframesRepository().Get(kLocNega, vidSetNega);
    for (int v=0 ; v<vidSetNega->NrFiles() ; v++)
    //for (int v=0 ; v<2 ; v++)
    {
        int nrKeys = keyframesNega->GetNrKeyframesVideo(v);
        int keyId = keyframesNega->GetFirstKeyframeVideo(v) + nrKeys - 1;
        Quid q = keyframesNega->GetQuidFrame(keyId);
        tab->AddNegative(q);
    }

    AnnotationTableSetLocator aLoc(vidSetPosi->GetLocator(), QUID_CLASS_FRAME,
                                   "conceptsAnnotator.txt");
    AnnotationTableSetRepository().Add(aLoc, &tSet);
    delete keyframesPosi;
    delete vidSetPosi;
    delete keyframesNega;
    delete vidSetNega;
}

/* Export .truth files as Mpeg7 files. */
void
DoExportAnnoMpeg7()
{
    typedef Core::VideoSet::VideoSet VideoSet;
    typedef Core::VideoSet::Segmentation Segmentation;
    typedef Core::VideoSet::Keyframes Keyframes;
    typedef Core::VideoSet::Mpeg7Doc Mpeg7Doc;

    ILOG_VAR(Impala.Application.Util.DoExportAnnoMpeg7);
    CmdOptions& options = CmdOptions::GetInstance();
    if (options.GetNrArg() < 5)
    {
        ILOG_ERROR("Need more parameters");
        return;
    }
    String videoSetName = options.GetArg(1);
    int fractions = Impala::atol(options.GetArg(2));
    if ((fractions != 25) && (fractions != 30000))
        ILOG_WARN("Never tried fractions = " << fractions);
    String conceptSet = options.GetArg(3);
    String anno = options.GetArg(4);
    bool hasKeyframes = false;
    if (anno == "hasKeyframes")
    {
        hasKeyframes = true;
    }
    else if (anno != "hasShots")
    {
        ILOG_ERROR("Argument should be hasShots or hasKeyframes");
        return;
    }

    VideoSet* vidSet = Core::VideoSet::MakeVideoSet(videoSetName);
    SegmentationLocator sLoc(videoSetName, "segmentation", options);
    Segmentation* segmentation = SegmentationRepository().Get(sLoc, vidSet);
    KeyframesLocator kLoc(videoSetName, "keyframes", options);
    Keyframes* keyframes = KeyframesRepository().Get(kLoc, vidSet);
    Persistency::KeywordListLocator loc(vidSet->GetLocator(), conceptSet);
    Core::Table::KeywordList concepts =
        *(Persistency::KeywordListRepository().Get(loc));
    for (int c=0 ; c<concepts.size() ; c++)
    {
        ILOG_INFO("doing concept " << concepts[c]);
        ILOG_NDC_PUSH(concepts[c]);
        String fName = "Annotations/groundtruth/" + concepts[c] + ".truth";
        Persistency::FileLocator fLoc(vidSet->GetLocator(), fName);
        Persistency::File file = RepositoryGetFile(fLoc, false, false);
        std::vector<String> annos;
        file.ReadStrings(annos);
        std::sort(annos.begin(), annos.end());
        for (int v=0 ; v<vidSet->NrFiles() ; v++)
        {
            String vidFile = vidSet->GetFile(v);
            int nrFrames = segmentation->GetNrFramesVideo(v);
            int frameRateNum = 0;
            int frameRateDen = 0;
            if (fractions == 0)
            {
                Core::Stream::RgbDataSrc* rgbSrc = vidSet->GetVideo(v);
                if ((!rgbSrc) || (rgbSrc->FrameRateNum() < 0)
                    || (rgbSrc->FrameRateDen() < 0))
                {
                    ILOG_ERROR("Need src with known frame rate");
                    continue;
                }
                frameRateNum = rgbSrc->FrameRateNum();
                frameRateDen = rgbSrc->FrameRateDen();
                if (rgbSrc)
                    delete rgbSrc;
            }
            Mpeg7Doc mp7(vidFile, vidFile, nrFrames, fractions, false,
                         conceptSet, concepts[c], frameRateNum, frameRateDen);
            if (hasKeyframes)
            {
                for (int k=0 ; k<keyframes->GetNrKeyframesVideo(v) ; k++)
                {
                    int keyId = keyframes->GetFirstKeyframeVideo(v) + k;
                    String keyName = FileNameBase(keyframes->GetName(keyId));
                    int frameNr = keyframes->GetFrameNr(keyId);
                    double relevance = 0;
                    if (find(annos.begin(),annos.end(),keyName) != annos.end())
                        relevance = 1;
                    mp7.AddAnnotation(concepts[c], keyName, frameNr, frameNr,
                                      relevance, 1);
                }
            }
            else
            {
                for (int s=0 ; s<segmentation->GetNrShotsVideo(v) ; s++)
                {
                    int shotId = segmentation->GetFirstShotVideo(v) + s;
                    String shotName = segmentation->GetName(shotId);
                    double relevance = 0;
                    if (find(annos.begin(),annos.end(),shotName) != annos.end())
                        relevance = 1;
                    int firstKey = keyframes->GetFirstKeyframeShot(shotId);
                    int nrKey = keyframes->GetNrKeyframesShot(shotId);
                    for (int k=firstKey ; k<firstKey+nrKey ; k++)
                    {
                        if (!keyframes->IsRKF(k))
                            continue;
                        String keyName = FileNameBase(keyframes->GetName(k));
                        int frameNr = keyframes->GetFrameNr(k);
                        mp7.AddAnnotation(concepts[c], keyName, frameNr,
                                          frameNr, relevance, 1);
                    }
                }
            }
            Core::VideoSet::Mpeg7DocWrite(&mp7, vidSet, v);
        }
        ILOG_NDC_POP;
    }
}

/* Import .truth files with [N]RKF as AnnotationTableSet.
 * Note: does positives only!
 */
void
DoImportAnnoTruth()
{
    typedef Core::VideoSet::VideoSet VideoSet;
    typedef Core::VideoSet::Keyframes Keyframes;
    typedef Core::Table::AnnotationTableSet AnnotationTableSet;
    typedef Core::Table::AnnotationTable AnnotationTable;

    ILOG_VAR(Impala.Application.Util.DoImportAnnoTruth);
    CmdOptions& options = CmdOptions::GetInstance();
    if (options.GetNrArg() < 4)
    {
        ILOG_ERROR("Need more parameters");
        return;
    }
    String videoSetName = options.GetArg(1);
    String conceptSet = options.GetArg(2);
    String maskSet = options.GetArg(3);

    VideoSet* vidSet = Core::VideoSet::MakeVideoSet(videoSetName);
    KeyframesLocator kLoc(vidSet->GetLocator(), "keyframes");
    Keyframes* keyframes = KeyframesRepository().Get(kLoc, vidSet);
    Persistency::KeywordListLocator loc(vidSet->GetLocator(), conceptSet);
    Core::Table::KeywordList concepts =
        *(Persistency::KeywordListRepository().Get(loc));

    typedef Persistency::RepositoryInFileSystem FS;
    Persistency::FileLocator mLoc(vidSet->GetLocator(), maskSet);
    Persistency::File mFile = FS::GetInstance().GetFile(mLoc, false, false);
    std::vector<String> mask;
    mFile.ReadStrings(mask);
    if (mask.size() == 0)
        ILOG_WARN("mask is empty");

    AnnotationTableSet tSet;
    for (int c=0 ; c<concepts.size() ; c++)
    {
        ILOG_INFO("doing concept " << concepts[c]);
        ILOG_NDC_PUSH(concepts[c]);
        AnnotationTable* tab = new AnnotationTable(concepts[c], 0);
        tSet.Add(tab);

        String fName = "Annotations/groundtruth/" + conceptSet + "/" +
            concepts[c] + ".truth";
        Persistency::FileLocator fLoc(vidSet->GetLocator(), fName);
        Persistency::File file = FS::GetInstance().GetFile(fLoc, false, true);
        if (!file.Valid())
        {
            ILOG_INFO("No truth file for " << concepts[c]);
            ILOG_NDC_POP;
            continue;
        }
            
        std::vector<String> annos;
        file.ReadStrings(annos);
        for (int i=0 ; i<annos.size() ; i++)
        {
            if (find(mask.begin(), mask.end(), annos[i]) == mask.end())
            {
                ILOG_DEBUG("not in mask, skipping");
                continue;
            }

            int keyId = keyframes->GetFrameId(annos[i] + ".jpg");
            if (keyId == -1)
            {
                // In trec2005 some NRKF seem to refer to the same frame as RKF
                String h1 = StringHead(annos[i], '_', true);
                String t = StringTail(annos[i], '_', false);
                String h2 = StringHead(t, '_', true);
                String rkf = h1 + h2 + "RKF";
                keyId = keyframes->GetFrameId(rkf + ".jpg");
            }
            if (keyId == -1)
            {
                ILOG_ERROR("Don't know " << annos[i]);
            }
            else
            {
                Quid q = keyframes->GetQuidFrame(keyId);
                tab->AddPositive(q);
            }
        }
        ILOG_NDC_POP;
    }

    AnnotationTableSetLocator aLoc(vidSet->GetLocator(), QUID_CLASS_FRAME,
                                   conceptSet);
    AnnotationTableSetRepository().Add(aLoc, &tSet);
    delete keyframes;
    delete vidSet;
}

/* Export frames from AnnotationTableSet as .truth files with [N]RKF. */
void
DoExportAnnoTruth()
{
    typedef Core::VideoSet::VideoSet VideoSet;
    typedef Core::VideoSet::Keyframes Keyframes;
    typedef Core::Table::AnnotationTableSet AnnotationTableSet;
    typedef Core::Table::AnnotationTable AnnotationTable;
    typedef Core::Table::QuidTable QuidTable;

    ILOG_VAR(Impala.Application.Util.DoExportAnnoTruth);
    CmdOptions& options = CmdOptions::GetInstance();
    if (options.GetNrArg() < 3)
    {
        ILOG_ERROR("Need more parameters");
        return;
    }
    String videoSetName = options.GetArg(1);
    String conceptSet = options.GetArg(2);

    VideoSet* vidSet = Core::VideoSet::MakeVideoSet(videoSetName);
    KeyframesLocator kLoc(vidSet->GetLocator(), "keyframes");
    Keyframes* keyframes = KeyframesRepository().Get(kLoc, vidSet);
    AnnotationTableSetLocator aLoc(vidSet->GetLocator(), QUID_CLASS_FRAME,
                                   conceptSet);
    AnnotationTableSet* tSet = AnnotationTableSetRepository().Get(aLoc);
    if (tSet == 0)
        return;

    for (int t=0 ; t<tSet->Size() ; t++)
    {
        AnnotationTable* tab = tSet->GetTable(t);
        tab->DumpSummary();
        QuidTable* quids = tab->GetPositive();
        std::vector<String> annos;
        for (int i=0 ; i<quids->Size() ; i++)
        {
            Quid q = quids->Get1(i);
            int id = keyframes->GetFrameId(q);
            if (id != -1)
            {
                String name = keyframes->GetName(id);
                annos.push_back(FileNameBase(name));
            }
        }
        delete quids;

        String fName = "Annotations/groundtruth/" + conceptSet + "/" +
            tab->GetLabel() + ".truth";
        Persistency::FileLocator fLoc(vidSet->GetLocator(), fName);
        typedef Persistency::RepositoryInFileSystem FS;
        Persistency::File file = FS::GetInstance().GetFile(fLoc, true, false);
        ILOG_INFO("Writing to " << file.GetPath());
        file.WriteStrings(annos);
    }
    delete tSet;
    delete keyframes;
    delete vidSet;
}

/* import .ann files (from IMAG).
One line looks like this:

RYY MCG-ICT-CAS Airplane BG_12460 TRECVID2007_1/shot1_100_RKF N [S]
==
Annotation_Person Organizer Concept Videoname Keyframename Judgment(Positive/Negative) Sign(S)

The optional S indicates that the annotator was not sure whether it is Pos/Neg
*/
void
DoImportAnnotations()
{
    typedef Core::VideoSet::VideoSet VideoSet;
    typedef Core::VideoSet::Segmentation Segmentation;
    typedef Core::VideoSet::Keyframes Keyframes;
    typedef Core::VideoSet::Mpeg7Doc Mpeg7Doc;

    ILOG_VAR(Impala.Application.Util.DoImportAnnotations);
    CmdOptions& options = CmdOptions::GetInstance();
    if (options.GetNrArg() < 4)
    {
        ILOG_ERROR("Need more parameters");
        return;
    }
    String videoSetName = options.GetArg(1);
    int fractions = Impala::atol(options.GetArg(2));
    if ((fractions != 25) && (fractions != 30000))
        ILOG_WARN("Never tried fractions = " << fractions);
    String conceptSet = options.GetArg(3);

    VideoSet* vidSet = Core::VideoSet::MakeVideoSet(videoSetName);
    SegmentationLocator sLoc(videoSetName, "segmentation", options);
    Segmentation* segmentation = SegmentationRepository().Get(sLoc, vidSet);
    KeyframesLocator kLoc(videoSetName, "keyframes", options);
    Keyframes* keyframes = KeyframesRepository().Get(kLoc, vidSet);
    FileLocator fLoc(conceptSet);
    typedef Persistency::RepositoryInFileSystem FS;
    Persistency::File file = FS::GetInstance().GetFile(fLoc, false, false);
    std::vector<String> concepts;
    file.ReadStrings(concepts);
    String path = FileNamePath(conceptSet) + "/";
    conceptSet = FileNameTail(conceptSet);
    for (int c=0 ; c<concepts.size() ; c++)
    {
        ILOG_INFO("doing concept " << concepts[c]);
        ILOG_NDC_PUSH(concepts[c]);
        String fName = path + concepts[c] + ".ann";
        std::vector<String> lines;
        fLoc = FileLocator(fName);
        file = FS::GetInstance().GetFile(fLoc, false, false);
        file.ReadStrings(lines);
        int curVidId = -1;
        Mpeg7Doc* curDoc = 0;
        for (int l=0 ; l<lines.size() ; l++)
        {
            Impala::Util::StringParser p(lines[l]);
            String s = p.GetString(' '); // Person
            s = p.GetString(' '); // Organizer
            s = p.GetString(' '); // Concept
            s = p.GetString(' '); // Videoname
            s = Impala::FileNameTail(p.GetString(' ')); // Keyframename
            int key = keyframes->GetFrameId(s + ".jpg");
            if (key == -1)
            {
                ILOG_ERROR("Unable to find keyframe " << s);
                continue;
            }
            double relevance = (p.GetString(' ', false) == "P") ? 1.0 : 0.0;
            double confidence = 1.0;
            if (!p.TheEnd() && (p.GetString(' ', false) == "S"))
                relevance = 0.5; // open for debate :-)
            
            if (keyframes->GetVideoId(key) != curVidId)
            {   // new video
                if (curDoc)
                {
                    Core::VideoSet::Mpeg7DocWrite(curDoc, vidSet, curVidId);
                    delete curDoc;
                    curDoc = 0;
                }
                curVidId = keyframes->GetVideoId(key);
                String vidFile = vidSet->GetFile(curVidId);
                int nrFrames = segmentation->GetNrFramesVideo(curVidId);
                int frameRateNum = 0;
                int frameRateDen = 0;
                if (fractions == 0)
                {
                    Core::Stream::RgbDataSrc* rgbSrc = vidSet->GetVideo(curVidId);
                    if ((!rgbSrc) || (rgbSrc->FrameRateNum() < 0)
                        || (rgbSrc->FrameRateDen() < 0))
                    {
                        ILOG_ERROR("Need src with known frame rate");
                        continue;
                    }
                    frameRateNum = rgbSrc->FrameRateNum();
                    frameRateDen = rgbSrc->FrameRateDen();
                    if (rgbSrc)
                        delete rgbSrc;
                }
                curDoc = new Mpeg7Doc(vidFile, vidFile, nrFrames, fractions,
                                      false, conceptSet, concepts[c],
                                      frameRateNum, frameRateDen);
            }
            String name = FileNameBase(keyframes->GetName(key));
            int frameNr = keyframes->GetFrameNr(key);
            curDoc->AddAnnotation(concepts[c], name, frameNr, frameNr,
                                  relevance, confidence);
        }
        if (curDoc)
        {
            Core::VideoSet::Mpeg7DocWrite(curDoc, vidSet, curVidId);
            delete curDoc;
        }
        ILOG_NDC_POP;
    }
}

/* import .1 (positive shot1_1) and .0 (negative shot1_1) files from Ork
   Files are named after rels.
*/
void
DoImportAnnotationsOrk()
{
    typedef Core::VideoSet::VideoSet VideoSet;
    typedef Core::VideoSet::Segmentation Segmentation;
    typedef Core::VideoSet::Keyframes Keyframes;
    typedef Core::VideoSet::Mpeg7Doc Mpeg7Doc;

    ILOG_VAR(Impala.Application.Util.DoImportAnnotations);
    CmdOptions& options = CmdOptions::GetInstance();
    if (options.GetNrArg() < 6)
    {
        ILOG_ERROR("Need more parameters");
        return;
    }
    String videoSetName = options.GetArg(1);
    int fractions = Impala::atol(options.GetArg(2));
    if ((fractions != 25) && (fractions != 30000))
        ILOG_WARN("Never tried fractions = " << fractions);
    String conceptSet = options.GetArg(3);
    String mappingName = options.GetArg(4);
    String inputPath = options.GetArg(5);

    VideoSet* vidSet = Core::VideoSet::MakeVideoSet(videoSetName);
    SegmentationLocator sLoc(videoSetName, "segmentation", options);
    Segmentation* segmentation = SegmentationRepository().Get(sLoc, vidSet);
    KeyframesLocator kLoc(videoSetName, "keyframes", options);
    Keyframes* keyframes = KeyframesRepository().Get(kLoc, vidSet);

    Persistency::KeywordListLocator loc(vidSet->GetLocator(), conceptSet);
    Core::Table::KeywordList concepts =
        *(Persistency::KeywordListRepository().Get(loc));

    std::vector<String> lines;
    Impala::Util::SimpleMap<String, String> conceptMapping;
    FileLocator fLoc(mappingName);
    typedef Persistency::RepositoryInFileSystem FS;
    Persistency::File file = FS::GetInstance().GetFile(fLoc, false, false);
    file.ReadStrings(lines);

    for (int i=0 ; i<lines.size() ; i++)
    {
        Impala::Util::StringParser p(lines[i]);
        String topic = p.GetString(' ');
        String concept = p.GetString(' ', false);
        std::cout << topic << " = " << concept << std::endl;
        conceptMapping.Add(concept, topic);
    }
    for (int c=0 ; c<concepts.size() ; c++)
    {
        ILOG_INFO("doing concept " << concepts[c]);
        ILOG_NDC_PUSH(concepts[c]);

        String topic;
        if (!conceptMapping.Get(concepts[c], topic))
        {
            ILOG_ERROR("no topic for " << concepts[c]);
            ILOG_NDC_POP;
            continue;
        }

        std::vector<String> posAnnos;
        String fName = inputPath + "." + topic + ".1";
        FileLocator posLoc(vidSet->GetLocator(), fName);
        file = FS::GetInstance().GetFile(posLoc, false, false);
        file.ReadStrings(posAnnos);

        std::vector<String> negAnnos;
        fName = inputPath + "." + topic + ".0";
        FileLocator negLoc(vidSet->GetLocator(), fName);
        file = FS::GetInstance().GetFile(negLoc, false, false);
        file.ReadStrings(negAnnos);
        if ((posAnnos.size() == 0) || (negAnnos.size() == 0))
        {
            ILOG_ERROR("missing input for " << concepts[c]);
            ILOG_NDC_POP;
            continue;
        }

        std::sort(posAnnos.begin(), posAnnos.end());
        std::sort(negAnnos.begin(), negAnnos.end());
        for (int v=0 ; v<vidSet->NrFiles() ; v++)
        {
            String vidFile = vidSet->GetFile(v);
            int nrFrames = segmentation->GetNrFramesVideo(v);
            int frameRateNum = 0;
            int frameRateDen = 0;
            if (fractions == 0)
            {
                Core::Stream::RgbDataSrc* rgbSrc = vidSet->GetVideo(v);
                if ((!rgbSrc) || (rgbSrc->FrameRateNum() < 0)
                    || (rgbSrc->FrameRateDen() < 0))
                {
                    ILOG_ERROR("Need src with known frame rate");
                    continue;
                }
                frameRateNum = rgbSrc->FrameRateNum();
                frameRateDen = rgbSrc->FrameRateDen();
                if (rgbSrc)
                    delete rgbSrc;
            }
            Mpeg7Doc mp7(vidFile, vidFile, nrFrames, fractions, false,
                         conceptSet, concepts[c], frameRateNum, frameRateDen);

            for (int s=0 ; s<segmentation->GetNrShotsVideo(v) ; s++)
            {
                int shotId = segmentation->GetFirstShotVideo(v) + s;
                String shotName = segmentation->GetName(shotId);
                double relevance = -1;
                if (find(posAnnos.begin(), posAnnos.end(), shotName) !=
                    posAnnos.end())
                {
                    relevance = 1;
                }
                else if (find(negAnnos.begin(), negAnnos.end(), shotName) !=
                         negAnnos.end())
                {
                    relevance = 0;
                }
                if (relevance < 0)
                    continue;
                int key = keyframes->GetShotRKF(shotId);

                String keyName = FileNameBase(keyframes->GetName(key));
                int frameNr = keyframes->GetFrameNr(key);
                mp7.AddAnnotation(concepts[c], keyName, frameNr, frameNr,
                                  relevance, 1);
            }
            if (mp7.HasAnnotations())
                Core::VideoSet::Mpeg7DocWrite(&mp7, vidSet, v);
        }
        ILOG_NDC_POP;
    }
}

/* Import annotations from active learning (in Cees' format?).
 * Annotations are on RKF's and stored in Annotations/from_active.
 * Positives are stored as shot1_1 in file concept/shots_bookmarked.txt and
 * negatives are stored in concept/shots_bookmarked_negative.txt.
 */
void
DoImportAnnotationsActive()
{
    typedef Core::VideoSet::VideoSet VideoSet;
    typedef Core::VideoSet::Segmentation Segmentation;
    typedef Core::VideoSet::Keyframes Keyframes;
    typedef Core::VideoSet::Mpeg7Doc Mpeg7Doc;

    ILOG_VAR(Impala.Application.Util.DoImportAnnotationsActive);
    CmdOptions& options = CmdOptions::GetInstance();
    if (options.GetNrArg() < 4)
    {
        ILOG_ERROR("Need more parameters");
        return;
    }
    String videoSetName = options.GetArg(1);
    int fractions = Impala::atol(options.GetArg(2));
    if ((fractions != 25) && (fractions != 30000))
        ILOG_WARN("Never tried fractions = " << fractions);
    String conceptSet = options.GetArg(3);

    VideoSet* vidSet = Core::VideoSet::MakeVideoSet(videoSetName);
    SegmentationLocator sLoc(videoSetName, "segmentation", options);
    Segmentation* segmentation = SegmentationRepository().Get(sLoc, vidSet);
    KeyframesLocator kLoc(videoSetName, "keyframes", options);
    Keyframes* keyframes = KeyframesRepository().Get(kLoc, vidSet);

    KeywordListLocator loc(vidSet->GetLocator(), conceptSet);
    Core::Table::KeywordList concepts =
        *(Persistency::KeywordListRepository().Get(loc));
    for (int c=0 ; c<concepts.size() ; c++)
    {
        ILOG_INFO("doing concept " << concepts[c]);
        ILOG_NDC_PUSH(concepts[c]);

        std::vector<String> posAnnos;
        String fName = "from_active/" + concepts[c] + "/shots_bookmarked.txt";
        KeywordListLocator posLoc(vidSet->GetLocator(), fName);
        if (KeywordListRepository().Exists(posLoc))
            posAnnos = *(KeywordListRepository().Get(posLoc));

        std::vector<String> negAnnos;
        fName = "from_active/" + concepts[c] + "/shots_bookmarked_negative.txt";
        KeywordListLocator negLoc(vidSet->GetLocator(), fName);
        if (KeywordListRepository().Exists(negLoc))
            posAnnos = *(KeywordListRepository().Get(negLoc));

        if ((posAnnos.size() == 0) || (negAnnos.size() == 0))
        {
            ILOG_ERROR("missing input for " << concepts[c]);
            ILOG_NDC_POP;
            continue;
        }

        std::sort(posAnnos.begin(), posAnnos.end());
        std::sort(negAnnos.begin(), negAnnos.end());
        for (int v=0 ; v<vidSet->NrFiles() ; v++)
        {
            String vidFile = vidSet->GetFile(v);
            int nrFrames = segmentation->GetNrFramesVideo(v);
            int frameRateNum = 0;
            int frameRateDen = 0;
            if (fractions == 0)
            {
                Core::Stream::RgbDataSrc* rgbSrc = vidSet->GetVideo(v);
                if ((!rgbSrc) || (rgbSrc->FrameRateNum() < 0)
                    || (rgbSrc->FrameRateDen() < 0))
                {
                    ILOG_ERROR("Need src with known frame rate");
                    continue;
                }
                frameRateNum = rgbSrc->FrameRateNum();
                frameRateDen = rgbSrc->FrameRateDen();
                if (rgbSrc)
                    delete rgbSrc;
            }
            Mpeg7Doc mp7(vidFile, vidFile, nrFrames, fractions, false,
                         conceptSet, concepts[c], frameRateNum, frameRateDen);

            for (int s=0 ; s<segmentation->GetNrShotsVideo(v) ; s++)
            {
                int shotId = segmentation->GetFirstShotVideo(v) + s;
                String shotName = segmentation->GetName(shotId);
                double relevance = -1;
                if (find(posAnnos.begin(), posAnnos.end(), shotName) !=
                    posAnnos.end())
                {
                    relevance = 1;
                }
                else if (find(negAnnos.begin(), negAnnos.end(), shotName) !=
                         negAnnos.end())
                {
                    relevance = 0;
                }
                if (relevance < 0)
                    continue;
                int key = keyframes->GetShotRKF(shotId);

                String keyName = FileNameBase(keyframes->GetName(key));
                int frameNr = keyframes->GetFrameNr(key);
                mp7.AddAnnotation(concepts[c], keyName, frameNr, frameNr,
                                  relevance, 1);
            }
            if (mp7.HasAnnotations())
                Core::VideoSet::Mpeg7DocWrite(&mp7, vidSet, v);
        }
        ILOG_NDC_POP;
    }
}

void
DoDumpParameter()
{
    typedef Core::Database::RawDataSet RawDataSet;
    typedef Core::Feature::FeatureDefinition FeatureDef;

    ILOG_VAR(Impala.Application.Util.DoDumpParameter);
    CmdOptions& options = CmdOptions::GetInstance();
    if (options.GetNrArg() < 5)
    {
        ILOG_ERROR("Need more parameters");
        return;
    }
    String dataSetName = options.GetArg(1);
    String conceptSet = options.GetArg(2);
    String model = options.GetArg(3);
    String feature = options.GetArg(4);

    RawDataSet* dataSet = Core::Database::MakeRawDataSet(dataSetName);
    KeywordListLocator keyLoc(dataSet->GetLocator(), conceptSet);
    Core::Table::KeywordList concepts = *(KeywordListRepository().Get(keyLoc));

    ModelLocator modelLoc(dataSet->GetLocator(), conceptSet, model, feature, "");
    Real64 map = 0;
    int nrMap = 0;
    std::cout << "parameter best for " << conceptSet << "  " << model << "  "
              << feature << std::endl;
    for (int c=0 ; c<concepts.size() ; c++)
    {
        String con = concepts[c];
        modelLoc.SetConcept(con);
        Impala::Util::PropertySet* props = BestFileRepository().Get(modelLoc);
        Real64 ap = props->GetDouble("value", 0.0);
        std::cout << con << " " << ap << std::endl;
        map += ap;
        nrMap++;
    }
    std::cout << "map = " << map / nrMap << std::endl << std::endl;
}

void
DoAPConfusion()
{
    typedef Core::Database::RawDataSet RawDataSet;
    typedef Core::Table::SimilarityTableSet SimilarityTableSet;
    typedef Core::Table::AnnotationTable AnnotationTable;
    using Impala::Core::Table::AveragePrecision;

    ILOG_VAR(Impala.Application.Util.DoAPConfusion);
    CmdOptions& options = CmdOptions::GetInstance();
    if (options.GetNrArg() < 5)
    {
        ILOG_ERROR("Need more parameters");
        return;
    }
    String dataSetName = options.GetArg(1);
    String conceptSet = options.GetArg(2);
    String model = options.GetArg(3);
    String feature = options.GetArg(4);
    String mappingName;
    if (options.GetNrArg() > 5)
        mappingName = options.GetArg(5);

    RawDataSet* dataSet = Core::Database::MakeRawDataSet(dataSetName);
    SimilarityTableSetLocator simLoc(dataSet->GetLocator(), true, "",
                                     conceptSet, model, feature, "");
    SimilarityTableSet* simSet = SimilarityTableSetRepository().Get(simLoc);
    Impala::Util::SimpleMap<String, String> conceptMapping;
    if (!mappingName.empty())
    {
        std::vector<String> lines;
        Persistency::File file = RepositoryGetFile(mappingName, false, false);
        file.ReadStrings(lines);
        for (int i=0 ; i<lines.size() ; i++)
        {
            Impala::Util::StringParser p(lines[i]);
            String src = p.GetString(' ');
            String dst = p.GetString(' ', false);
            std::cout << src << " => " << dst << std::endl;
            conceptMapping.Add(src, dst);
        }
    }

    Core::Table::QuidTable* qTable = simSet->GetQuidTable();
    int qClass = QuidClass(qTable->Get1(0));
    Real64 map = 0;
    Real64 mapJ = 0;
    Real64 map2000 = 0;
    Real64 map2000J = 0;
    bool do2000 = (simSet->TableSize() > 2000);
    int nrMap = 0;
    std::cout << simLoc << ", size = " << simSet->TableSize() << std::endl;

    AnnotationTable** allAnnotations = new AnnotationTable*[simSet->NrTables()];

    for (int c=0 ; c<simSet->NrTables() ; c++)
    {
        String concept = simSet->GetName(c);
        String mappedConcept;
        if (!mappingName.empty())
        {
            if (conceptMapping.Get(concept, mappedConcept))
            {
                concept = mappedConcept;
            }
            else
            {
                continue;
            }
        }
        AnnotationTableLocator annoLoc(dataSet->GetLocator(), qClass,
                                       conceptSet, concept);
        if (!AnnotationTableRepository().Exists(annoLoc))
        {
            ILOG_ERROR("No groundtruth for " << concept);
            continue;
        }
        allAnnotations[c] = AnnotationTableRepository().Get(annoLoc);
        allAnnotations[c]->UpdateQuidMap();
    }

    std::cout << "\nConfusion Matrix Average Precision" << std::endl;
    for (int c=0 ; c<simSet->NrTables() ; c++)
    {
        Real64* confEntry = AveragePrecisionConfusion(simSet->GetRankTable(c),
                                                      allAnnotations,
                                                      c, simSet->NrTables(), -1);

        String concept = simSet->GetName(c);
        std::cout << MakeString(concept, 25) << "\t";

        Real64 total = 0;
        for (int i=0; i<simSet->NrTables() ; i++)
        {
            total += confEntry[i];
            std::cout << confEntry[i] << "\t";
        }

        std::cout << total << std::endl;
    }
 
    std::cout << "\nConfusion Matrix Average Precision Judged" << std::endl;
    for (int c=0 ; c<simSet->NrTables() ; c++)
    {
        Real64* confEntry =
            AveragePrecisionJudgedConfusion(simSet->GetRankTable(c),
                                            allAnnotations,
                                            c, simSet->NrTables(), -1);

        String concept = simSet->GetName(c);
        std::cout << MakeString(concept, 25) << "\t ";

        Real64 total = 0;
        for (int i=0; i<simSet->NrTables() ; i++)
        {
            total += confEntry[i];
            std::cout << confEntry[i] << "\t ";
        }

        std::cout << total << std::endl;
    }

    for (int i=0; i < simSet->NrTables() ; i++)
        delete allAnnotations[i];
    delete allAnnotations;
    delete simSet;
    delete dataSet;
}

void
DoScoreConcepts()
{
    typedef Core::Database::RawDataSet RawDataSet;
    typedef Core::Table::SimilarityTableSet SimilarityTableSet;
    typedef Core::Table::AnnotationTable AnnotationTable;
    using Impala::Core::Table::AveragePrecision;

    ILOG_VAR(Impala.Application.Util.DoScoreConcept);
    CmdOptions& options = CmdOptions::GetInstance();
    if (options.GetNrArg() < 5)
    {
        ILOG_ERROR("Need more parameters");
        return;
    }
    String dataSetName = options.GetArg(1);
    String conceptSet = options.GetArg(2);
    String model = options.GetArg(3);
    String feature = options.GetArg(4);
    String annotations = conceptSet;
    if (options.GetNrArg() > 5)
        annotations = options.GetArg(5);
    String mappingName;
    if (options.GetNrArg() > 6)
        mappingName = options.GetArg(6);

    RawDataSet* dataSet = Core::Database::MakeRawDataSet(dataSetName);
    SimilarityTableSetLocator simLoc(dataSet->GetLocator(), true, "",
                                     conceptSet, model, feature, "");
    SimilarityTableSet* simSet = SimilarityTableSetRepository().Get(simLoc);
    Impala::Util::SimpleMap<String, String> conceptMapping;
    if (!mappingName.empty())
    {
        std::vector<String> lines;
        Persistency::File file = RepositoryGetFile(mappingName, false, false);
        file.ReadStrings(lines);
        for (int i=0 ; i<lines.size() ; i++)
        {
            Impala::Util::StringParser p(lines[i]);
            String src = p.GetString(' ');
            String dst = p.GetString(' ', false);
            std::cout << src << " => " << dst << std::endl;
            conceptMapping.Add(src, dst);
        }
    }

    Core::Table::QuidTable* qTable = simSet->GetQuidTable();
    int qClass = QuidClass(qTable->Get1(0));
    Real64 map = 0;
    Real64 mapJ = 0;
    Real64 map2000 = 0;
    Real64 map2000J = 0;
    bool do2000 = (simSet->TableSize() > 2000);
    int nrMap = 0;
    //std::cout << namesPath << ", size = " << simSet->TableSize() << std::endl;
    std::cout << simLoc << ", size = " << simSet->TableSize() << std::endl;
    for (int c=0 ; c<simSet->NrTables() ; c++)
    {
        String concept = simSet->GetName(c);
        String mappedConcept;
        if (!mappingName.empty())
        {
            if (conceptMapping.Get(concept, mappedConcept))
            {
                concept = mappedConcept;
            }
            else
            {
                continue;
            }
        }
        AnnotationTableLocator annoLoc(dataSet->GetLocator(), qClass,
                                       annotations, concept);
        if (!AnnotationTableRepository().Exists(annoLoc))
        {
            ILOG_INFO("No groundtruth for " << concept);
            continue;
        }
        AnnotationTable* truth = AnnotationTableRepository().Get(annoLoc);
        truth->UpdateQuidMap();
        Real64 ap = AveragePrecision(simSet->GetRankTable(c), truth, -1);
        Real64 apJ = AveragePrecisionJudged(simSet->GetRankTable(c), truth,
                                            false, -1);
        map += ap;
        mapJ += apJ;
        std::cout << MakeString(concept, 30)
                  << " " << ap << "\t j: " << apJ;

        if (do2000)
        {
            Real64 ap2000 = AveragePrecision(simSet->GetRankTable(c), truth,
                                             2000);
            Real64 ap2000J = AveragePrecisionJudged(simSet->GetRankTable(c),
                                                    truth, false, 2000);
            map2000 += ap2000;
            map2000J += ap2000J;
            std::cout << "\t " << ap2000 << "\t j: " << ap2000J;
        }

        std::cout << std::endl;
        nrMap++;
        delete truth;
    }
    std::cout << "map=" << map/nrMap << ", mapJudged=" << mapJ/nrMap;
    if (do2000)
        std::cout << " map2000=" << map2000/nrMap << ", map2000Judged="
                  << map2000J/nrMap;
    std::cout << std::endl << std::endl;
    delete simSet;
    delete dataSet;
}

void
DoScoreConceptsVideo()
{
    typedef Core::Database::RawDataSet RawDataSet;
    typedef Core::Table::SimilarityTableSet SimilarityTableSet;
    typedef Core::Table::SimilarityTableSet::RankTableType RankTableType;
    typedef Core::Table::AnnotationTable AnnotationTable;
    using Impala::Core::Table::AveragePrecision;

    ILOG_VAR(Impala.Application.Util.DoScoreConceptVideo);
    CmdOptions& options = CmdOptions::GetInstance();
    if (options.GetNrArg() < 5)
    {
        ILOG_ERROR("Need more parameters");
        return;
    }
    String dataSetName = options.GetArg(1);
    String conceptSet = options.GetArg(2);
    String model = options.GetArg(3);
    String feature = options.GetArg(4);
    int vidStart = atol(options.GetArg(5));
    int vidEnd = atol(options.GetArg(6));

    RawDataSet* dataSet = Core::Database::MakeRawDataSet(dataSetName);
    SimilarityTableSetLocator simLoc(dataSet->GetLocator(), true, "",
                                     conceptSet, model, feature, "");
    SimilarityTableSet* simSet = SimilarityTableSetRepository().Get(simLoc);

    Core::Table::QuidTable* qTable = simSet->GetQuidTable();
    int qClass = QuidClass(qTable->Get1(0));
    Real64 mapJ = 0;
    int nrMap = 0;
    std::cout << simLoc << ", size = " << simSet->TableSize() << std::endl;
    std::vector<int> videos;
    std::cout << "videos: ";
    for (int i=vidStart ; i<vidEnd ; i++)
    {
        videos.push_back(i);
        std::cout << i << " ";
    }
    std::cout << std::endl;
    for (int c=0 ; c<simSet->NrTables() ; c++)
    {
        String concept = simSet->GetName(c);
        AnnotationTableLocator annoLoc(dataSet->GetLocator(), qClass,
                                       conceptSet, concept);
        if (!AnnotationTableRepository().Exists(annoLoc))
        {
            ILOG_ERROR("No groundtruth for " << concept);
            continue;
        }
        AnnotationTable* truth = AnnotationTableRepository().Get(annoLoc);
        truth->UpdateQuidMap();
        RankTableType* rank = simSet->GetRankTable(c);
        if (videos.size() > 0)
        {
            Core::Table::CriterionQuidObjectInSet<RankTableType> crit(videos);
            Core::Table::Select(rank, rank, crit, true);
        }
        Real64 apJ = AveragePrecisionJudged(rank, truth, false, -1, true);
        mapJ += apJ;
        std::cout << MakeString(concept, 25) << " " << apJ << std::endl;
        nrMap++;
        delete truth;
    }
    std::cout << "mapJudged=" << mapJ/nrMap << std::endl;
    std::cout << std::endl;
    delete simSet;
    delete dataSet;
}

void
DoCombineConcepts()
{
    typedef Core::VideoSet::VideoSet VideoSet;
    typedef Core::Table::SimilarityTableSet SimilarityTableSet;
    typedef Core::Table::SimilarityTableSet::SimTableType SimTableType;

    ILOG_VAR(Impala.Application.Util.DoCombineConcepts);
    CmdOptions& options = CmdOptions::GetInstance();
    if (options.GetNrArg() < 7)
    {
        ILOG_ERROR("Need more parameters");
        return;
    }
    String vidSetName = options.GetArg(1);
    String conceptSet = options.GetArg(2);
    String model = options.GetArg(3);
    String resultName = options.GetArg(4);
    String combi = options.GetArg(5);
    if ((combi != "mul") && (combi != "avg"))
    {
        ILOG_ERROR("Unknown combination method : " << combi);
        return;
    }
    std::vector<String> featureDefs;
    for (int i=6 ; i<options.GetNrArg() ; i++)
        featureDefs.push_back(options.GetArg(i));

    VideoSet* vidSet = Core::VideoSet::MakeVideoSet(vidSetName);

    SimilarityTableSetLocator loc(vidSet->GetLocator(), true, "", conceptSet,
                                  model, featureDefs[0], "");
    SimilarityTableSet* combinedSet = SimilarityTableSetRepository().Get(loc);
    for (int i=1 ; i<featureDefs.size() ; i++)
    {
        loc.SetFeature(featureDefs[i]);
        SimilarityTableSet* simSet = SimilarityTableSetRepository().Get(loc);
        for (int t=0 ; t<simSet->NrTables() ; t++)
        {
            if (combi == "mul")
                MulAssign(combinedSet->GetSimTable(t)->GetColumn1(),
                          simSet->GetSimTable(t)->GetColumn1(), 0, -1);
            else
                AddAssign(combinedSet->GetSimTable(t)->GetColumn1(),
                          simSet->GetSimTable(t)->GetColumn1(), 0, -1);
        }
        delete simSet;
    }
    if (combi == "avg")
        for (int t=0 ; t<combinedSet->NrTables() ; t++)
            DivAssign(combinedSet->GetSimTable(t)->GetColumn1(),
                      featureDefs.size(), 0, -1);
    combinedSet->ComputeRanks(true);
    loc.SetFeature(resultName);
    SimilarityTableSetRepository().Add(loc, combinedSet);
    delete combinedSet;
    delete vidSet;
}

void
DoMapConcepts2Shots()
{
    typedef Core::VideoSet::VideoSet VideoSet;
    typedef Core::VideoSet::Segmentation Segmentation;
    typedef Core::Table::SimilarityTableSet SimilarityTableSet;
    typedef Core::Table::SimilarityTableSet::SimTableType SimTableType;

    ILOG_VAR(Impala.Application.Util.DoMapConcepts2Shots);
    CmdOptions& options = CmdOptions::GetInstance();
    if (options.GetNrArg() < 5)
    {
        ILOG_ERROR("Need more parameters");
        return;
    }
    String vidSetName = options.GetArg(1);
    String conceptSet = options.GetArg(2);
    String model = options.GetArg(3);
    String feature = options.GetArg(4);
    String aggregationMode = "max";
    if (options.GetNrArg() >= 6)
    {
        aggregationMode = options.GetArg(5);
    }

    VideoSet* vidSet = Core::VideoSet::MakeVideoSet(vidSetName);
    SegmentationLocator sLoc(vidSetName, "segmentation", options);
    Segmentation* segmentation = SegmentationRepository().Get(sLoc, vidSet);
    SimilarityTableSetLocator simLoc(vidSet->GetLocator(), true, "",
                                     conceptSet, model, feature, "");
    SimilarityTableSet* simSet = SimilarityTableSetRepository().Get(simLoc);
 
    Core::Table::QuidTable* frameQuids = simSet->GetQuidTable();
    int nrShots = segmentation->GetNrShots();
    SimilarityTableSet* res = new SimilarityTableSet(simSet->GetNames(), nrShots);
    Core::Table::QuidTable* shotQuids = res->GetQuidTable();
    for (int t=0 ; t<simSet->NrTables() ; t++)
    {
        SimTableType* frameSimTable = simSet->GetSimTable(t);
        SimTableType* shotSimTable = res->GetSimTable(t);
        int lastShot = -1;
        Real64 lastSim = 0;
        int lastCount = 0;
        for (int i=0 ; i<frameSimTable->Size() ; i++)
        {
            Quid frameQ = frameQuids->Get1(i);
            Real64 frameSim = frameSimTable->Get1(i);
            int shot = segmentation->GetShotId(frameQ);
            if (shot != lastShot)
            {
                if (lastShot != -1)
                {
                    Quid check = segmentation->GetQuidShot(lastShot);
                    int rank = shotSimTable->Size();
                    if (shotQuids->Size() <= rank)
                        shotQuids->Add(check);
                    if (check != shotQuids->Get1(rank))
                    {
                        ILOG_ERROR("Quids do not match");
                    }
                    if (aggregationMode == "avg")
                    {
                        lastSim = lastSim / lastCount;
                    }
                    shotSimTable->Add(lastSim);
                }
                lastSim = frameSim;
                lastShot = shot;
                lastCount = 1;
            }
            else
            {
                lastCount++;
                if (aggregationMode == "max")
                {
                    if (frameSim > lastSim)
                        lastSim = frameSim;
                }
                else if (aggregationMode == "avg")
                {
                    lastSim += frameSim;
                }
            }
        }
        if (lastShot != -1)
        {
            Quid check = segmentation->GetQuidShot(lastShot);
            int rank = shotSimTable->Size();
            if (shotQuids->Size() <= rank)
                shotQuids->Add(check);
            if (check != shotQuids->Get1(rank))
            {
                ILOG_ERROR("Quids do not match");
            }
            if (aggregationMode == "avg")
            {
                lastSim = lastSim / lastCount;
            }
            shotSimTable->Add(lastSim);
        }
    }

    res->ComputeRanks(true);
    simLoc.SetFeature("shot" + feature);
    SimilarityTableSetRepository().Add(simLoc, res);
    delete res;
    delete simSet;
    delete vidSet;
}

// Note : this "hack" requires *not* doing LoadRanks and SaveRanks in
// SimilarityTableSetRepositoryInFile
void
DoConcepts2AllFrames()
{
    typedef Core::VideoSet::VideoSet VideoSet;
    typedef Core::VideoSet::Segmentation Segmentation;
    typedef Core::Table::SimilarityTableSet SimilarityTableSet;
    typedef Core::Table::SimilarityTableSet::SimTableType SimTableType;

    ILOG_VAR(Impala.Application.Util.DoConceptsExtra2AllFrames);
    CmdOptions& options = CmdOptions::GetInstance();
    if (options.GetNrArg() < 5)
    {
        ILOG_ERROR("Need more parameters");
        return;
    }
    String vidSetName = options.GetArg(1);
    String conceptSet = options.GetArg(2);
    String model = options.GetArg(3);
    String feature = options.GetArg(4);

    VideoSet* vidSet = Core::VideoSet::MakeVideoSet(vidSetName);
    SegmentationLocator sLoc(vidSetName, "segmentation", options);
    Segmentation* segmentation = SegmentationRepository().Get(sLoc, vidSet);
    SimilarityTableSetLocator srcLoc(vidSet->GetLocator(), true, "",
                                     conceptSet, model, feature, "");
    SimilarityTableSet* srcSet = SimilarityTableSetRepository().Get(srcLoc);
 
    Core::Table::QuidTable* srcQuids = srcSet->GetQuidTable();
    srcQuids->UpdateGroups();
    for (int v=0 ; v<vidSet->NrFiles() ; v++)
    {
        int nrFrames = segmentation->GetNrFramesVideo(v);
        ILOG_INFO("Video " << v << " has " << nrFrames << " frames and " <<
                  segmentation->GetNrShotsVideo(v) << " shots");
        SimilarityTableSet* dstSet = new SimilarityTableSet(srcSet->GetNames(),
                                                            nrFrames);
        Core::Table::QuidTable* dstQuids = dstSet->GetQuidTable();
        for (int t=0 ; t<srcSet->NrTables() ; t++)
        {
            SimTableType* srcSimTable = srcSet->GetSimTable(t);
            SimTableType* dstSimTable = dstSet->GetSimTable(t);
            for (int f=0 ; f<nrFrames ; f++)
            {
                Quid quid = vidSet->GetQuidFrame(v, f);
                if (t == 0)
                    dstQuids->Add(quid);
                Real64 sim = 0;
                int obj = QuidObject(quid);
                int start = srcQuids->GetFirstQuidObject(obj);
                int nr = srcQuids->GetNrQuidsObject(obj);
                int idx = srcQuids->Size();
                for (int i=start ; i<start+nr ; i++)
                {
                    if (srcQuids->Get1(i) == quid)
                    {
                        idx = i;
                        break;
                    }
                }
                if (idx != srcQuids->Size())
                {
                    sim = srcSimTable->Get1(idx);
                }
                dstSimTable->Add(sim);
            }
        }

        // Not used right now, so skipping...
        //dstSet->ComputeRanks(true);
        SimilarityTableSetLocator dstLoc(vidSet->GetLocator(), false, "Frames",
                                         conceptSet, model, feature,
                                         vidSet->GetContainer(v));
        SimilarityTableSetRepository().Add(dstLoc, dstSet);
        delete dstSet;
    }
    delete srcSet;
    delete vidSet;
}

void
DoConcepts2TrecResult()
{
    typedef Core::VideoSet::VideoSet VideoSet;
    typedef Core::VideoSet::Segmentation Segmentation;
    typedef Core::VideoSet::Keyframes Keyframes;
    typedef Core::Table::SimilarityTableSet SimilarityTableSet;
    typedef Core::Table::SimilarityTableSet::RankTableType RankTableType;

    ILOG_VAR(Impala.Application.Util.DoConcepts2TrecResult);
    CmdOptions& options = CmdOptions::GetInstance();
    if (options.GetNrArg() < 5)
    {
        ILOG_ERROR("Need more parameters");
        return;
    }
    String vidSetName = options.GetArg(1);
    String conceptSet = options.GetArg(2);
    String model = options.GetArg(3);
    String feature = options.GetArg(4);

    VideoSet* vidSet = Core::VideoSet::MakeVideoSet(vidSetName);
    SegmentationLocator sLoc(vidSetName, "segmentation", options);
    Segmentation* segmentation = SegmentationRepository().Get(sLoc, vidSet);
    KeyframesLocator kLoc(vidSetName, "keyframes", options);
    Keyframes* keyframes = KeyframesRepository().Get(kLoc, vidSet);
    SimilarityTableSetLocator simLoc(vidSet->GetLocator(), true, "",
                                     conceptSet, model, feature, "");
    SimilarityTableSet* simSet = SimilarityTableSetRepository().Get(simLoc);

    for (int c=0 ; c<simSet->NrTables() ; c++)
    {
        String concept = simSet->GetName(c);
        ILOG_INFO("Doing concept " << concept);
        std::vector<String> res;
        RankTableType* rTable = simSet->GetRankTable(c);
        for (int i=0 ; i<rTable->Size() ; i++)
        {
            Quid quid = rTable->Get1(i);
            int shot = -1;
            if (QuidClass(quid) == QUID_CLASS_FRAME) // assume it is a keyframe
            {
                int keyfr = keyframes->GetFrameId(quid);
                if (keyfr != -1)
                    shot = keyframes->GetShotId(keyfr);
            }
            if (QuidClass(quid) == QUID_CLASS_SHOT)
            {
                shot = segmentation->GetShotId(quid);
            }
            if (shot == -1)
            {
                ILOG_ERROR("Unable to find shot for " << QuidObj(quid));
                continue;
            }
            String name = segmentation->GetName(shot);
            if (std::find(res.begin(), res.end(), name) == res.end())
                res.push_back(name);
        }
        String fName = concept + ".txt";
        Persistency::File file = RepositoryGetFile(fName, true, false);
        file.WriteStrings(res.begin(), res.end());
    }
    delete simSet;
    delete vidSet;
}

void
DoJudgeConcepts()
{
    typedef Core::VideoSet::VideoSet VideoSet;
    typedef Core::VideoSet::Segmentation Segmentation;
    typedef Core::VideoSet::Keyframes Keyframes;
    typedef Core::Table::SimilarityTableSet SimilarityTableSet;
    typedef Core::Table::SimilarityTableSet::RankTableType RankTableType;

    ILOG_VAR(Impala.Application.Util.DoJudgeConcepts);
    CmdOptions& options = CmdOptions::GetInstance();
    if (options.GetNrArg() < 7)
    {
        ILOG_ERROR("Need at least 7 arguments");
        return;
    }
    String vidSetName = options.GetArg(1);
    String conceptSet = options.GetArg(2);
    String model = options.GetArg(3);
    String feature = options.GetArg(4);
    String mappingName = options.GetArg(5);
    String judgeFile = options.GetArg(6);

    VideoSet* vidSet = Core::VideoSet::MakeVideoSet(vidSetName);
    SegmentationLocator sLoc(vidSetName, "segmentation", options);
    Segmentation* segmentation = SegmentationRepository().Get(sLoc, vidSet);
    KeyframesLocator kLoc(vidSetName, "keyframes", options);
    Keyframes* keyframes = KeyframesRepository().Get(kLoc, vidSet);
    SimilarityTableSetLocator simLoc(vidSet->GetLocator(), true, "",
                                     conceptSet, model, feature, "");
    SimilarityTableSet* simSet = SimilarityTableSetRepository().Get(simLoc);

    std::vector<String> lines;
    Impala::Util::SimpleMap<String, String> conceptMapping;
    Persistency::File file = RepositoryGetFile(mappingName, false, false);
    file.ReadStrings(lines);
    for (int i=0 ; i<lines.size() ; i++)
    {
        Impala::Util::StringParser p(lines[i]);
        String topic = p.GetString(' ');
        String concept = p.GetString(' ', false);
        std::cout << topic << " = " << concept << std::endl;
        conceptMapping.Add(concept, topic);
    }
    Core::Trec::SearchJudge judge(judgeFile);
    judge.Stats();

    Real64 miap = 0;
    int nrMiap = 0;
    std::cout << simLoc << ", size = " << simSet->TableSize() << std::endl;
    for (int c=0 ; c<simSet->NrTables() ; c++)
    {
        String concept = simSet->GetName(c);
        ILOG_DEBUG("Doing concept " << concept);
        std::vector<String> res;
        RankTableType* rTable = simSet->GetRankTable(c);
        for (int i=0 ; i<rTable->Size() ; i++)
        {
            Quid quid = rTable->Get1(i);
            int shot = -1;
            if (QuidClass(quid) == QUID_CLASS_FRAME) // assume it is a keyframe
            {
                int keyfr = keyframes->GetFrameId(quid);
                if (keyfr != -1)
                    shot = keyframes->GetShotId(keyfr);
            }
            if (QuidClass(quid) == QUID_CLASS_SHOT)
            {
                shot = segmentation->GetShotId(quid);
            }
            if (shot == -1)
            {
                ILOG_ERROR("Unable to find shot for " << QuidObj(quid));
                continue;
            }
            String name = segmentation->GetName(shot);
            if (std::find(res.begin(), res.end(), name) == res.end())
                res.push_back(name);
            if (res.size() >= 2000)
                break;
        }
        String topic;
        if (!conceptMapping.Get(concept, topic))
        {
            ILOG_ERROR("No topic for " << concept);
            continue;
        }
        if (!judge.HasTopic(topic))
        {
            ILOG_INFO("No judge for " << topic << " = " << concept);
            continue;
        }
        Real64 infAP = judge.Judge(topic, res);
        std::cout << concept << " " << infAP << std::endl;
        miap += infAP;
        nrMiap++;
    }
    std::cout << "miap = " << miap / nrMiap << std::endl << std::endl;
    delete simSet;
    delete vidSet;
}

void
DoPing()
{
    typedef Impala::Util::Channel Channel;
    typedef Impala::Util::ChannelPool ChannelPool;

    ILOG_VAR(Impala.Application.Util.DoPing);
    CmdOptions& options = CmdOptions::GetInstance();
    if (options.GetNrArg() < 2)
    {
        ILOG_ERROR("Need at least 2 arguments");
        return;
    }
    String hostName = options.GetArg(1);
    String passFile = options.GetString("passwordFile");
    Channel* channel = ChannelPool::Instance().Get(hostName, passFile);;
    if (! (channel && channel->Valid()))
    {
        ILOG_ERROR("Could not connect to server");
        return;
    }
    char* buf = channel->Buffer();
    sprintf(buf, "ping\0");
    channel->SendRequest(strlen(buf)+1);
    if (channel->LastSendHadError())
    {
        ILOG_ERROR("Failed to send message");
        return;
    }
    ILOG_INFO("Server OK");
}

int
mainUtil(int argc, char* argv[])
{
    CmdOptions& options = CmdOptions::GetInstance();
    options.Initialise(true, false, true);
    options.AddOption(0, "start", "nr", "0");
    options.AddOption(0, "end", "nr", "-1");
    String usageStr = "cmd = \n\n";
    usageStr += "  createimageset imageset.txt [imagefile]+\n";
    usageStr += "  trectopicdata ...\n";
    usageStr += "  trecset year {devel|test} collection.xml\n";
    usageStr += "  trecjudge qrel.txt shotresult.txt topiccode\n";
    usageStr += "  dumpkeyframes videoset.txt\n";
    usageStr += "  dumpsegmentation videoset.txt\n";
    usageStr += "  exportshotmpeg7 videoset.txt {25|30000} generateShotNames withKeyframes\n";
    usageStr += "  exportannompeg7 videoset.txt {25|30000} concepts.txt\n";
    usageStr += "  importannotruth videoset.txt concepts.txt maskfile\n";
    usageStr += "  exportannotruth videoset.txt concepts.txt\n";
    usageStr += "  importannotations videoset.txt {25|30000} concepts.txt\n";
    usageStr += "  exportconceptmpeg7 videoset.txt {25|30000} names.txt\n";
    usageStr += "  dumpparameter videoset.txt concepts.txt model featuredef\n";
    usageStr += "  apconfusion videoset.txt concepts.txt model feature [mapping]\n";
    usageStr += "  scoreconcepts videoset.txt concepts.txt model feature [annotations=concepts.txt] [mapping]\n";
    usageStr += "  scoreconceptsvideo videoset.txt annoset.txt names.txt vidStart vidEnd\n";
    usageStr += "  combineconcepts videoset.txt concepts.txt model resultName {avg|mil} {feature}+\n";
    usageStr += "  mapconcepts2shots videoset.txt conceptSet model feature [mode=max]\n";
    usageStr += "  conceptsextra2allframes videoset.txt conceptSet model feature\n";
    usageStr += "  concepts2trecresult videoset.txt concepts.txt model feature\n";
    usageStr += "  judgeconcepts videoset.txt concepts.txt model feature conceptMapping.txt qrels\n";
    usageStr += "  ping host:port\n";
    usageStr += "  checknativetypesize\n";
    if (! options.ParseArgs(argc, argv, usageStr, 1))
        return 1;

    ILOG_VAR(Impala.Application.Util.mainUtil);

    String cmd = options.GetArg(0);
    ILOG_DEBUG("cmd = " << cmd);
    if (cmd == "createimageset")
        DoCreateImageSet();
    else if (cmd == "trectopicdata")
        DoTrecTopicData();
    else if (cmd == "trecset")
        DoTrecSet();
    else if (cmd == "trecjudge")
        DoTrecJudge();
    else if (cmd == "trecdropped")
        DoTrecDropped();
    else if (cmd == "trecmissing")
        DoTrecMissing();
    else if (cmd == "createcaanno")
        DoCreateCaAnno();
    else if (cmd == "exportshotmpeg7")
        DoExportShotMpeg7();
    else if (cmd == "exportannompeg7")
        DoExportAnnoMpeg7();
    else if (cmd == "importannotruth")
        DoImportAnnoTruth();
    else if (cmd == "exportannotruth")
        DoExportAnnoTruth();
    else if (cmd == "importannotations")
        DoImportAnnotations();
    else if (cmd == "importannotationsork")
        DoImportAnnotationsOrk();
    else if (cmd == "importannotationsactive")
        DoImportAnnotationsActive();
    else if (cmd == "dumpparameter")
        DoDumpParameter();
    else if (cmd == "apconfusion")
        DoAPConfusion();
    else if (cmd == "scoreconcepts")
        DoScoreConcepts();
    else if (cmd == "scoreconceptsvideo")
        DoScoreConceptsVideo();
    else if (cmd == "combineconcepts")
        DoCombineConcepts();
    else if (cmd == "mapconcepts2shots")
        DoMapConcepts2Shots();
    else if (cmd == "concepts2allframes")
        DoConcepts2AllFrames();
    else if (cmd == "concepts2trecresult")
        DoConcepts2TrecResult();
    else if (cmd == "judgeconcepts")
        DoJudgeConcepts();
    else if (cmd == "ping")
        DoPing();
    else if (cmd == "checknativetypesize")
        Impala::Core::Array::Element::CheckNativeTypeSize();
    else ILOG_ERROR("Unknown cmd : " << cmd);

    return ILOG_ERROR_COUNT;
}

} // namespace Util
} // namespace Application
} // namespace Impala

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

---