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

---

mainRepository.cpp

Go to the documentation of this file.

#include "Persistency/ImageSetRepository.h"
#include "Persistency/AnnotationTableSetRepository.h"
#include "Persistency/AnnotationTableRepository.h"
#include "Persistency/FeatureTableRepository.h"
#include "Persistency/ImageArchiveRepository.h"
#include "Persistency/VideoSetRepository.h"
#include "Persistency/SegmentationRepository.h"
#include "Persistency/KeyframesRepository.h"
#include "Persistency/KeywordListRepository.h"
#include "Persistency/SimilarityTableSetRepository.h"
#include "Core/Table/KeywordListDiff.h"



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

namespace Impala
{
namespace Application
{
namespace Repository
{


using namespace Persistency;

using Core::Array::ImageArchive;
using Core::Database::RawDataSet;
using Core::ImageSet::ImageSet;
using Core::VideoSet::VideoSet;
using Core::VideoSet::Segmentation;
using Core::VideoSet::Keyframes;
using Core::Table::AnnotationTable;
using Core::Table::AnnotationTableSet;
using Core::Table::KeywordList;
using Core::Table::SimilarityTableSet;
using Core::Feature::FeatureTable;

// Convenience functions

RawDataSet*
GetRawDataSet(String locString, String setName, bool required)
{
    ILOG_VAR(Impala.Application.Repository.GetRawDataSet);

    Locator loc(locString, setName);
    RawDataSet* dataSet = 0;
    if (VideoSetsRepository::GetInstance().Contains(setName))
    {
        dataSet = VideoSetRepository().Get(loc);
    }
    else if (ImageSetsRepository::GetInstance().Contains(setName))
    {
        ImageSetLocator imSetLoc(loc, "");
        dataSet = ImageSetRepository().Get(imSetLoc);
    }
    else if (required)
    {
        ILOG_ERROR("Could find " << loc);
    }
    return dataSet;
}

RawDataSet*
GetRawDataSet(CmdOptions& options, bool required)
{
    ILOG_VAR(Impala.Application.Repository.GetRawDataSet);

    int a = 1;
    String locString = options.GetArg(a++);
    String setName = options.GetArg(a++);
    return GetRawDataSet(locString, setName, required);
}

ImageSet*
GetImageSet(String locString, String setName, bool required)
{
    ILOG_VAR(Impala.Application.Repository.GetImageSet);

    ImageSetLocator loc(locString, setName);
    ImageSet* imSet = 0;
    if (ImageSetsRepository::GetInstance().Contains(setName))
    {
        imSet = ImageSetRepository().Get(loc);
    }
    else if (required)
    {
        ILOG_ERROR("Could find " << loc);
    }
    return imSet;
}

ImageSet*
GetImageSet(CmdOptions& options, bool required, bool getSrcLoc = true)
{
    ILOG_VAR(Impala.Application.Repository.GetImageSet);

    int nrArg = 2;
    if (!getSrcLoc)
        nrArg++;
    if (options.GetNrArg() < nrArg)
    {
        ILOG_ERROR("Need at least " << nrArg << " parameters");
    }
    int a = 1;
    String locString = options.GetArg(a++);
    String setName = options.GetArg(a++);
    if (!getSrcLoc)
        locString = options.GetArg(a++);
    return GetImageSet(locString, setName, required);
}

VideoSet*
GetVideoSet(String locString, String setName, bool required)
{
    ILOG_VAR(Impala.Application.Repository.GetVideoSet);

    Locator loc(locString, setName);
    VideoSet* vidSet = 0;
    if (VideoSetsRepository::GetInstance().Contains(setName))
    {
        vidSet = VideoSetRepository().Get(loc);
    }
    else if (required)
    {
        ILOG_ERROR("Could find " << loc);
    }
    return vidSet;
}

VideoSet*
GetVideoSet(CmdOptions& options, bool required, bool getSrcLoc = true)
{
    ILOG_VAR(Impala.Application.Repository.GetVideoSet);

    int nrArg = 2;
    if (!getSrcLoc)
        nrArg++;
    if (options.GetNrArg() < nrArg)
    {
        ILOG_ERROR("Need at least " << nrArg << " parameters");
    }
    int a = 1;
    String locString = options.GetArg(a++);
    String setName = options.GetArg(a++);
    if (!getSrcLoc)
        locString = options.GetArg(a++);
    return GetVideoSet(locString, setName, required);
}

// ImageSets part

void
DoDumpImageSets()
{
    ImageSetsRepository::GetInstance().Dump();
}

// VideoSets part

void
DoDumpVideoSets()
{
    VideoSetsRepository::GetInstance().Dump();
}

void
DoCopyVideoSets()
{
    ILOG_VAR(Impala.Application.Repository.DoCopyVideoSets);
    CmdOptions& options = CmdOptions::GetInstance();

    String locString = options.GetArg(1);
    Locator dstLoc(options.GetArg(1), "dummy");
    VideoSetsRepository::GetInstance().CopyTo(dstLoc);
}

// ImageSet part

void
DoDumpImageSet()
{
    ILOG_VAR(Impala.Application.Repository.DoDumpImageSet);
    CmdOptions& options = CmdOptions::GetInstance();

    ImageSet* imSet = GetImageSet(options, true);
    imSet->Dump(0, -1, options.GetInt("start"), options.GetInt("end"));
    delete imSet;
}

void
DoDiffImageSet()
{
    ILOG_VAR(Impala.Application.Repository.DoDiffImageSet);
    CmdOptions& options = CmdOptions::GetInstance();

    ImageSet* imSet1 = GetImageSet(options, true);
    ImageSet* imSet2 = GetImageSet(options, true, false);
    imSet1->Diff(imSet2);
    delete imSet2;
    delete imSet1;
}

void
DoCopyImageSet()
{
    ILOG_VAR(Impala.Application.Repository.DoCopyImageSet);
    CmdOptions& options = CmdOptions::GetInstance();

    String locString1 = options.GetArg(1);
    String setName = options.GetArg(2);
    String locString2 = options.GetArg(3);
    ImageSet* imSet = GetImageSet(options, true);
    ImageSetLocator setLoc2(locString2, setName);
    ImageSetRepository().Add(setLoc2, imSet);
    delete imSet;
}

// VideoSet part

void
DoDumpVideoSet()
{
    ILOG_VAR(Impala.Application.Repository.DoDumpVideoSet);
    CmdOptions& options = CmdOptions::GetInstance();

    VideoSet* vidSet = GetVideoSet(options, true);
    vidSet->Dump(0, -1, options.GetInt("start"), options.GetInt("end"));
    delete vidSet;
}

void
DoDiffVideoSet()
{
    ILOG_VAR(Impala.Application.Repository.DoDiffVideoSet);
    CmdOptions& options = CmdOptions::GetInstance();

    VideoSet* vidSet1 = GetVideoSet(options, true);
    VideoSet* vidSet2 = GetVideoSet(options, true, false);
    vidSet1->Diff(vidSet2);
    delete vidSet2;
    delete vidSet1;
}

void
DoCopyVideoSet()
{
    ILOG_VAR(Impala.Application.Repository.DoCopyVideoSet);
    CmdOptions& options = CmdOptions::GetInstance();

    String locString1 = options.GetArg(1);
    String setName = options.GetArg(2);
    String locString2 = options.GetArg(3);
    VideoSet* vidSet = GetVideoSet(options, true);
    Locator setLoc2(locString2, setName);
    VideoSetRepository().Add(setLoc2, vidSet);
    delete vidSet;
}

// Segmentation part

SegmentationLocator
GetSegmentationLocator(CmdOptions& options, bool getSrcLoc)
{
    ILOG_VAR(Impala.Application.Repository.GetSegmentationLocator);

    int nrArg = 2;
    if (!getSrcLoc)
        nrArg++;
    if (options.GetNrArg() < nrArg)
    {
        ILOG_ERROR("Need at least " << nrArg << " parameters");
    }

    int a = 1;
    String locString = options.GetArg(a++);
    String setName = options.GetArg(a++);
    if (!getSrcLoc)
        locString = options.GetArg(a++);
    return SegmentationLocator(locString, setName, "segmentation");
}

void
DoDumpSegmentation()
{
    ILOG_VAR(Impala.Application.Repository.DoDumpSegmentation);
    CmdOptions& options = CmdOptions::GetInstance();

    SegmentationLocator loc = GetSegmentationLocator(options, true);
    VideoSet* vidSet = GetVideoSet(options, true);
    Segmentation* seg = SegmentationRepository().Get(loc, vidSet);
    ILOG_INFO("nrVideos = " << seg->GetNrVideos());
    ILOG_INFO("nrShots = " << seg->GetNrShots());
    ILOG_INFO("nrFrames = " << seg->GetTotalNrFrames());
    if (options.GetInt("end") == 0)
        return;
    int minNr = 10000000;
    int maxNr = 0;
    for (int i=0 ; i<seg->GetNrVideos() ; i++)
    {
        int nrFrames = seg->GetNrFramesVideo(i);
        std::cout << "  vid " << i << " has " << seg->GetNrShotsVideo(i)
                  << " shots and " << nrFrames << " frames" << std::endl;
        if (nrFrames < minNr)
            minNr = nrFrames;
        if (nrFrames > maxNr)
            maxNr = nrFrames;
    }
    std::cout << "  min nr frames = " << minNr << ", max nr = " << maxNr
              << std::endl;
    seg->Dump(options.GetInt("start"), options.GetInt("end"));
    delete seg;
    delete vidSet;
}

void
DoDiffSegmentation()
{
    ILOG_VAR(Impala.Application.Repository.DoDiffSegmentation);
    CmdOptions& options = CmdOptions::GetInstance();

    SegmentationLocator loc1 = GetSegmentationLocator(options, true);
    VideoSet* vidSet1 = GetVideoSet(options, true);
    Segmentation* seg1 = SegmentationRepository().Get(loc1, vidSet1);

    SegmentationLocator loc2 = GetSegmentationLocator(options, false);
    VideoSet* vidSet2 = VideoSetRepository().Get(loc2);
    Segmentation* seg2 = SegmentationRepository().Get(loc2, vidSet2);

    seg1->Diff(seg2);

    delete seg2;
    delete seg1;
    delete vidSet2;
    delete vidSet1;
}

void
DoCopySegmentation()
{
    ILOG_VAR(Impala.Application.Repository.DoCopySegmentation);
    CmdOptions& options = CmdOptions::GetInstance();

    SegmentationLocator loc1 = GetSegmentationLocator(options, true);
    VideoSet* vidSet = GetVideoSet(options, true);
    Segmentation* seg = SegmentationRepository().Get(loc1, vidSet);

    SegmentationLocator loc2 = GetSegmentationLocator(options, false);
    SegmentationRepository().Add(loc2, seg);
    delete seg;
    delete vidSet;
}

// Keyframes part

KeyframesLocator
GetKeyframesLocator(CmdOptions& options, bool getSrcLoc)
{
    ILOG_VAR(Impala.Application.Repository.GetKeyframesLocator);

    int nrArg = 2;
    if (!getSrcLoc)
        nrArg++;
    if (options.GetNrArg() < nrArg)
    {
        ILOG_ERROR("Need at least " << nrArg << " parameters");
    }

    int a = 1;
    String locString = options.GetArg(a++);
    String setName = options.GetArg(a++);
    if (!getSrcLoc)
        locString = options.GetArg(a++);
    return KeyframesLocator(locString, setName, "keyframes");
}

void
DoDumpKeyframes()
{
    ILOG_VAR(Impala.Application.Repository.DoDumpKeyframes);
    CmdOptions& options = CmdOptions::GetInstance();

    KeyframesLocator loc = GetKeyframesLocator(options, true);
    VideoSet* vidSet = GetVideoSet(options, true);
    Keyframes* keys = KeyframesRepository().Get(loc, vidSet);

    ILOG_INFO("nrVideos = " << keys->GetNrVideos());
    ILOG_INFO("nrShots = " << keys->GetNrShots());
    ILOG_INFO("nrKeyframes = " << keys->GetNrKeyframes());
    if (options.GetInt("end") == 0)
        return;
    for (int i=0 ; i<keys->GetNrVideos() ; i++)
        std::cout << "  vid " << i << " has " << keys->GetNrKeyframesVideo(i)
                  << " keyframes" << std::endl;
    //keys.DumpGroups();
    keys->Dump(options.GetInt("start"), options.GetInt("end"));
    delete keys;
    delete vidSet;
}

void
DoDiffKeyframes()
{
    ILOG_VAR(Impala.Application.Repository.DoDiffKeyframes);
    CmdOptions& options = CmdOptions::GetInstance();

    KeyframesLocator loc1 = GetKeyframesLocator(options, true);
    VideoSet* vidSet1 = GetVideoSet(options, true);
    Keyframes* keys1 = KeyframesRepository().Get(loc1, vidSet1);

    KeyframesLocator loc2 = GetKeyframesLocator(options, false);
    VideoSet* vidSet2 = VideoSetRepository().Get(loc2);
    Keyframes* keys2 = KeyframesRepository().Get(loc2, vidSet2);

    keys1->Diff(keys2);

    delete keys2;
    delete keys1;
    delete vidSet2;
    delete vidSet1;
}

void
DoCopyKeyframes()
{
    ILOG_VAR(Impala.Application.Repository.DoCopyKeyframes);
    CmdOptions& options = CmdOptions::GetInstance();

    KeyframesLocator loc1 = GetKeyframesLocator(options, true);
    VideoSet* vidSet = GetVideoSet(options, true);
    Keyframes* keys = KeyframesRepository().Get(loc1, vidSet);

    KeyframesLocator loc2 = GetKeyframesLocator(options, false);
    KeyframesRepository().Add(loc2, keys);
    delete keys;
    delete vidSet;
}

// ImageArchive part

ImageArchiveLocator
GetImageArchiveLocator(CmdOptions& options, bool getSrcLoc)
{
    ILOG_VAR(Impala.Application.Repository.GetImageArchiveLocator);

    int nrArg = 6;
    if (!getSrcLoc)
        nrArg++;
    if (options.GetNrArg() < nrArg)
    {
        ILOG_ERROR("Need at least " << nrArg << " parameters");
    }

    int a = 1;
    String locString = options.GetArg(a++);
    String setName = options.GetArg(a++);
    bool frames = StringToBool(options.GetArg(a++));
    String container = options.GetArg(a++);
    String name = options.GetArg(a++);
    if (!getSrcLoc)
        locString = options.GetArg(a++);
    return ImageArchiveLocator(locString, setName, frames, container, name, 0);
}

void
DoDumpImageArchive()
{
    ILOG_VAR(Impala.Application.Repository.DoDumpImageArchive);
    CmdOptions& options = CmdOptions::GetInstance();

    ImageArchiveLocator loc = GetImageArchiveLocator(options, true);
    VideoSet* vidSet = GetVideoSet(options, true);
    String container = loc.GetContainer();
    int nrArchives = (container == "ALL") ? vidSet->NrFiles() : 1;
    for (int i=0 ; i<nrArchives ; i++)
    {
        String cur = (container == "ALL") ? vidSet->GetFile(i) : container;
        loc.SetContainer(cur);
        int v = vidSet->GetFileId(cur);
        Quid quid = (v != -1) ? vidSet->GetQuidVideo(v, false) : 0;
        loc.SetQuid(quid);
        ImageArchive* archive = ImageArchiveRepository().Get(loc);
        std::cout << loc << " has " << archive->NrImages() << " images"
                  << std::endl;
        if (archive->NrImages() > 0)
        {
            Core::Array::Array2dVec3UInt8* im = archive->ReadImage(0);
            std::cout << "ImageSize = " << im->CW() << "x" << im->CH()
                      << std::endl;
            delete im;
        }
        delete archive;
    }
    delete vidSet;
}

void
DoDiffImageArchive()
{
    ILOG_VAR(Impala.Application.Repository.DoDiffImageArchive);
    CmdOptions& options = CmdOptions::GetInstance();

    ImageArchiveLocator loc1 = GetImageArchiveLocator(options, true);
    ImageArchiveLocator loc2 = GetImageArchiveLocator(options, false);
    VideoSet* vidSet = GetVideoSet(options, true);
    String container = loc1.GetContainer();
    int nrArchives = (container == "ALL") ? vidSet->NrFiles() : 1;
    for (int i=0 ; i<nrArchives ; i++)
    {
        String cur = (container == "ALL") ? vidSet->GetFile(i) : container;
        ILOG_INFO("Checking " << i << " = " << cur);
        int v = vidSet->GetFileId(cur);
        Quid quid = (v != -1) ? vidSet->GetQuidVideo(v, false) : 0;
        loc1.SetContainer(cur);
        loc1.SetQuid(quid);
        ImageArchive* archive1 = ImageArchiveRepository().Get(loc1);
        loc2.SetContainer(cur);
        loc2.SetQuid(quid);
        ImageArchive* archive2 = ImageArchiveRepository().Get(loc2);
        archive1->Diff(archive2);
        delete archive2;
        delete archive1;
    }
    delete vidSet;
}

void
DoCopyImageArchive()
{
    ILOG_VAR(Impala.Application.Repository.DoCopyImageArchive);
    CmdOptions& options = CmdOptions::GetInstance();

    ImageArchiveLocator loc1 = GetImageArchiveLocator(options, true);
    ImageArchiveLocator loc2 = GetImageArchiveLocator(options, false);
    VideoSet* vidSet = GetVideoSet(options, true);
    String container = loc1.GetContainer();
    int nrArchives = (container == "ALL") ? vidSet->NrFiles() : 1;
    for (int i=0 ; i<nrArchives ; i++)
    {
        String cur = (container == "ALL") ? vidSet->GetFile(i) : container;
        int v = vidSet->GetFileId(cur);
        Quid quid = (v != -1) ? vidSet->GetQuidVideo(v, false) : 0;
        loc1.SetContainer(cur);
        loc1.SetQuid(quid);
        ImageArchive* archive = ImageArchiveRepository().Get(loc1);
        loc2.SetContainer(cur);
        loc2.SetQuid(quid);
        ImageArchiveRepository().Add(loc2, archive);
        delete archive;
    }
    delete vidSet;
}

// FeatureTable part

FeatureLocator
GetFeatureLocator(CmdOptions& options, bool getSrcLoc)
{
    ILOG_VAR(Impala.Application.Repository.GetFeatureLocator);

    int nrArg = 8;
    if (!getSrcLoc)
        nrArg++;
    if (options.GetNrArg() < nrArg)
    {
        ILOG_ERROR("Need at least " << nrArg << " parameters");
    }

    int a = 1;
    String locString = options.GetArg(a++);
    String setName = options.GetArg(a++);
    bool isCodebook = StringToBool(options.GetArg(a++));
    bool isIndex = StringToBool(options.GetArg(a++));
    String walkType = options.GetArg(a++);
    String feature = options.GetArg(a++);
    String container = options.GetArg(a++);
    if (!getSrcLoc)
        locString = options.GetArg(a++);
    return FeatureLocator(locString, setName, isCodebook, isIndex, walkType,
                          feature, container);
}

void
DoDumpFeatureTable()
{
    ILOG_VAR(Impala.Application.Repository.DoDumpFeatureTable);
    CmdOptions& options = CmdOptions::GetInstance();

    FeatureLocator loc = GetFeatureLocator(options, true);
    VideoSet* vidSet = GetVideoSet(options, true);
    String container = loc.GetContainer();
    int nrFiles = (container == "ALL") ? vidSet->NrFiles() : 1;
    for (int i=0 ; i<nrFiles ; i++)
    {
        String cur = (container == "ALL") ? vidSet->GetFile(i) : container;
        loc.SetContainer(cur);
        FeatureTable* tab = FeatureTableRepository().Get(loc);
        std::cout << "loc = " << loc << std::endl;
        tab->Dump(0, options.GetInt("start"), options.GetInt("end"));
        delete tab;
    }
}

void
DoDiffFeatureTable()
{
    ILOG_VAR(Impala.Application.Repository.DoDiffFeatureTable);
    CmdOptions& options = CmdOptions::GetInstance();

    FeatureLocator loc1 = GetFeatureLocator(options, true);
    FeatureLocator loc2 = GetFeatureLocator(options, false);
    VideoSet* vidSet = GetVideoSet(options, true);
    String container = loc1.GetContainer();
    int nrFiles = (container == "ALL") ? vidSet->NrFiles() : 1;
    for (int i=0 ; i<nrFiles ; i++)
    {
        String cur = (container == "ALL") ? vidSet->GetFile(i) : container;
        loc1.SetContainer(cur);
        FeatureTable* tab1 = FeatureTableRepository().Get(loc1);
        loc2.SetContainer(cur);
        FeatureTable* tab2 = FeatureTableRepository().Get(loc2);
        tab1->Diff(tab2);
        delete tab2;
        delete tab1;
    }
}

void
DoCopyFeatureTable()
{
    ILOG_VAR(Impala.Application.Repository.DoCopyFeatureTable);
    CmdOptions& options = CmdOptions::GetInstance();

    FeatureLocator loc1 = GetFeatureLocator(options, true);
    FeatureLocator loc2 = GetFeatureLocator(options, false);
    VideoSet* vidSet = GetVideoSet(options, true);
    String container = loc1.GetContainer();
    int nrFiles = (container == "ALL") ? vidSet->NrFiles() : 1;
    for (int i=0 ; i<nrFiles ; i++)
    {
        String cur = (container == "ALL") ? vidSet->GetFile(i) : container;
        loc1.SetContainer(cur);
        FeatureTable* tab = FeatureTableRepository().Get(loc1);
        loc2.SetContainer(cur);
        FeatureTableRepository().Add(loc2, tab);
        delete tab;
    }
}

// KeywordList part

KeywordListLocator
GetKeywordListLocator(CmdOptions& options, bool getSrcLoc)
{
    ILOG_VAR(Impala.Application.Repository.GetKeywordListLocator);

    int nrArg = 3;
    if (!getSrcLoc)
        nrArg++;
    if (options.GetNrArg() < nrArg)
    {
        ILOG_ERROR("Need at least " << nrArg << " parameters");
    }

    int a = 1;
    String locString = options.GetArg(a++);
    String setName = options.GetArg(a++);
    String conceptSet = options.GetArg(a++);
    if (!getSrcLoc)
        locString = options.GetArg(a++);
    return KeywordListLocator(locString, setName, conceptSet);
}

void
DoDumpKeywordList()
{
    ILOG_VAR(Impala.Application.Repository.DoDumpKeywordList);
    CmdOptions& options = CmdOptions::GetInstance();

    KeywordListLocator loc = GetKeywordListLocator(options, true);
    KeywordList keyList = *(KeywordListRepository().Get(loc));
    for (int i=0 ; i<keyList.size() ; i++)
        std::cout << keyList[i] << std::endl;
}

void
DoDiffKeywordList()
{
    ILOG_VAR(Impala.Application.Repository.DoDiffKeywordList);
    CmdOptions& options = CmdOptions::GetInstance();

    KeywordListLocator loc1 = GetKeywordListLocator(options, true);
    KeywordList keyList1 = *(KeywordListRepository().Get(loc1));
    KeywordListLocator loc2 = GetKeywordListLocator(options, false);
    KeywordList keyList2 = *(KeywordListRepository().Get(loc2));
    Core::Table::KeywordListDiff(keyList1, keyList2);    
}

void
DoCopyKeywordList()
{
    ILOG_VAR(Impala.Application.Repository.DoCopyKeywordList);
    CmdOptions& options = CmdOptions::GetInstance();

    KeywordListLocator loc1 = GetKeywordListLocator(options, true);
    KeywordList* keyList = KeywordListRepository().Get(loc1);
    KeywordListLocator loc2 = GetKeywordListLocator(options, false);
    KeywordListRepository().Add(loc2, keyList);
    delete keyList;
}

// AnnotationTable part

AnnotationTableLocator
GetAnnotationTableLocator(CmdOptions& options, bool getSrcLoc)
{
    ILOG_VAR(Impala.Application.Repository.GetAnnotationTableLocator);

    int nrArg = 6;
    if (!getSrcLoc)
        nrArg++;
    if (options.GetNrArg() < nrArg)
    {
        ILOG_ERROR("Need at least " << nrArg << " parameters");
    }

    int a = 1;
    String locString = options.GetArg(a++);
    String setName = options.GetArg(a++);
    int quidClass = StringToQuidClass(options.GetArg(a++));
    String conceptSet = options.GetArg(a++);
    String keyword = options.GetArg(a++);
    if (!getSrcLoc)
        locString = options.GetArg(a++);
    return AnnotationTableLocator(locString, setName, quidClass, conceptSet,
                                  keyword);
}

void
DoDumpAnnotationTable()
{
    ILOG_VAR(Impala.Application.Repository.DoDumpAnnotationTable);
    CmdOptions& options = CmdOptions::GetInstance();

    AnnotationTableLocator loc = GetAnnotationTableLocator(options, true);
    AnnotationTable* tab = AnnotationTableRepository().Get(loc);
    if (tab == 0)
        return;
    RawDataSet* dataSet = GetRawDataSet(options, false);
    tab->Dump(dataSet, options.GetInt("start"), options.GetInt("end"));
    tab->DumpSummary();
    delete tab;
    if (dataSet)
        delete dataSet;
}

void
DoDiffAnnotationTable()
{
    ILOG_VAR(Impala.Application.Repository.DoDiffAnnotationTable);
    CmdOptions& options = CmdOptions::GetInstance();

    AnnotationTableLocator loc1 = GetAnnotationTableLocator(options, true);
    AnnotationTable* tab1 = AnnotationTableRepository().Get(loc1);
    if (tab1 == 0)
        return;
    AnnotationTableLocator loc2 = GetAnnotationTableLocator(options, false);
    AnnotationTable* tab2 = AnnotationTableRepository().Get(loc2);
    tab1->Diff(tab2);
    delete tab2;
    delete tab1;
}

void
DoCopyAnnotationTable()
{
    ILOG_VAR(Impala.Application.Repository.DoCopyAnnotationTable);
    CmdOptions& options = CmdOptions::GetInstance();

    AnnotationTableLocator loc1 = GetAnnotationTableLocator(options, true);
    AnnotationTable* tab = AnnotationTableRepository().Get(loc1);
    if (tab == 0)
        return;
    AnnotationTableLocator loc2 = GetAnnotationTableLocator(options, false);
    AnnotationTableRepository().Add(loc2, tab);
    delete tab;
}

// AnnotationTableSet part

AnnotationTableSetLocator
GetAnnotationTableSetLocator(CmdOptions& options, bool getSrcLoc)
{
    ILOG_VAR(Impala.Application.Repository.GetAnnotationTableSetLocator);

    int nrArg = 5;
    if (!getSrcLoc)
        nrArg++;
    if (options.GetNrArg() < nrArg)
    {
        ILOG_ERROR("Need at least " << nrArg << " parameters");
    }

    int a = 1;
    String locString = options.GetArg(a++);
    String setName = options.GetArg(a++);
    int quidClass = StringToQuidClass(options.GetArg(a++));
    String conceptSet = options.GetArg(a++);
    if (!getSrcLoc)
        locString = options.GetArg(a++);
    return AnnotationTableSetLocator(locString, setName, quidClass, conceptSet);
}

void
DoDumpAnnotationTableSet()
{
    ILOG_VAR(Impala.Application.Repository.DoDumpAnnotationTableSet);
    CmdOptions& options = CmdOptions::GetInstance();

    int a = 5;
    bool dumpTable = atol(options.GetArg(a++));
    int maxV = -1;
    if (options.GetNrArg() > a)
        maxV = atol(options.GetArg(a++));
    int maxP = -1;
    if (options.GetNrArg() > a)
        maxP = atol(options.GetArg(a++));
    int maxN = -1;
    if (options.GetNrArg() > a)
        maxN = atol(options.GetArg(a++));

    AnnotationTableSetLocator loc = GetAnnotationTableSetLocator(options, true);
    AnnotationTableSet* tSet = AnnotationTableSetRepository().Get(loc);
    if (tSet == 0)
        return;
    RawDataSet* dataSet = GetRawDataSet(options, false);

    for (int i=0 ; i<tSet->Size() ; i++)
    {
        AnnotationTable* tab = tSet->GetTable(i);
        tab->DumpSummary();
        tab->DumpSummaryObject();
        if (dumpTable)
            tab->Dump(dataSet, options.GetInt("start"), options.GetInt("end"));
        if (maxV != -1)
        {
            tab->SelectQuidObjectMaxId(maxV);
            tab->SetLabel(tab->GetLabel() + "_maxV_" + MakeString(maxV));
            tab->DumpSummary();
            tab->DumpSummaryObject();
        }
        if (maxP != -1)
        {
            tab->SelectQuidObjectMaxPositive(maxP);
            tab->SetLabel(tab->GetLabel() + "_maxP_" + MakeString(maxP));
            tab->DumpSummary();
            tab->DumpSummaryObject();
        }
        if (maxN != -1)
        {
            tab->SelectQuidObjectMaxNegative(maxN);
            tab->SetLabel(tab->GetLabel() + "_maxN_" + MakeString(maxN));
            tab->DumpSummary();
            tab->DumpSummaryObject();
        }
    }

    delete tSet;
    if (dataSet)
        delete dataSet;
}

void
DoDiffAnnotationTableSet()
{
    ILOG_VAR(Impala.Application.Repository.DoDiffAnnotationTableSet);
    CmdOptions& options = CmdOptions::GetInstance();

    AnnotationTableSetLocator loc1 = GetAnnotationTableSetLocator(options, true);
    AnnotationTableSet* tSet1 = AnnotationTableSetRepository().Get(loc1);
    if (tSet1 == 0)
        return;
    AnnotationTableSetLocator loc2 = GetAnnotationTableSetLocator(options, false);
    AnnotationTableSet* tSet2 = AnnotationTableSetRepository().Get(loc2);
    tSet1->Diff(tSet2);
    delete tSet2;
    delete tSet1;
}

void
DoCopyAnnotationTableSet()
{
    ILOG_VAR(Impala.Application.Repository.DoCopyAnnotationTableSet);
    CmdOptions& options = CmdOptions::GetInstance();

    AnnotationTableSetLocator loc1 = GetAnnotationTableSetLocator(options, true);
    AnnotationTableSet* tSet = AnnotationTableSetRepository().Get(loc1);
    if (tSet == 0)
        return;
    AnnotationTableSetLocator loc2 = GetAnnotationTableSetLocator(options, false);
    AnnotationTableSetRepository().Add(loc2, tSet);
    delete tSet;
}

// SimilarityTableSet part

SimilarityTableSetLocator
GetSimilarityTableSetLocator(CmdOptions& options, bool getSrcLoc)
{
    ILOG_VAR(Impala.Application.Repository.GetSimilarityTableSetLocator);

    int nrArg = 9;
    if (!getSrcLoc)
        nrArg++;
    if (options.GetNrArg() < nrArg)
    {
        ILOG_ERROR("Need at least " << nrArg << " parameters");
    }

    int a = 1;
    String locString = options.GetArg(a++);
    String setName = options.GetArg(a++);
    bool inIndex = StringToBool(options.GetArg(a++));
    String walkType = options.GetArg(a++);
    String conceptSet = options.GetArg(a++);
    String model = options.GetArg(a++);
    String feature = options.GetArg(a++);
    String container = options.GetArg(a++);
    if (!getSrcLoc)
        locString = options.GetArg(a++);
    return SimilarityTableSetLocator(locString, setName, inIndex, walkType,
                                     conceptSet, model, feature, container);
}

void
DoDumpSimilarityTableSet()
{
    ILOG_VAR(Impala.Application.Repository.DoDumpSimilarityTableSet);
    CmdOptions& options = CmdOptions::GetInstance();

    SimilarityTableSetLocator loc = GetSimilarityTableSetLocator(options, true);
    VideoSet* vidSet = GetVideoSet(options, true);
    String container = loc.GetContainer();
    int nrFiles = (container == "ALL") ? vidSet->NrFiles() : 1;
    for (int i=0 ; i<nrFiles ; i++)
    {
        String cur = (container == "ALL") ? vidSet->GetFile(i) : container;
        loc.SetContainer(cur);
        SimilarityTableSet* simSet = SimilarityTableSetRepository().Get(loc);
        simSet->DumpRanking(0, options.GetInt("start"), options.GetInt("end"));
        delete simSet;
    }
}

void
DoDiffSimilarityTableSet()
{
    ILOG_VAR(Impala.Application.Repository.DoDiffSimilarityTableSet);
    CmdOptions& options = CmdOptions::GetInstance();

    SimilarityTableSetLocator loc1 = GetSimilarityTableSetLocator(options, true);
    SimilarityTableSetLocator loc2 = GetSimilarityTableSetLocator(options, false);
    VideoSet* vidSet = GetVideoSet(options, true);
    String container = loc1.GetContainer();
    int nrFiles = (container == "ALL") ? vidSet->NrFiles() : 1;
    for (int i=0 ; i<nrFiles ; i++)
    {
        String cur = (container == "ALL") ? vidSet->GetFile(i) : container;
        loc1.SetContainer(cur);
        SimilarityTableSet* simSet1 = SimilarityTableSetRepository().Get(loc1);

        loc2.SetContainer(cur);
        SimilarityTableSet* simSet2 = SimilarityTableSetRepository().Get(loc2);
        simSet1->Diff(simSet2);
        delete simSet2;
        delete simSet1;
    }
}

void
DoCopySimilarityTableSet()
{
    ILOG_VAR(Impala.Application.Repository.DoCopySimilarityTableSet);
    CmdOptions& options = CmdOptions::GetInstance();

    SimilarityTableSetLocator loc1 = GetSimilarityTableSetLocator(options, true);
    SimilarityTableSetLocator loc2 = GetSimilarityTableSetLocator(options, false);
    VideoSet* vidSet = GetVideoSet(options, true);
    String container = loc1.GetContainer();
    int nrFiles = (container == "ALL") ? vidSet->NrFiles() : 1;
    for (int i=0 ; i<nrFiles ; i++)
    {
        String cur = (container == "ALL") ? vidSet->GetFile(i) : container;
        loc1.SetContainer(cur);
        SimilarityTableSet* simSet = SimilarityTableSetRepository().Get(loc1);

        loc2.SetContainer(cur);
        SimilarityTableSetRepository().Add(loc2, simSet);
        delete simSet;
    }
}

int
mainRepository(int argc, char* argv[])
{
    CmdOptions& options = CmdOptions::GetInstance();
    options.Initialise(false, false, true);
    options.AddOption(0, "start", "nr", "0");
    options.AddOption(0, "end", "nr", "-1");
    String usageStr = "cmd = \n\n";
    usageStr += "  dumpimagesets\n";
    usageStr += "  dumpvideosets\n";
    usageStr += "  copyvideosets dstLocation\n";
    usageStr += "  dumpimageset location imageset.txt\n";
    usageStr += "  diffimageset location1 imageset.txt location2\n";
    usageStr += "  copyimageset location1 imageset.txt location2\n";
    usageStr += "  dumpvideoset location videoset.txt\n";
    usageStr += "  diffvideoset location1 videoset.txt location2\n";
    usageStr += "  copyvideoset location1 videoset.txt location2\n";
    usageStr += "  dumpsegmentation location videoset.txt\n";
    usageStr += "  diffsegmentation location1 videoset.txt location2\n";
    usageStr += "  copysegmentation location1 videoset.txt location2\n";
    usageStr += "  dumpkeyframes location videoset.txt\n";
    usageStr += "  diffkeyframes location1 videoset.txt location2\n";
    usageStr += "  copykeyframes location1 videoset.txt location2\n";
    usageStr += "  dumpstills location videoset.txt\n";
    usageStr += "  dumpimagearchive location dataset.txt isFrames container name.raw\n";
    usageStr += "  diffimagearchive location1 dataset.txt isFrames container name.raw location2\n";
    usageStr += "  copyimagearchive location1 dataset.txt isFrames container name.raw location2\n";
    usageStr += "  dumpfeaturetable location dataset.txt isCodebook isIndex walkType feature container\n";
    usageStr += "  difffeaturetable location1 dataset.txt isCodebook isIndex walkType feature container location2\n";
    usageStr += "  copyfeaturetable location1 dataset.txt isCodebook isIndex walkType feature container location2\n";
    usageStr += "  dumpkeywordlist location videoset.txt concepts.txt\n";
    usageStr += "  diffkeywordlist location1 videoset.txt concepts.txt location2\n";
    usageStr += "  copykeywordlist location1 videoset.txt concepts.txt location2\n";
    usageStr += "  dumpannotationtable location dataset.txt quidClass concepts.txt keyword\n";
    usageStr += "  diffannotationtable location1 dataset.txt quidClass concepts.txt keyword location2\n";
    usageStr += "  copyannotationtable location1 dataset.txt quidClass concepts.txt keyword location2\n";
    usageStr += "  dumpannotationtableset location dataset.txt quidClass concepts.txt doTable [maxVidId maxPos maxNeg]\n";
    usageStr += "  diffannotationtableset location1 dataset.txt quidClass concepts.txt location2\n";
    usageStr += "  copyannotationtableset location1 dataset.txt quidClass concepts.txt location2\n";
    usageStr += "  dumpsimilaritytableset location dataset.txt isIndex walkType conceptSet.txt model feature container\n";
    usageStr += "  diffsimilaritytableset location1 dataset.txt isIndex walkType conceptSet.txt model feature container location2\n";
    usageStr += "  copysimilaritytableset location1 dataset.txt isIndex walkType conceptSet.txt model feature container location2\n";
    if (! options.ParseArgs(argc, argv, usageStr, 1))
        return 1;

    ILOG_VAR(Impala.Application.Repository.mainRepository);

    String cmd = options.GetArg(0);
    ILOG_DEBUG("cmd = " << cmd);
    if (cmd == "dumpimagesets")
        DoDumpImageSets();
    else if (cmd == "dumpvideosets")
        DoDumpVideoSets();
    else if (cmd == "copyvideosets")
        DoCopyVideoSets();
    else if (cmd == "dumpimageset")
        DoDumpImageSet();
    else if (cmd == "diffimageset")
        DoDiffImageSet();
    else if (cmd == "copyimageset")
        DoCopyImageSet();
    else if (cmd == "dumpvideoset")
        DoDumpVideoSet();
    else if (cmd == "diffvideoset")
        DoDiffVideoSet();
    else if (cmd == "copyvideoset")
        DoCopyVideoSet();
    else if (cmd == "dumpsegmentation")
        DoDumpSegmentation();
    else if (cmd == "diffsegmentation")
        DoDiffSegmentation();
    else if (cmd == "copysegmentation")
        DoCopySegmentation();
    else if (cmd == "dumpkeyframes")
        DoDumpKeyframes();
    else if (cmd == "diffkeyframes")
        DoDiffKeyframes();
    else if (cmd == "copykeyframes")
        DoCopyKeyframes();
    else if (cmd == "dumpimagearchive")
        DoDumpImageArchive();
    else if (cmd == "diffimagearchive")
        DoDiffImageArchive();
    else if (cmd == "copyimagearchive")
        DoCopyImageArchive();
    else if (cmd == "dumpfeaturetable")
        DoDumpFeatureTable();
    else if (cmd == "difffeaturetable")
        DoDiffFeatureTable();
    else if (cmd == "copyfeaturetable")
        DoCopyFeatureTable();
    else if (cmd == "dumpkeywordlist")
        DoDumpKeywordList();
    else if (cmd == "diffkeywordlist")
        DoDiffKeywordList();
    else if (cmd == "copykeywordlist")
        DoCopyKeywordList();
    else if (cmd == "dumpannotationtable")
        DoDumpAnnotationTable();
    else if (cmd == "diffannotationtable")
        DoDiffAnnotationTable();
    else if (cmd == "copyannotationtable")
        DoCopyAnnotationTable();
    else if (cmd == "dumpannotationtableset")
        DoDumpAnnotationTableSet();
    else if (cmd == "diffannotationtableset")
        DoDiffAnnotationTableSet();
    else if (cmd == "copyannotationtableset")
        DoCopyAnnotationTableSet();
    else if (cmd == "dumpsimilaritytableset")
        DoDumpSimilarityTableSet();
    else if (cmd == "diffsimilaritytableset")
        DoDiffSimilarityTableSet();
    else if (cmd == "copysimilaritytableset")
        DoCopySimilarityTableSet();
    else ILOG_ERROR("Unknown cmd : " << cmd);

    return 0;
}

} // namespace Repository
} // namespace Application
} // namespace Impala

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

---