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

---

ImageSet.h

Go to the documentation of this file.

#ifndef Impala_Core_ImageSet_ImageSet_h
#define Impala_Core_ImageSet_ImageSet_h

#include "Persistency/ImageSetsRepository.h"
#include "Persistency/ImageRepository.h"
#include "Persistency/ImageArchiveRepository.h"
#include "Basis/Timer.h"
#include "Util/Cache.h"
#include "Core/Array/Arrays.h"
#include "Core/Array/ReadFile.h"
#include "Core/Array/MakeFromData.h"
#include "Core/Array/ImageArchiveFile.h"
#include "Core/Database/RawDataSet.h"

namespace Impala
{
namespace Core
{
namespace ImageSet
{


class ImageSet : public Database::RawDataSet
{
public:

    typedef Persistency::ImageSetsRepository ImageSetsRepository;

    ImageSet(String setName) :
        Database::RawDataSet(setName),
        mSetId(-1)
    {
        CmdOptions& options = CmdOptions::GetInstance();
        mUseArchive = false;
        mUseFileArchive = false;
        mUseSplitArchive = false;
        int cacheSize = options.GetInt("imCacheSize", 128);
        mArchives.SetSize(cacheSize);
        mQuidClass = QUID_CLASS_IMAGE;
        ImageSetsRepository::GetInstance().Register(this, GetSetName());
    }

#ifndef REPOSITORY_USED // Here comes the deprecated stuff
    ImageSet(Util::Database* db, String setName, bool readSet) :
        Database::RawDataSet
            (db, setName,
             readSet ? db->GetFilePath("ImageData", setName, false, false) : ""),
        mSetId(-1)
    {
        CmdOptions& options = CmdOptions::GetInstance();
        mUseArchive = false;
        mUseFileArchive = false;
        mUseSplitArchive = false;
        int cacheSize = options.GetInt("imCacheSize", 128);
        mArchives.SetSize(cacheSize);
        mQuidClass = QUID_CLASS_IMAGE;
        ImageSetsRepository::GetInstance().Register(this, GetSetName());
    }
#endif // REPOSITORY_USED

    int
    GetSetId()
    {
        if(mSetId == -1)
            mSetId = ImageSetsRepository::GetInstance().GetId(GetSetName());
        return mSetId;
    }

    Persistency::ImageLocator
    GetImageLocator(int fileId)
    {
        return Persistency::ImageLocator
            (GetLocator(), GetContainerDirOfFile(fileId), GetFile(fileId));
    }

    Quid
    GetQuidImage(int fileId)
    {
        return MakeQuidImage(GetSetId(), fileId);
    }

    virtual String
    QuidToString(Quid quid, bool elaborate)
    {
        QuidObj qObj(quid);
        if (!elaborate)
            return qObj.ToString();
        String setName = "unknown";
        if ((qObj.Set() != 0) && (qObj.Set() == GetSetId()))
            setName = GetSetName();
        return "Q(" + QuidClassToString(qObj.Class()) + "," + setName + "," +
            GetFile(qObj.Id()) + ")";
    }

    void
    SetImageSrc(bool useArchive, bool useFileArchive, bool useSplitArchive)
    {
        mUseArchive = useArchive;
        mUseFileArchive = useFileArchive;
        mUseSplitArchive = useSplitArchive;
        if (mUseFileArchive)
            mUseArchive = true;
        if (mUseSplitArchive)
        {
            mUseFileArchive = true;
            mUseArchive = true;
        }

        if (mUseArchive)
        {
            String prefix("");
            if (mUseSplitArchive)
                prefix = "split ";
            else if (mUseFileArchive)
                prefix = "file ";
            ILOG_INFO("Reading " << prefix << "archive");
            Timer timer(1);
            if (mUseSplitArchive)
            {
                for (int i=0 ; i<NrDirs() ; i++)
                {
                    if (GetArchive(i) == 0)
                        mUseArchive = false;
                }
                return;
            }
            else
            {
                if (GetArchive(0) == 0)
                    mUseArchive = false;
            }
            ILOG_INFO("time: " << timer.SplitTime());
        }
    }

    bool
    GetUseArchive()
    {
        return mUseArchive;
    }

    Array::Array2dVec3UInt8*
    GetImage(int fileId)
    {
        Array::Array2dVec3UInt8* im = 0;
        if (mUseArchive)
        {
            int dirId;
            int imIdx;
            if (mUseSplitArchive)
            {
                dirId = GetDirIdOfFile(fileId);
                imIdx = fileId - GetFirstFileId(dirId);
            }
            else
            {
                dirId = 0;
                imIdx = fileId;
            }
#ifndef REPOSITORY_USED // Here comes the deprecated stuff
            Array::ImageArchiveFile* ar = GetArchive(dirId);
#else // REPOSITORY_USED
            Array::ImageArchive* ar = GetArchive(dirId);
#endif // REPOSITORY_USED
            if (ar)
                im = ar->ReadImage(imIdx);
        }
        else
        {
#ifndef REPOSITORY_USED // Here comes the deprecated stuff
            String path = GetFilePathImageData(fileId, false, false);
            if (!path.empty())
                ReadFile(im, path, GetDatabase());
#else // REPOSITORY_USED
            Persistency::ImageLocator loc = GetImageLocator(fileId);
            im = Persistency::ImageRepository().Get(loc);
#endif // REPOSITORY_USED
        }
        return im;
    }

    Array::Array2dScalarUInt8*
    GetImageData(int fileId)
    {
        UInt8* dataPtr=0;
        size_t dataSize=0;
        if (mUseArchive)
        {
            int dirId;
            int imIdx;
            if (mUseSplitArchive)
            {
                dirId = GetDirIdOfFile(fileId);
                imIdx = fileId - GetFirstFileId(dirId);
            }
            else
            {
                dirId = 0;
                imIdx = fileId;
            }
#ifndef REPOSITORY_USED // Here comes the deprecated stuff
            Array::ImageArchiveFile* ar = GetArchive(dirId);
#else // REPOSITORY_USED
            Array::ImageArchive* ar = GetArchive(dirId);
#endif // REPOSITORY_USED
            if (ar)
                dataPtr = ar->GetImageData(imIdx, dataSize);
        }
        else
        {
#ifndef REPOSITORY_USED // Here comes the deprecated stuff
            String path = GetFilePathImageData(fileId, false, false);
            Util::Database* db = GetDatabase();
            Util::IOBuffer* ioBuf = db->GetIOBuffer(path, true, false, "", 0, true);
            if (!ioBuf)
            {
                ILOG_ERROR("Unable to open file " << path);
                return 0;
            }
#else // REPOSITORY_USED
            Persistency::ImageLocator loc = GetImageLocator(fileId);
            Util::IOBuffer* ioBuf =
                Persistency::ImageRepositoryInFile().GetReadBuffer(loc);
#endif // REPOSITORY_USED
            dataSize = ioBuf->Size();
            dataPtr = new UInt8[dataSize];
            Int64 nrRead = ioBuf->Read(dataPtr, dataSize);
            delete ioBuf;
            if(nrRead != dataSize)
                ILOG_ERROR("not all data read from ioBuf");
        }
        Array::Array2dScalarUInt8* im =
            Array::MakeFromData<Array::Array2dScalarUInt8>(dataPtr, dataSize, 1);
        delete dataPtr;
        return im;
    }

    int
    Diff(ImageSet* arg)
    {
        if (NrFiles() != arg->NrFiles())
        {
            ILOG_ERROR("Diff: nrFiles differs: " << NrFiles() << " vs " <<
                       arg->NrFiles());
            return 1;
        }
        int nDiff = 0;
        for (int i=0 ; i<NrFiles() ; i++)
        {
            if (GetAsPath(i) != arg->GetAsPath(i))
            {
                ILOG_DEBUG("File " << i << " differs " << GetAsPath(i) <<
                           " vs " << arg->GetAsPath(i));
                nDiff++;
            }
            else if (GetQuidImage(i) != arg->GetQuidImage(i))
            {
                ILOG_DEBUG("Quid " << i << " differs " << GetQuidImage(i)
                           << " vs " << arg->GetQuidImage(i));
                nDiff++;
            }
        }
        if (nDiff > 0)
            ILOG_ERROR("Found " << nDiff << " differences");
        return nDiff;
    }

#ifndef REPOSITORY_USED // Here comes the deprecated stuff
    // Any data part based on id's

    String
    MakeDirId(String base, String subDir, int fileId, bool makeDbFile)
    {
        String dbFile = (makeDbFile) ? GetFile(fileId) : ".";
        return mDb->MakeDir(base, subDir, GetSectionOfFile(fileId),
                            GetDirOfFile(fileId), dbFile);
    }

    String
    GetFilePathId(String base, String subDir, int fileId,
                  bool useDbFileDir, bool useDbFile, String suffix,
                  bool toWrite)
    {
        String dbFileDir = (useDbFileDir) ? GetFile(fileId) : "";
        String fName = (useDbFile) ? GetFileBase(fileId) : "";
        return mDb->GetFilePath(base,  subDir, GetSectionOfFile(fileId),
                                GetDirOfFile(fileId), dbFileDir,
                                fName + suffix, toWrite, false);
    }

    // I/O part

    void
    SaveImageSet()
    {
        mDb->MakeDir("ImageData", "");
        Save(mDb->GetFilePath("ImageData", mSetName, true, false));
    }

    void
    UpdateImageSet()
    {
        mDb->MakeDir("ImageData", "");
        String fName = mDb->GetFilePath("ImageData", mSetName, true, true);
        if (fName.empty()) // try force override thru read
            fName = mDb->GetFilePath("ImageData", mSetName, false, false);
        Save(fName);
    }
#endif // REPOSITORY_USED

private:

#ifndef REPOSITORY_USED // Here comes the deprecated stuff
    Array::ImageArchiveFile*
    GetArchive(int dirId)
    {
        Array::ImageArchiveFile* res = 0;
        if (mArchives.GetElement(dirId, res))
            return res;

        if (mUseSplitArchive)
        {
            int fileId = GetFirstFileId(dirId);
            String fName = GetFilePathImageArchive(fileId, "images.raw", false,
                                                   false);
            if (fName.empty())
                return 0;
            res = new Array::ImageArchiveFile(fName, !mUseFileArchive,
                                              GetDatabase());
            mArchives.AddElement(dirId, res);
            return res;
        }
        String fName = GetFilePathImageArchive(GetSetNameBase() + ".raw", false,
                                               false);
        if (fName.empty())
            return 0;
        res = new Array::ImageArchiveFile(fName, !mUseFileArchive, GetDatabase());
        mArchives.AddElement(0, res);
        return res;
    }
#else // REPOSITORY_USED
    Array::ImageArchive*
    GetArchive(int dirId)
    {
        Array::ImageArchive* res = 0;
        if (mArchives.GetElement(dirId, res))
            return res;

        if (mUseSplitArchive)
        {
            String container = GetContainerDir(dirId);
            Persistency::ImageArchiveLocator loc(GetLocator(), false,
                                                 container, "images.raw", 0);
            res = Persistency::ImageArchiveRepository().Get(loc);
            mArchives.AddElement(dirId, res);
            return res;
        }
        String arName = GetSetNameBase() + ".raw";
        Persistency::ImageArchiveLocator loc(GetLocator(), false, "", arName, 0);
        res = Persistency::ImageArchiveRepository().Get(loc);
        mArchives.AddElement(0, res);
        return res;
    }
#endif // REPOSITORY_USED

    int mSetId;
    bool mUseArchive;
    bool mUseFileArchive;
    bool mUseSplitArchive;
#ifndef REPOSITORY_USED // Here comes the deprecated stuff
    Util::Cache<int, Array::ImageArchiveFile*> mArchives;
#else // REPOSITORY_USED
    Util::Cache<int, Array::ImageArchive*> mArchives;
#endif // REPOSITORY_USED

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(ImageSet, Impala.Core.ImageSet);

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

#endif

---