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

---

ImageArchiveFile.h

Go to the documentation of this file.

#ifndef Impala_Core_Array_ImageArchiveFile_h
#define Impala_Core_Array_ImageArchiveFile_h

#include "Persistency/File.h"
#include "Core/Array/ImageArchive.h"
#include "Util/DatabaseWriteNative.h"
#include "Util/DatabaseReadNative.h"
#include "Core/Array/ReadRaw.h"
#include "Core/Array/WriteRaw.h"
#include "Core/Array/ReadImage.h"

namespace Impala
{
namespace Core
{
namespace Array
{


class ImageArchiveFile : public ImageArchive
{
public:

#ifndef REPOSITORY_USED // Here comes the deprecated stuff
    ImageArchiveFile(CString fName, bool useMemory, Util::Database* db)
    {
        Init(fName, useMemory, db);
    }
#endif // REPOSITORY_USED

    ImageArchiveFile(Persistency::File file)
    {
        mIOBuffer = 0;
        if (!file.Valid())
        {
            ILOG_ERROR("Invalid file");
            return;
        }

        mIOBuffer = file.GetReadBuffer();
        if (!mIOBuffer)
            return;

        Persistency::File idxFile(file.GetPath() + ".idx", file.GetFileSystem(),
                                  file.IsWritable());
        idxFile.ReadNative(std::back_inserter(mFileOffset), true);
        if (mFileOffset.size() == 0)
            ILOG_ERROR("Empty .idx file");
    }

    virtual
    ~ImageArchiveFile()
    {
        if (mIOBuffer)
            delete mIOBuffer;
    }

    bool
    Valid()
    {
        return (mIOBuffer != 0) && (mFileOffset.size() != 0);
    }

    int
    NrImages()
    {
        return mFileOffset.size();
    }

    Array2dVec3UInt8*
    ReadImage(int idx)
    {
        if (!Valid())
        {
            ILOG_ERROR("Cannot ReadImage: archive not valid");
            return 0;
        }

        size_t blockSize = 0;
        UInt8* data = GetImageData(idx, blockSize);
        Array2dVec3UInt8* im = 0;
        ReadImageFromMemory(im, (char*) data, blockSize);
        delete data;
        return im;
    }

    UInt8*
    GetImageData(int idx, size_t& blockSize)
    {
        if (!Valid())
        {
            ILOG_ERROR("Cannot GetImageData: archive not valid");
            return 0;
        }
        if (idx >= mFileOffset.size())
        {
            ILOG_ERROR("Index out of bounds: " << idx << " vs. " <<
                       mFileOffset.size());
            return 0;
        }

        mIOBuffer->SetPosition(mFileOffset[idx]);
        char buf[200];
        int width;
        int height;
        mIOBuffer->Read(buf, 20);
        sscanf(buf, "%d %d ", &width, &height);
        blockSize = width*height;
        UInt8* data = new UInt8[blockSize];
        size_t nrRead = mIOBuffer->Read(data, blockSize);
        if (nrRead != blockSize)
            ILOG_ERROR("GetImageData: read " << nrRead
                        << " bytes instead of " << blockSize);
        return data;
    }

private:

#ifndef REPOSITORY_USED // Here comes the deprecated stuff
    void
    Init(CString fileName, bool useMemory, Util::Database* db)
    {
        mIOBuffer = 0;

        if (db == 0)
        {
            ILOG_ERROR("No database given");
            return;
        }
        if (fileName.empty())
        {
            ILOG_ERROR("Empty fileName");
            return;
        }

        // fileName must be a resolved (absolute) file path
        mIOBuffer = db->GetIOBuffer(fileName, true, useMemory, "", 0, true);
        //mIOBuffer = db->GetIOBuffer(fileName, true, useMemory, "");
        if (!mIOBuffer)
            return;

        const String idxPath = fileName + ".idx";
        if (CmdOptions::GetInstance().GetString("dataServer").empty())
        {
            // SK,Oct'08: This approach does currently not work with a dataserver 
            //            (the path would be re-resolved at the dataserver side);
            //            hence with dataservers we assume the presence of an index file.
            if (!Util::IOBufferFile::FileExists(idxPath))
            {
                ReadRawListVarIndex<Array2dScalarUInt8>(mFileOffset, mIOBuffer);
                ILOG_INFO("saving index [" + idxPath + "]");
                Util::DatabaseWriteNative(idxPath, db, mFileOffset.begin(),
                                          mFileOffset.end());
                return;
            }
        }

        Util::IOBuffer* indexBuffer = db->GetIOBuffer(idxPath, true, true, "");
        Util::DatabaseReadNative(std::back_inserter(mFileOffset), indexBuffer);
        delete indexBuffer;
        if (mFileOffset.size() == 0)
            ILOG_ERROR("Empty .idx file");
    }
#endif // REPOSITORY_USED

    Util::IOBuffer*    mIOBuffer;
    std::vector<Int64> mFileOffset;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(ImageArchiveFile, Impala.Core.Array);

} // namespace Array
} // namespace Core
} // namespace Impala

#endif

---