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

---

Thumbnails.h

Go to the documentation of this file.

#ifndef Impala_Core_ImageSet_Thumbnails_h
#define Impala_Core_ImageSet_Thumbnails_h

#include "Core/ImageSet/Reporter.h"
#include "Core/ImageSet/MakeImageSet.h"
#include "Core/Array/MakeFromValue.h"
#include "Core/Array/Scale.h"
#include "Core/Array/WriteJpg.h"
#include "Core/Array/WritePng.h"
#include "Core/Array/ImageArchiveMemory.h"

namespace Impala
{
namespace Core
{
namespace ImageSet
{


class Thumbnails : public Listener
{
    typedef Array::Array2dVec3UInt8 ImType;
public:

    Thumbnails(Reporter* reporter, CmdOptions& options)
    {
        mReporter = reporter;
        mThumbSet = MakeImageSet(options.GetArg(2));
        mScale = 0.5;
        if (options.GetNrArg() > 3)
            mScale = atof(options.GetArg(3));
        mArchive = false;
        mSplitArchive = false;
        if (options.GetNrArg() > 4)
        {
            if (options.GetArg(4) == "archive")
                mArchive = true;
            if (options.GetArg(4) == "split")
                mSplitArchive = true;
            mReporter->SetReportArray(false); // we will cause a "memory leak"
        }
        mRkfMask = false;
        if (options.GetNrArg() > 5)
        {
            if (options.GetArg(5) == "rkf")
                mRkfMask = true;
        }
        mFirstImWidth = -1;
        mFirstImHeight = -1;
        mBufSize = 100000;
        mBuf = new char[mBufSize];
    }

    virtual
    ~Thumbnails()
    {
        delete mThumbSet;
        delete mBuf;
    }

    virtual void
    HandleNewWalk(ImageSet* is)
    {
        if (is->NrFiles() != mThumbSet->NrFiles())
        {
            ILOG_ERROR("Thumbnails: nr of files differs");
        }
    }

    virtual void
    HandleNewFile(ImageSet* is, int fileId, Array::Array2dVec3UInt8* im)
    {
        ImType* blackIm = 0;
        if (!im)
        {
            ILOG_ERROR("No image");
            if (mFirstImWidth == -1)
            {
                ILOG_ERROR("No image size yet, so can't generate black image");
                return;
            }
            blackIm = Array::MakeFromValue<ImType>
                (Array::Element::Vec3Int32(0, 0, 0), mFirstImWidth,
                 mFirstImHeight);
            im = blackIm;
        }
        if (mFirstImWidth == -1)
        {
            mFirstImWidth = im->CW();
            mFirstImHeight = im->CH();
            ILOG_INFO("First image has sizes : " << mFirstImWidth << " x "
                      << mFirstImHeight);
        }
        if (mRkfMask)
        {
            String imFile = is->GetFile(fileId);
            if (imFile.find("_NRKF_") != String::npos)
                return;
        }
        ImType* sc = 0;
        Array::Scale(sc, im, mScale, mScale, Geometry::NEAREST, true);
        if (mArchive || mSplitArchive)
        {
            size_t nrBytes = 0;
            if (FileNameExt(mThumbSet->GetFile(fileId)) == "jpg")
                Array::WriteJpgToMemory(sc, mBuf, mBufSize, &nrBytes);
            else
                Array::WritePngToMemory(sc, mBuf, mBufSize, &nrBytes);
            Array::Array2dScalarUInt8* bufIm =
                Array::MakeFromData<Array::Array2dScalarUInt8>((UInt8*) mBuf,
                                                               nrBytes, 1);
            mImList.push_back(bufIm);
        }
        else
        {
#ifndef REPOSITORY_USED // Here comes the deprecated stuff
            String resFile = mThumbSet->GetFilePathImageData(fileId, true,
                                                             false);
            Array::WriteJpg(sc, resFile, mThumbSet->GetDatabase());
#else // REPOSITORY_USED
            String container = mThumbSet->GetContainerDirOfFile(fileId);
            Persistency::ImageLocator loc(mThumbSet->GetLocator(), container,
                                          mThumbSet->GetFile(fileId));
            Persistency::ImageRepository().Add(loc, sc);
#endif // REPOSITORY_USED
        }
        delete sc;
        if (blackIm)
            delete blackIm;
    }

    virtual void
    HandleDoneDir(ImageSet* is, int dirId)
    {
        if (!mSplitArchive)
            return;
#ifndef REPOSITORY_USED // Here comes the deprecated stuff
        int fileId = mThumbSet->GetFirstFileId(dirId);
        String fName = mThumbSet->GetFilePathImageArchive(fileId, "images.raw",
                                                          true, false);
        if (!fName.empty())
        {
            Array::WriteRawListVar(mImList, fName, mThumbSet->GetDatabase(),
                                   true, true);
        }
        else
        {
            ILOG_ERROR("Unable to write split archive");
        }
#else // REPOSITORY_USED
        String container = mThumbSet->GetContainerDir(dirId);
        Persistency::ImageArchiveLocator loc(mThumbSet->GetLocator(), false,
                                             container, "images.raw", 0);
        Array::ImageArchiveMemory wrapper(&mImList);
        Persistency::ImageArchiveRepository().Add(loc, &wrapper);
#endif // REPOSITORY_USED
        Array::ArrayListDelete(&mImList);
    }

    virtual void
    HandleDoneWalk(ImageSet* is)
    {
        if (!mArchive)
            return;

#ifndef REPOSITORY_USED // Here comes the deprecated stuff
        String fName = mThumbSet->GetSetNameBase() + ".raw";
        fName = mThumbSet->GetFilePathImageArchive(fName, true, false);
        if (fName.empty())
        {
            ILOG_ERROR("Thumbnails: Couldn't write archive");
            return;
        }
        ILOG_INFO("writing archive [" << fName << "]");
        Array::WriteRawListVar(mImList, fName, mThumbSet->GetDatabase(), true,
                               true);
#else // REPOSITORY_USED
        String arName = mThumbSet->GetSetNameBase() + ".raw";
        Persistency::ImageArchiveLocator loc(mThumbSet->GetLocator(), false,
                                             "", arName, 0);
        Array::ImageArchiveMemory wrapper(&mImList);
        Persistency::ImageArchiveRepository().Add(loc, &wrapper);
#endif // REPOSITORY_USED
        Array::ArrayListDelete(&mImList);
    }

private:

    Reporter* mReporter;
    ImageSet* mThumbSet;
    double    mScale;
    bool      mArchive;
    bool      mSplitArchive;
    bool      mRkfMask;
    int       mFirstImWidth;
    int       mFirstImHeight;
    int       mBufSize;
    char*     mBuf;
    std::vector<Array::Array2dScalarUInt8*> mImList;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(Thumbnails, Impala.Core.ImageSet);

} // namespace ImageSet
} // namespace Core
} // namespace Impala

#endif

---