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

---

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 = 0;
        mThumbPrefix = "";
        String thumbSetDef = options.GetArg(2);
        if (FileNameExt(thumbSetDef) == ".txt")
            mThumbSet = MakeImageSet(thumbSetDef);
        else
            mThumbPrefix = thumbSetDef;
        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];
        if ((mArchive || mSplitArchive) && (!mThumbSet))
        {
            ILOG_ERROR("Archiving requires a thumbset");
            mArchive = false;
            mSplitArchive = false;
        }
    }

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

    virtual void
    HandleNewWalk(ImageSet* is)
    {
        if (mThumbSet && (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;
        }

        double scale = mScale;
        if (mScale > 1) // assume mScale indicates fixed maximum size
        {
            double scaleW = mScale / im->CW();
            double scaleH = mScale / im->CH();
            scale = Impala::Min(scaleW, scaleH);
        }

        ImType* sc = 0;
        Array::Scale(sc, im, scale, scale, Geometry::NEAREST, true);
        if (mArchive || mSplitArchive)
        {
            String fName = (mThumbSet) ? mThumbSet->GetFile(fileId)
                                       : is->GetFile(fileId);
            size_t nrBytes = 0;
            if (FileNameExt(fName) == "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
        {
            typedef Persistency::ImageLocator ImageLocator;
            if (mThumbSet)
            {
                ImageLocator loc = mThumbSet->GetImageLocator(fileId);
                Persistency::ImageRepository().Add(loc, sc);
            }
            else
            {
                String container = is->GetContainerDirOfFile(fileId);
                container = FileNameConcat(mThumbPrefix, container);
                ImageLocator loc = ImageLocator(is->GetLocator(), container,
                                                is->GetFile(fileId));
                Persistency::ImageRepository().Add(loc, sc);
            }
        }
        delete sc;
        if (blackIm)
            delete blackIm;
    }

    virtual void
    HandleDoneDir(ImageSet* is, int dirId)
    {
        if (!mSplitArchive)
            return;

        String container = mThumbSet->GetContainerDir(dirId);
        Persistency::ImageArchiveLocator loc(mThumbSet->GetLocator(), false,
                                             container, "images.raw", 0);
        Array::ImageArchiveMemory wrapper(&mImList);
        Persistency::ImageArchiveRepository().Add(loc, &wrapper);
        Array::ArrayListDelete(&mImList);
    }

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

        String arName = mThumbSet->GetSetNameBase() + ".raw";
        Persistency::ImageArchiveLocator loc(mThumbSet->GetLocator(), false,
                                             "", arName, 0);
        Array::ImageArchiveMemory wrapper(&mImList);
        Persistency::ImageArchiveRepository().Add(loc, &wrapper);
        Array::ArrayListDelete(&mImList);
    }

private:

    Reporter* mReporter;
    ImageSet* mThumbSet;
    String    mThumbPrefix;
    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

---