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

---

Archive.h

Go to the documentation of this file.

#ifndef Impala_Core_ImageSet_Archive_h
#define Impala_Core_ImageSet_Archive_h

#include "Core/ImageSet/Reporter.h"
#include "Core/ImageSet/MakeImageSet.h"
#include "Core/Array/MakeFromValue.h"
#include "Core/Array/ArrayListDelete.h"
#include "Core/Array/WriteRaw.h"
#include "Core/Array/ImageArchiveMemory.h"
#include "Core/Array/LimitCompressedImageSize.h"

namespace Impala
{
namespace Core
{
namespace ImageSet
{


class Archive : public Listener
{
    typedef Array::Array2dScalarUInt8 CImType;
    typedef Array::Array2dVec3UInt8 RgbImType;
public:

    Archive(Reporter* reporter, CmdOptions& options)
    {
        mReporter = reporter;
        mReporter->SetReportArray(false); // we will cause a "memory leak"
        mSplit = false;
        if ((options.GetNrArg() > 2) && (options.GetArg(2) == "split"))
            mSplit = true;
        mMaxSize = -1;
        if (options.GetNrArg() > 3)
            mMaxSize = atol(options.GetArg(3));
        mMinSize = 64;
        if (options.GetNrArg() > 4)
            mMinSize = atol(options.GetArg(4));
        mNrBlackIm = 0;
        mNrSmallIm = 0;
        mNrBigIm = 0;
    }

    virtual
    ~Archive()
    {
        Array::ArrayListDelete(&mImList);
    }

    virtual void
    HandleNewFile(ImageSet* is, int fileId, Array::Array2dVec3UInt8* im)
    {
        if (im == 0)
        {
            ILOG_ERROR("No readable image, adding minSize black image");
            RgbImType* rgbIm = Array::MakeFromValue<RgbImType>(0, mMinSize,
                                                               mMinSize);
            CompressAndAdd(rgbIm);
            mNrBlackIm++;
            return;
        }

        if ((im->CW() < mMinSize) || (im->CH() < mMinSize))
        {
            ILOG_INFO("Image too small (" << im->CW() << "x" << im->CH() <<
                      "), adding minSize black image");
            RgbImType* rgbIm = Array::MakeFromValue<RgbImType>(0, mMinSize,
                                                               mMinSize);
            CompressAndAdd(rgbIm);
            mNrSmallIm++;
            return;
        }

        if ((mMaxSize > 0) && ((im->CW() > mMaxSize) || (im->CH() > mMaxSize)))
        {
            double scale = 1.0;
            while ((scale*im->CW() > mMaxSize) || (scale*im->CH() > mMaxSize))
                scale *= 0.5;

            RgbImType* sc = 0;
            Scale(sc, im, scale, scale, Core::Geometry::NEAREST, true);
            ILOG_INFO("Image too big, scaled it from " << im->CW() << "x" <<
                      im->CH() << " to " << sc->CW() << "x" << sc->CH());
            CompressAndAdd(sc);
            mNrBigIm++;
            return;
        }

        // Image seems OK, get original (compressed) data
        CImType* bufIm = is->GetImageData(fileId);
        mImList.push_back(bufIm);
    }

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

        String container = is->GetContainerDir(dirId);
        Persistency::ImageArchiveLocator loc(is->GetLocator(), false,
                                             container, "images.raw", 0);
// hack to store locally
//loc.SetProtocol("file");
//loc.SetHost("");
//loc.SetHost("node444.das3.science.uva.nl:57000");
        Array::ImageArchiveMemory wrapper(&mImList);
        Persistency::ImageArchiveRepository().Add(loc, &wrapper);
        Array::ArrayListDelete(&mImList);
    }

    virtual void
    HandleDoneWalk(ImageSet* is)
    {
        ILOG_INFO("NrBlackIm=" << mNrBlackIm << ", NrSmallIm=" << mNrSmallIm
                  << ", NrBigIm=" << mNrBigIm);
        if (mSplit)
            return;

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

private:

    void
    CompressAndAdd(RgbImType* im)
    {
        int charBufSize = im->CW() * im->CH() * 3 + 1024;
        char* charBuf = new char[charBufSize];
        size_t nrBytes;
        WritePngToMemory(im, charBuf, charBufSize, &nrBytes);
        delete im;
        CImType* bufIm = Array::MakeFromData<CImType>((UInt8*) charBuf,
                                                      nrBytes, 1);
        delete charBuf;
        mImList.push_back(bufIm);
    }

    Reporter*             mReporter;
    bool                  mSplit;
    int                   mMaxSize;
    int                   mMinSize;
    std::vector<CImType*> mImList;
    int                   mNrBlackIm;
    int                   mNrSmallIm;
    int                   mNrBigIm;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(Archive, Core.ImageSet);

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

#endif

---