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

---

Collection.h

Go to the documentation of this file.

#ifndef Impala_Core_Trec_Collection_h
#define Impala_Core_Trec_Collection_h

#include "Persistency/Mpeg7DocRepository.h"
#include "Core/VideoSet/Keyframes.h"
#include "Core/VideoSet/Segmentation.h"
#include "Core/VideoSet/Mpeg7Doc.h"
#include "Core/ImageSet/ImageSet.h"

namespace Impala
{
namespace Core
{
namespace Trec
{


class Collection : public Util::XmlDoc
{
public:

    typedef VideoSet::Segmentation Segmentation;
    typedef VideoSet::Keyframes Keyframes;
    typedef VideoSet::Mpeg7Doc Mpeg7Doc;

    Collection(const Persistency::FileLocator& loc)
    {
        ReadData(loc);
    }

    // inquiry

    int
    NrVideoFiles()
    {
        return mId.size();
    }

    void
    WriteVideoSet(const Persistency::Locator& loc, String use, String clipsKeys,
                  bool vidSetOnly)
    {
#ifndef REPOSITORY_USED // Here comes the deprecated stuff
        VideoSet::VideoSet* vidSet =
            new VideoSet::VideoSet(&Util::Database::GetInstance(),
                                   loc.GetDataSet(), false);
#else // REPOSITORY_USED
        VideoSet::VideoSet* vidSet = new VideoSet::VideoSet(loc.GetDataSet());
        vidSet->SetProtocolAndHost(loc.GetProtocolAndHost());
#endif // REPOSITORY_USED
        Segmentation segm(vidSet, "");
        Keyframes keyframes(vidSet, "");
        int videoId = 0;
        int offset = 0; // hack to skip devel video's in test keyframelist
        for (int v=0 ; v<NrVideoFiles() ; v++)
        //for (int v=0 ; v<10 ; v++)
        {
            if ((!use.empty()) && (mUse[v] != use))
            {
                if (use == "test")
                    offset = v + 1;
                continue;
            }

            vidSet->AddFile(mFileName[v], ".");
            if (vidSetOnly)
                continue;

            Stream::RgbDataSrc* rgbSrc = vidSet->GetVideo(videoId);
            if (!rgbSrc)
            {
                ILOG_ERROR("WriteVideoSet: no src for v=" << v << " (" <<
                           mFileName[v] << ")");
                return;
            }
            if ((rgbSrc->FrameRateNum() < 0) || (rgbSrc->FrameRateDen() < 0))
            {
                ILOG_ERROR("WriteVideoSet: no framerate for v=" << v << " (" <<
                           mFileName[v] << ")");
                return;
            }

            String fileName = mSrcDir + MakeString(mId[v]) + ".mp7.xml";
            Persistency::Mpeg7DocLocator loc(fileName);
            loc.SetFrameRateNum(rgbSrc->FrameRateNum());
            loc.SetFrameRateDen(rgbSrc->FrameRateDen());
            Mpeg7Doc* mp7 = Persistency::Mpeg7DocRepository().Get(loc);
            ILOG_INFO("video " << mFileName[v] << " shots " << mp7->NrShots());
            int lastFrame = 0;
            for (int s=0 ; s<mp7->NrShots() ; s++)
            {
                if (mp7->StartFrame(s) != lastFrame)
                {
                    ILOG_ERROR("shot " << s << " has gap (previous shot end "
                               << lastFrame << ", this shot start " <<
                               mp7->StartFrame(s) << "), adjusting start");
                    segm.Add(videoId, lastFrame, mp7->EndFrame(s),
                             mp7->ShotName(s));
                }
                else
                {
                    segm.Add(videoId, mp7->StartFrame(s), mp7->EndFrame(s),
                             mp7->ShotName(s));
                }
                lastFrame = mp7->EndFrame(s) + 1;
                if (clipsKeys.empty())
                {
                    int shotId = segm.Size() - 1;
                    for (int k=0 ; k<mp7->NrKeyframes(s) ; k++)
                    {
                        String name = mp7->KeyframeName(s, k) + ".jpg";
                        keyframes.Add(videoId, shotId, mp7->KeyframeFrame(s, k),
                                      name);
                    }
                }
            }
            delete mp7;
            delete rgbSrc;
            videoId++;
        }
        if (!clipsKeys.empty())
            ReadKeyframesClips(&segm, &keyframes, clipsKeys, offset);
        Persistency::Locator baseLoc = vidSet->GetLocator();
        bool binary = true;
        if (vidSetOnly)
        {
            Persistency::VideoSetRepository().Add(baseLoc, vidSet);
            return;
        }
        Persistency::SegmentationLocator sLoc(baseLoc, "segmentation");
        Persistency::SegmentationRepository().Add(sLoc, &segm);

        keyframes.RemoveDuplicates();
        for (int i=0 ; i<keyframes.Size() ; i++)
        {
            int frame = keyframes.GetFrameNr(i);
            int shotId = keyframes.GetShotId(i);
            int start = segm.GetStart(shotId);
            int end = segm.GetEnd(shotId);
            if ((frame < start) || (frame > end))
            {
                ILOG_ERROR("keyframe " << i << ": frame " << frame <<
                           " outside shot " << start << " - " << end);
            }
        }   
        Persistency::KeyframesLocator kLoc(baseLoc, "keyframes");
        Persistency::KeyframesRepository().Add(kLoc, &keyframes);
        keyframes.WriteImageSets();
    }

private:

    /* file excerpt:

<?xml version"1.0" encoding="UTF-8"?>
<VideoFileList>
   <VideoFile>
      <id>1</id>
      <filename>20041116_110000_CCTV4_NEWS3_CHN.mpg</filename>
      <use>test</use>
      <source>CCTV4.NEWS3</source>
      <filetype>MPEG-1</filetype>
   </VideoFile>

    */
    void
    ReadData(const Persistency::FileLocator& loc)
    {
        mSrcDir = FileNamePath(loc.GetName());
        typedef Persistency::RepositoryInFileSystem FS;
        Persistency::File file = FS::GetInstance().GetFile(loc, false, false);
        Util::IOBuffer* ioBuf = file.GetReadBuffer(true, "");
        Persistency::XmlFileReader reader;
        DOMDocument* doc = reader.Read(loc.GetName(), ioBuf);
        delete ioBuf;
        DOMNodeList* vList = reader.FindElementsByName(doc, "VideoFile");
        for (XMLSize_t i=0 ; i<vList->getLength() ; i++)
        {
            DOMNode* video = vList->item(i);
            DOMNodeList* children = video->getChildNodes();
            for (XMLSize_t j=0 ; j<children->getLength() ; j++)
            {
                DOMNode* child = children->item(j);
                DOMNode* grandChild = child->getFirstChild();
                if (!grandChild)
                    continue;
                String name = XMLCh2String(child->getNodeName());
                String val = XMLCh2String(grandChild->getNodeValue());
                ILOG_DEBUG("read " << name << " = " << val);
                if (name == "id")
                    mId.push_back(atol(val));
                else if (name == "filename")
                    mFileName.push_back(val);
                else if (name == "use")
                    mUse.push_back(val);
                else if (name == "source")
                    mSource.push_back(val);
            }
        }
    }

    void
    ReadKeyframesClips(Segmentation* segm, Keyframes* keyframes,
                       String clipsKeys, int offset)
    {
        std::vector<String> lines;
        Persistency::FileLocator loc(clipsKeys);
        typedef Persistency::RepositoryInFileSystem FS;
        Persistency::File file = FS::GetInstance().GetFile(loc, false, false);
        file.ReadStrings(std::back_inserter(lines), true);
        ILOG_DEBUG("clipsKeys nr lines = " << lines.size());
        int curShot = -1;
        int lastShot = -1;
        for (int i=0 ; i<lines.size() ; i++)
        {
            Util::StringParser p(lines[i]);
            int frameNr = atol(FileNameBase(p.GetString(' ')));
            int vidId = atol(p.GetString('_'));
            if (vidId - 1 < offset)
            {
                ILOG_DEBUG("skipping " << vidId - 1);
                continue;
            }
            int shotId = atol(p.GetString('_'));
            int shotSub = atol(p.GetString(' '));
            String imName = FileNameTail(p.GetString(' '));
            ILOG_DEBUG("frameNr = " << frameNr << ", vid = " << vidId <<
                       ", shot = " << shotId << ", imName = " << imName);
            if (shotId != lastShot)
            {
                curShot++;
                lastShot = shotId;
                if (curShot > segm->GetNrShots())
                {
                    ILOG_ERROR("Too many keyframes");
                    return;
                }
            }
            if ((vidId - 1 - offset) != segm->GetVideoId(curShot))
                ILOG_ERROR("ReadKeyframesClips: wrong vidId on line" << i);
            if ((frameNr < segm->GetStart(curShot)) ||
                (frameNr > segm->GetEnd(curShot)))
            {
                ILOG_ERROR("ReadKeyframesClips: frame " << frameNr <<
                           " outside shot [" << segm->GetStart(curShot)
                           << "," << segm->GetEnd(curShot) << "], line nr = "
                           << i << ", curshot = " << curShot);
            }
            keyframes->Add(vidId - 1 - offset, curShot, frameNr, imName);
        }
    }

public:

    // data

    String              mSrcDir;
    std::vector<int>    mId;
    std::vector<String> mFileName;
    std::vector<String> mUse;
    std::vector<String> mSource;

    ILOG_VAR_DEC;

};

ILOG_VAR_INIT(Collection, Impala.Core.Trec);

} // namespace Trec
} // namespace Core
} // namespace Impala

#endif

---