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

---

ExportStills.h

Go to the documentation of this file.

#ifndef Impala_Core_VideoSet_ExportStills_h
#define Impala_Core_VideoSet_ExportStills_h

#include "Persistency/ImageSetRepository.h"
#include "Persistency/StillsRepository.h"
#include "Core/VideoSet/Reporter.h"
#include "Core/VideoSet/Segmentation.h"
#include "Core/VideoSet/Stills.h"
#include "Core/ImageSet/MakeImageSet.h"
#include "Core/Array/Set.h"
#include "Core/Array/Scale.h"
#include "Core/Array/WriteRaw.h"
#include "Core/Array/WriteJpg.h"
#include "Core/Array/ArrayListDelete.h"
#include "Link/DiskImage/DiskImageFuncs.h"

namespace Impala
{
namespace Core
{
namespace VideoSet
{


class ExportStills : public Listener
{
public:
    typedef Array::Array2dVec3UInt8 Array2dVec3UInt8;
    typedef Array::Array2dScalarUInt8 Array2dScalarUInt8;

    ExportStills(Reporter* reporter, CmdOptions& options)
    {
        mReporter = reporter;
        mImSet = 0;
        mStills = 0;
        mSkipFr = 15;
        mNrIm = 16;
        mDoFullSize = true;
        mBufSize = 1000000;
        mBuf = new char[mBufSize];
        mNr = 0;
        mDoDef = false;
        mDoData = false;
        if (options.GetNrArg() < 3)
        {
            ILOG_ERROR("Need argument [def|data]");
        }
        else
        {
            if (options.GetArg(2) == "def")
                mDoDef = true;
            else if (options.GetArg(2) == "data")
                mDoData = true;
            else
            {
                ILOG_ERROR("Argument should be def or data");
            }
            if (options.GetNrArg() > 3)
                Core::Array::gWriteJpgQuality = atol(options.GetArg(3));
        }
    }

    virtual
    ~ExportStills()
    {
        delete mBuf;
    }

    virtual void
    HandleNewWalk(VideoSet* vs)
    {
#ifndef REPOSITORY_USED // Here comes the deprecated stuff
        mSegmentation = new Segmentation(vs, "segmentation");
#else // REPOSITORY_USED
        Persistency::SegmentationLocator loc(vs->GetLocator(), "segmentation");
        mSegmentation = Persistency::SegmentationRepository().Get(loc, vs);
#endif // REPOSITORY_USED
        ILOG_INFO(mSegmentation->GetNrShots() << " shots");
        String name("stills.txt");
        mImSetLoc = Persistency::ImageSetLocator(vs->GetLocator(), name);
        mStillsLoc = Persistency::StillsLocator(vs->GetLocator(), "stills");

        if (mDoDef)
        {
#ifndef REPOSITORY_USED // Here comes the deprecated stuff
            mImSet = new ImageSet::ImageSet(vs->GetDatabase(), name, false);
#else // REPOSITORY_USED
            mImSet = new ImageSet::ImageSet(name);
#endif // REPOSITORY_USED
            mStills = new Stills(vs, "");
        }
        if (mDoData)
        {
            ILOG_INFO("reading image set " << name);
#ifndef REPOSITORY_USED // Here comes the deprecated stuff
            mImSet = new ImageSet::ImageSet(vs->GetDatabase(), name, true);
            mStills = new Stills(vs, "stills");
#else // REPOSITORY_USED
            mImSet =  Persistency::ImageSetRepository().Get(mImSetLoc);
            mStills = Persistency::StillsRepository().Get(mStillsLoc, vs);
#endif // REPOSITORY_USED
            ILOG_INFO("reading stills");
            ILOG_INFO(mStills->GetNrStills() << " stills");
            if (mImSet->NrDirs() != vs->NrFiles())
            {
                ILOG_WARN("Number of still dirs doesn't match number of videos: "
                          << mImSet->NrDirs() << " vs. " << vs->NrFiles());
            }
        }
        mTimer.Start();
    }

    virtual void
    HandleNewFile(VideoSet* vs, int fileId, Stream::RgbDataSrc* src)
    {
        std::vector<Array2dScalarUInt8*> imList;
        String dbSec(FileNameBase(vs->GetSetName()) + "_stills");
        String dbDir = vs->GetFile(fileId);
        String dirOfFile = vs->GetDirOfFile(fileId);

        if (Link::DiskImage::DiskImageUsed())
        {
            dbSec = vs->GetAsPath(fileId);
            int posSep = dbSec.find_last_of('/');
            dbSec = "stills/" + dbSec.substr(0, posSep);
        }
        else
        {
            dbSec = "stills/" + vs->GetSectionOfFile(fileId) + "/" + dirOfFile;
        }

        int firstS = mSegmentation->GetFirstShotVideo(fileId);
        int lastS = firstS + mSegmentation->GetNrShotsVideo(fileId);
        for (int shot=firstS ; shot<lastS ; shot++)
        {
            int startF = mSegmentation->GetStart(shot);
            int endF = mSegmentation->GetEnd(shot);
            int interval = (endF - startF) / (mNrIm - 1);
            if (interval < mSkipFr)
                interval = mSkipFr;
            ILOG_DEBUG("Doing shot " << shot << " from " << startF << " to "
                       << endF << " interval " << interval);
            if (mDoData && (interval < 100))
                src->SetInterval(interval);

            int i=0;
            while (startF <= endF)
            {
                if (mDoData)
                {
                    ILOG_DEBUG("Doing frame " << startF);
                    src->GotoFrame(startF);
                    Array2dVec3UInt8* im = Array::ArrayCreate<Array2dVec3UInt8>
                        (src->FrameWidth(), src->FrameHeight(), 0, 0,
                         src->DataPtr(), true);
                    Array2dVec3UInt8* sc = 0;
                    if (mDoFullSize)
                        Array::Set(sc, im);
                    else
                        Array::Scale(sc, im, 0.5, 0.5, Geometry::NEAREST, true);

                    size_t nrBytes = 0;
                    Array::WriteJpgToMemory(sc, mBuf, mBufSize, &nrBytes);
                    delete sc;
                    delete im;

                    Array2dScalarUInt8* jpgData =
                        Array::MakeFromData<Array2dScalarUInt8>((UInt8*) mBuf,
                                                                nrBytes, 1);
                    imList.push_back(jpgData);
                }
                if (mDoDef)
                {
                    String name(FileNameCtor("shot", fileId, shot, i++, ".jpg"));
                    mImSet->AddFile(name, dbSec, dbDir);
                    mStills->Add(fileId, shot, startF, name);
                }
                startF += interval;
            }

            if (mDoData && (mNr % 100 == 0))
                ILOG_INFO("Did " << mNr + 1 << " shots in "
                          << mTimer.SplitTime() << " sec");
            mNr++;
        }

        if (!mDoData)
            return;

#ifndef REPOSITORY_USED // Here comes the deprecated stuff
        int id = mImSet->GetFirstFileId(fileId); // use video as dir
        String fName = mImSet->GetFilePathImageArchive(id, "images.raw",
                                                       true, false);
        if (! fName.empty())
        {
            Array::WriteRawListVar(imList, fName, mImSet->GetDatabase(), true,
                                   true);
        }
        else
        {
            ILOG_ERROR("unable to write to " << fName);
        }
#else // REPOSITORY_USED
        String container = mImSet->GetContainerDir(fileId); // use video as dir
        Persistency::ImageArchiveLocator loc(vs->GetLocator(), false,
                                             container, "images.raw", 0);
        Array::ImageArchiveMemory wrapper(&imList);
        Persistency::ImageArchiveRepository().Add(loc, &wrapper);
#endif // REPOSITORY_USED
        Array::ArrayListDelete(&imList);
    }

    virtual void
    HandleDoneWalk(VideoSet* vs)
    {
        if (mDoDef)
        {
            bool binary = true;
#ifndef REPOSITORY_USED // Here comes the deprecated stuff
            mStills->Save("stills", binary);
            mImSet->SaveImageSet();
#else // REPOSITORY_USED
            Persistency::StillsRepository().Add(mStillsLoc, mStills);
            Persistency::ImageSetRepository().Add(mImSetLoc, mImSet);
#endif // REPOSITORY_USED
        }
    }

private:

    Reporter*                    mReporter;
    Persistency::ImageSetLocator mImSetLoc;
    ImageSet::ImageSet*          mImSet;
    Segmentation*                mSegmentation;
    Persistency::StillsLocator   mStillsLoc;
    Stills*                      mStills;

    int   mSkipFr;
    int   mNrIm;
    bool  mDoFullSize;
    int   mBufSize;
    char* mBuf;
    bool  mDoDef;
    bool  mDoData;

    int   mNr;
    Timer mTimer;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(ExportStills, Impala.Core.VideoSet);

} // namespace VideoSet
} // namespace Core
} // namespace Impala

#endif

---