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

---

mainVidSet.cpp

Go to the documentation of this file.

#ifndef REPOSITORY_USED // Here comes the deprecated stuff
#else // REPOSITORY_USED
#define REPOSITORY_TODO
#endif // REPOSITORY_USED

#include "Basis/FileName.h"
#include "Core/Table/Sort.h"
#include "Core/VideoSet/SelectFrames.h"
#include "Core/VideoSet/ClusterFeatures.h"
#include "Core/VideoSet/ExportFeatures.h"
#include "Core/VideoSet/ImportAudioConcepts.h"
#include "Core/VideoSet/IndexAnnotation.h"
#include "Core/VideoSet/CombineConcepts.h"
#include "Core/VideoSet/TaskTable.h"
#include "Core/VideoSet/ExportConcepts.h"
#include "Core/VideoSet/IndexConcepts.h"
#include "Core/VideoSet/ImportConcepts.h"
#include "Core/VideoSet/ApplyConcepts.h"
#include "Core/VideoSet/ConcatFeatures.h"
#include "Link/Mpi/MpiFuncs.h"
#include "Core/VideoSet/TestVideo.h"
#include "Core/VideoSet/CheckNrFrames.h"
#include "Core/VideoSet/IndexSegmentation.h"
#include "Core/VideoSet/ProtoSimilarityEval.h"
#include "Core/Feature/VisSem.h"
#include "Core/VideoSet/ShotSegmenter.h"
#include "Core/VideoSet/IndexFeatures.h"
#include "Core/VideoSet/ExportKeyframes.h"
#include "Core/VideoSet/ExportStills.h"
#include "Core/VideoSet/VisSemGaborStat.h"
#include "Core/VideoSet/LabHistExtractor.h"
#include "Core/VideoSet/LabHist3dExtractor.h"
#include "Core/VideoSet/RgbHistExtractor.h"
#include "Core/VideoSet/ExportFrames.h"
#include "Core/VideoSet/ExportFrameHashes.h"
#include "Core/VideoSet/VisSemTrain.h"
#include "Core/VideoSet/Reporter.h"
#include "Core/VideoSet/Walker.h"
#include "Core/VideoSet/MakeVideoSet.h"
#include "Core/Array/MakeGaussian1d.h"
#include "Core/VideoSet/ComputeKernelData.h"
#include "Core/VideoSet/InterestPointProc.h"
#include "Core/VideoSet/BlackFrameProc.h"
#include "Core/VideoSet/MakeQuidLookup.h"
#include "Core/VideoSet/LbpEval.h"
#ifndef REPOSITORY_TODO
#include "Link/DiskImage/DiskImageFuncs.h"
#include "Core/VideoSet/VideoIndexValidator.h"
#endif
#include "Core/VideoSet/BlackFrameDetect.h"
#include "Core/VideoSet/KfrMotionExtractor.h"
#include "Persistency/TaskTableRepository.h"

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

namespace Impala
{
namespace Application
{
namespace VidSet
{

using namespace Impala::Core::Array;
using namespace Impala::Core::Feature;
using namespace Impala::Core::VideoSet;


TaskTable*
MakeVideoTaskTableByQuids(VideoSet* videoSet, Walker* walker)
{
    ILOG_VAR(Impala.Application.VidSet.MakeVideoTaskTableByQuids);
    CmdOptions& options = CmdOptions::GetInstance();
    int startFile = options.GetInt("startFile");
    int numberFiles = options.GetInt("numberFiles");
    if (numberFiles == -1)
        numberFiles = videoSet->NrFiles();
    if (startFile + numberFiles >= videoSet->NrFiles())
        numberFiles = videoSet->NrFiles() - startFile;
    TaskTable* taskTable = new TaskTable();
    Core::Table::QuidTable* quids = walker->GetQuids();
    for (int i=startFile ; i<startFile+numberFiles ; i++)
        taskTable->Add(i, 1, quids->GetNrQuidsObject(i));
    Core::Table::Sort(taskTable, 3, false);
    for (int i=0 ; i<taskTable->Size() ; i++)
        taskTable->Set3(i, 0);
    return taskTable;
}

TaskTable*
MakeVideoTaskTableByVideoSize(VideoSet* videoSet, Walker* walker)
{
    ILOG_VAR(Impala.Application.VidSet.MakeVideoTaskTableByVideoSize);
    CmdOptions& options = CmdOptions::GetInstance();
    int startFile = options.GetInt("startFile");
    int numberFiles = options.GetInt("numberFiles");
    Segmentation* segmentation = walker->GetSegmentation();
    if (segmentation == 0)
    {
        ILOG_ERROR("Need segmentation");
        return 0;
    }
    if (numberFiles == -1)
        numberFiles = videoSet->NrFiles();
    if (startFile + numberFiles >= videoSet->NrFiles())
        numberFiles = videoSet->NrFiles() - startFile;
    TaskTable* taskTable = new TaskTable();
    for (int i=startFile ; i<startFile+numberFiles ; i++)
        taskTable->Add(i, 1, segmentation->GetNrFramesVideo(i));
    Core::Table::Sort(taskTable, 3, false);
    for (int i=0 ; i<taskTable->Size() ; i++)
        taskTable->Set3(i, 0);
    return taskTable;
}

TaskTable*
MakeVideoTaskTableByKeyframes(VideoSet* videoSet, Walker* walker)
{
    ILOG_VAR(Impala.Application.VidSet.MakeVideoTaskTableByKeyframes);
    CmdOptions& options = CmdOptions::GetInstance();
    int startFile = options.GetInt("startFile");
    int numberFiles = options.GetInt("numberFiles");
    Keyframes* keyframes = walker->GetKeyframes();
    if (keyframes == 0)
    {
        ILOG_ERROR("Need keyframes");
        return 0;
    }
    if (numberFiles == -1)
        numberFiles = videoSet->NrFiles();
    if (startFile + numberFiles >= videoSet->NrFiles())
        numberFiles = videoSet->NrFiles() - startFile;
    TaskTable* taskTable = new TaskTable();
    for (int i=startFile ; i<startFile+numberFiles ; i++)
        taskTable->Add(i, 1, keyframes->GetNrKeyframesVideo(i));
    Core::Table::Sort(taskTable, 3, false);
    for (int i=0 ; i<taskTable->Size() ; i++)
        taskTable->Set3(i, 0);
    return taskTable;
}

TaskTable*
MakeVideoTaskTableByFrames(VideoSet* videoSet, Walker* walker)
{
    ILOG_VAR(Impala.Application.VidSet.MakeVideoTaskTableByFrames);
    CmdOptions& options = CmdOptions::GetInstance();
    int startFile = options.GetInt("startFile");
    int numberFiles = options.GetInt("numberFiles");
    int stepSize = options.GetInt("stepSize");
    int numberFrames = options.GetInt("numberFrames");
    Segmentation* segmentation = walker->GetSegmentation();
    if (segmentation == 0)
    {
        ILOG_ERROR("Need segmentation");
        return 0;
    }
    if (numberFiles == -1)
        numberFiles = videoSet->NrFiles();
    if (startFile + numberFiles >= videoSet->NrFiles())
        numberFiles = videoSet->NrFiles() - startFile;
    int curFile = startFile;
    int curFrame = 0;
    TaskTable* taskTable = new TaskTable();
    while (numberFiles > 0)
    {
        taskTable->Add(curFile, 1, curFrame);
        curFrame += numberFrames * stepSize;
        if (curFrame > segmentation->GetNrFramesVideo(curFile))
        {
            curFrame = 0;
            curFile++;
            numberFiles--;
        }
    }
    return taskTable;
}

TaskTable*
MakeVideoTaskTableByVideo(VideoSet* videoSet, Walker* walker)
{
    CmdOptions& options = CmdOptions::GetInstance();
    int startFile = options.GetInt("startFile");
    int numberFiles = options.GetInt("numberFiles");
    int startFrame = options.GetInt("startFrame");
    int numProcs = Link::Mpi::NrProcs();
    if (numberFiles == -1)
        numberFiles = videoSet->NrFiles();
    if (startFile + numberFiles >= videoSet->NrFiles())
        numberFiles = videoSet->NrFiles() - startFile;
    int lastFile = startFile + numberFiles;
    int taskSize = numberFiles / numProcs;
    int restSize = numberFiles % numProcs;
    int curFile = startFile;
    TaskTable* taskTable = new TaskTable();
    for (int i=0 ; i<numProcs ; i++)
    {
        startFile = curFile;
        numberFiles = taskSize;
        if (--restSize >= 0)
            numberFiles++;
        if (startFile + numberFiles > lastFile)
            numberFiles = lastFile - startFile;
        curFile += numberFiles;
        taskTable->Add(startFile, numberFiles, startFrame);
    }
    return taskTable;
}

TaskTable*
MakeVideoTaskTable(VideoSet* videoSet, Walker* walker, String cmd, String quidFile)
{
    CmdOptions& options = CmdOptions::GetInstance();
    int startTask = options.GetInt("startTask");
    if ((cmd == "tasktable") || (startTask != -1))
    {
        if (!quidFile.empty())
            return MakeVideoTaskTableByQuids(videoSet, walker);
        if (options.GetBool("taskByVideoSize"))
            return MakeVideoTaskTableByVideoSize(videoSet, walker);
        if (options.GetBool("keyframes"))
            return MakeVideoTaskTableByKeyframes(videoSet, walker);
        return MakeVideoTaskTableByFrames(videoSet, walker);
    }
    return MakeVideoTaskTableByVideo(videoSet, walker);
}

int
GetVideoTask()
{
    CmdOptions& options = CmdOptions::GetInstance();
    if (options.GetBool("virtualWalkAll"))
        return 0;
    int startTask = options.GetInt("startTask");
    if (startTask == -1)
        startTask = 0;
    return startTask + Link::Mpi::MyId();
}

int
mainVidSet(int argc, char* argv[])
{
    Link::Mpi::Init(&argc, &argv);

    CmdOptions& options = CmdOptions::GetInstance();
    options.Initialise(true, false, true);
    options.AddOption(0, "report", "perNr", "0");
    options.AddOption(0, "startFile", "idx", "0");
    options.AddOption(0, "numberFiles", "nr", "-1");
    options.AddOption(0, "segmentation", "", "0");
    options.AddOption(0, "keyframes", "", "0");
    options.AddOption(0, "rkfMask", "", "0");
    options.AddOption(0, "keyframeMask", "file", "");
    options.AddOption(0, "keyframeMaskAnno", "file", "");
    options.AddOption(0, "quidWalk", "file", "");
    options.AddOption(0, "startTask", "idx", "-1");
    options.AddOption(0, "nrTaskWalk", "nr", "1"); // quick hack for process mgt
    options.AddOption(0, "taskByVideoSize", "", "0");
    options.AddOption(0, "virtualWalkAll", "", "0");
    options.AddOption(0, "maskFile", "file", "");
    options.AddOption(0, "featureIndexCat", "name", "");
    options.AddOption(0, "classifyIndexCat", "name", "");
    options.AddOption(0, "precomputed", "[only works for applyconcepts] boolean: if 1 modelfiles must be for precomputed kernel", "0");
    options.AddOption(0, "storeKernelData", "[only works for applyconcepts] boolean: if 1 kernel data will be written to disk", "0");
    options.AddOption(0, "kernelDataOnly", "[only works for applyconcepts] boolean: if 1 only kernel data will be computed (no model apply)", "0");
    options.AddOption(0, "fik", "[only works for applyconcepts] boolean: if 1 modelfiles must be for fast intersection kernel", "0");
    options.AddOption(0, "msf-feature", "bool [for lbpeval]", "0");

    WalkerConfig walkerConfig;
    walkerConfig.InitOptions(options);

    // initialization of options
    Impala::Core::VideoSet::InterestPointProc::AddCmdOptions();

    // Below are ShotSegmenter specific options   
    options.AddOption(0, "SSProbThresh", "value", "0.5");
    options.AddOption(0, "SSNoMpeg7", "", "0");
    options.AddOption(0, "SSNoSim", "", "0");
    options.AddOption(0, "SSNoNrkf", "", "0");

    if (! options.ParseArgs(argc, argv, "cmd videoSet|vxs|dbsection/file", 2))
    {
        Link::Mpi::Finalize();
        return 1;
    }

    ILOG_VAR(Impala.Application.VidSet.mainVidSet);

    ILOG_INFO("Disk images are " <<
              (Link::DiskImage::DiskImageUsed() ? "" : "not ") << "supported");

    String cmd = options.GetArg(0);
    String fileName = options.GetArg(1);

    VideoSet* videoSet = MakeVideoSet(fileName);

    walkerConfig.RetrieveOptions(options);
    Walker walker(videoSet, walkerConfig);
    Reporter* reporter = new Reporter(0);
    walker.AddListener(reporter);

    ILOG_INFO("vidset command : " << cmd);

    if (cmd == "computekerneldata")
        walker.AddListener(new ComputeKernelData(reporter, options));
    if (cmd == "testvideo")
        walker.AddListener(new TestVideo(reporter, options));
#ifndef REPOSITORY_TODO
    if (cmd == "validatevideoindex")
        walker.AddListener(new VideoIndexValidator(reporter, options));
#endif
    if (cmd == "checknrframes")
        walker.AddListener(new CheckNrFrames(reporter, options));
    if (cmd == "shotsegmenter")
        walker.AddListener(new ShotSegmenter(reporter, options));
    if (cmd == "selectframes")
        walker.AddListener(new SelectFrames(reporter, options));
    if (cmd == "indexsegmentation")
        walker.AddListener(new IndexSegmentation(reporter, options));
    if (cmd == "indexannotation")
        walker.AddListener(new IndexAnnotation(reporter, options));
    if (cmd == "applyconcepts")
        walker.AddListener(new ApplyConcepts(reporter, options, videoSet,false));
    if (cmd == "applyconceptsindex")
        walker.AddListener(new ApplyConcepts(reporter, options, videoSet, true));
    if (cmd == "combineconcepts")
        walker.AddListener(new CombineConcepts(reporter, options));
    if (cmd == "indexconcepts")
        walker.AddListener(new IndexConcepts(reporter, options, videoSet));
    if (cmd == "exportconcepts")
        walker.AddListener(new ExportConcepts(reporter, options));
    if (cmd == "importconcepts")
        walker.AddListener(new ImportConcepts(reporter, options));
    if (cmd == "importaudioconcepts")
        walker.AddListener(new ImportAudioConcepts(reporter, options));

    if (cmd == "exportframes")
        walker.AddListener(new ExportFrames(reporter, options));
    if (cmd == "exportkeyframes")
        walker.AddListener(new ExportKeyframes(reporter, options, videoSet));
    if (cmd == "exportstills")
        walker.AddListener(new ExportStills(reporter, options));
    if (cmd == "exportframehashes")
        walker.AddListener(new ExportFrameHashes(reporter, options));

    if (cmd == "vistrain")
        walker.AddListener(new VisSemTrain(reporter, "vissem", options));
    if (cmd == "visgabortrain")
        walker.AddListener(new VisSemTrain(reporter, "vissemgabor", options));

    if (cmd == "viseval")
    {
        Computor* c = new VisSem("vissem", options);
        walker.AddListener(new ProtoSimilarityEval(c, reporter, options));
    }
    if (cmd == "visgaboreval")
    {
        Computor* c = new VisSem("vissemgabor", options);
        walker.AddListener(new ProtoSimilarityEval(c, reporter, options));
    }
    if (cmd == "lbpeval")
        walker.AddListener(new LbpEval(reporter, options));

    if (cmd == "visgaborstat")
        walker.AddListener(new VisSemGaborStat(reporter, options));

    if (cmd == "clusterfeatures")
    {
        if (options.GetNrArg() < 4)
            ILOG_ERROR("cluster: missing argument");
        String feature = options.GetArg(2);
        Computor* c = 0;
        if (feature == "weibull")
            c = new VisSem("vissem", options);
        if (feature == "gabor")
            c = new Core::Feature::VisSem("vissemgabor", options);
        String clusteror = options.GetArg(3);
        walker.AddListener(new ClusterFeatures(c, clusteror, reporter, options));
    }

    if (cmd == "extractlab")
        walker.AddListener(new LabHistExtractor(reporter, options));
    if (cmd == "extractlab3d")
        walker.AddListener(new LabHist3dExtractor(reporter, options));
    if (cmd == "extractrgb")
        walker.AddListener(new RgbHistExtractor(reporter, options));

    if (cmd == "indexfeatures")
        walker.AddListener(new IndexFeatures(reporter, options));
    if (cmd == "concatfeatures")
        walker.AddListener(new ConcatFeatures(reporter, options));
    if (cmd == "exportfeatures")
        walker.AddListener(new ExportFeatures(reporter, options));
    if (cmd == "interestpointproc")
        walker.AddListener(new InterestPointProc(reporter, options));
    if (cmd == "blackframeproc")
        walker.AddListener(new BlackFrameProc(reporter, options));
    if (cmd == "makequidlookup")
        walker.AddListener(new MakeQuidLookup(reporter, options));

    if ((walker.NrListeners() == 1) && !((cmd == "nop") || (cmd == "tasktable")))
    {
        ILOG_ERROR("Unknown command : " << cmd);
        Link::Mpi::Finalize();
        return 1;
    }

    walker.AddListener(new Reporter(reporter));
    if (FileNameExt(fileName) == "vxs")
    {
        walker.LoadBookmarks(fileName);
        reporter->SetTotalNrFramesInBookmarks(walker.TotalNrFramesInBookmarks());
        walker.DoWalkBookmarks();
    }
    else
    {
        if (options.GetBool("keyframes"))
        {
            walker.LoadKeyframes("keyframes");
            if (options.GetBool("rkfMask"))
                walker.AddRkfMask();
            if (options.GetString("keyframeMaskAnno") != "")
                walker.AddKeyframeMaskAnnoFile(options.GetString("keyframeMaskAnno"));
        }
        if (options.GetBool("segmentation"))
            walker.LoadSegmentation("segmentation");
        String quidFile = options.GetString("quidWalk");
        if (!quidFile.empty())
        {
            walker.LoadQuids(quidFile);
        }

        TaskTable* taskTable = MakeVideoTaskTable(videoSet, &walker, cmd,
                                                  quidFile);
        if ((Link::Mpi::MyId() == 0) && (cmd == "tasktable"))
        {
            taskTable->Dump();
            Persistency::TaskTableLocator loc(videoSet->GetLocator(),
                                              "tasktable.tab");
            Persistency::TaskTableRepository().Add(loc, taskTable);
        }
        int taskIdx = GetVideoTask();
        int nrTaskWalk = options.GetInt("nrTaskWalk");
        int numProcs = Link::Mpi::NrProcs();
        for (int walk=0 ; walk<nrTaskWalk ; walk++)
        {
            int t = taskIdx + walk*numProcs;
            if (t >= taskTable->Size())
            {
                ILOG_WARN("Task index out of range");
                continue;
            }
            int startFile = taskTable->GetStartFile(t);
            int numberFiles = taskTable->GetNumberFiles(t);
            if (options.GetBool("virtualWalkAll")
                && (options.GetInt("numberFiles") == -1))
            {
                numberFiles = videoSet->NrFiles();
            }
            int startFrame = taskTable->GetStartFrame(t);
            ILOG_INFO("Process " << Link::Mpi::MyId() << " of " <<
                      Link::Mpi::NrProcs() << " is doing file " << startFile
                      << " till " << startFile + numberFiles << " from frame "
                      << startFrame);

            if (!quidFile.empty())
            {
                walker.DoWalkQuids(startFile, numberFiles);
            }
            else if (options.GetBool("keyframes"))
            {
                walker.DoWalkKeyframes(startFile, numberFiles);
            }
            else
            {
                walker.DoWalk(startFile, numberFiles, startFrame);
            }
        }
        delete taskTable;
    }

    reporter->FinalReport();

    int nrOfErrors = ILOG_ERROR_COUNT;
    ILOG_DEBUG("nr of errors collected = " << nrOfErrors);

    nrOfErrors = Link::Mpi::ReduceSum(nrOfErrors);
    ILOG_INFO_HEADNODE("Root: total nr error = " << nrOfErrors);
    Link::Mpi::Finalize();

    return nrOfErrors;
}

} // namespace VidSet
} // namespace Application
} // namespace Impala

int
main(int argc, char* argv[])
{

#ifdef NO_DIALOGONCRASH
#ifdef WIN32
    DWORD oldMode = ::SetErrorMode(SEM_NOGPFAULTERRORBOX);
    ::SetErrorMode(oldMode | SEM_NOGPFAULTERRORBOX);
#endif
#endif

    int result = Impala::Application::VidSet::mainVidSet(argc, argv);
    return result;
}

---