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

---

IxsDocument.h

Go to the documentation of this file.

#ifndef Impala_Core_ImageSet_IxsDocument_h
#define Impala_Core_ImageSet_IxsDocument_h

#include "Core/Database/DataDocument.h"
#include "Core/Table/TableIxs.h"
#include "Core/Table/RemoveRow.h"
#include "Core/ImageSet/ImageSet.h"
#include "Core/Column/Copy.h"

namespace Impala
{
namespace Core
{
namespace ImageSet
{


class IxsDocument : public Database::DataDocument
{
public:
    typedef Core::Table::TableIxs TableIxs;
    typedef TableIxs BookmarkedType;

    IxsDocument(ImageSet* imSet) : Database::DataDocument(imSet)
    {
        mImSet = imSet;
        mBookmarked = new TableIxs();
        mBookmarkedIds = new TableIds(0);
    }

    Core::Array::Array2dVec3UInt8*
    CurImage()
    {
        if (!HasCurFile())
            return 0;
        return mImSet->GetImage(CurFileId());
    }

    ImageSet*
    GetImageSet()
    {
        return mImSet;
    }

    // cursor part

    Database::DocLevel
    CursorToBookmark(int idx)
    {
        if (mBookmarked->SetCursor(idx))
            return CursorToCurBookmark();
        return Database::LEVEL_NONE;
    }

    Database::DocLevel
    CursorNextBookmark()
    {
        if (mBookmarked->MoveCursor(1))
            return CursorToCurBookmark();
        return Database::LEVEL_NONE;
    }

    Database::DocLevel
    CursorPrevBookmark()
    {
        if (mBookmarked->MoveCursor(-1))
            return CursorToCurBookmark();
        return Database::LEVEL_NONE;
    }

    Database::DocLevel
    CursorToCurBookmark()
    {
        if (!mBookmarked->HasCursor())
            return Database::LEVEL_NONE;
        GotoFile(mBookmarked->Get7AtCursor());
        SetRect(mBookmarked->Get2AtCursor());
        SetConcept(mBookmarked->Get1AtCursor());
        return Database::LEVEL_FILE;
    }

    // ownership resides with caller
    // data only garanteed as long as cursor doesn't move
    virtual Core::Array::Array2dVec3UInt8*
    VisualAtCursor(bool thumbnail)
    {
        //todo : scale when thumbnail?
        return CurImage();
    }

    // bookmarked part

    BookmarkedType*
    GetBookmarked()
    {
        return mBookmarked;
    }

    TableIds*
    GetBookmarkedIds()
    {
        mBookmarkedIds->ReserveMin(mBookmarked->Size(), false);
        Column::Copy(mBookmarkedIds->GetColumn1(), mBookmarked->GetColumn7(),
                     mBookmarked->Size(), 0, 0);
        mBookmarkedIds->SetSize(mBookmarked->Size());
        return mBookmarkedIds;
    }

    virtual bool
    HasBookmarks()
    {
        return mBookmarked->Size() > 0;
    }

    bool
    HasCurBookmark()
    {
        return mBookmarked->HasCursor();
    }

    int
    CurBookmark()
    {
        return mBookmarked->GetCursor();
    }

    std::string
    CurBookmarkAnno()
    {
        if (!HasCurBookmark())
            return std::string("");
        return mBookmarked->Get1AtCursor();
    }

    virtual std::string
    DescribeBookmark(int idx)
    {
        int fileId = mBookmarked->Get7(idx);
        return mDataSet->GetFile(fileId) + "  " + mBookmarked->Get1(idx) + "  ("
            + mDataSet->GetSectionOfFile(fileId)
            + "/" + mDataSet->GetDirOfFile(fileId) + ")";
    }

    virtual bool
    AddCursorToBookmarked()
    {
        if (! HasCurFile())
            return false;
        Geometry::Rectangle rect = GetRect();
        std::string anno = GetConcept();
        int fileId = CurFileId();
        for (int i=0 ; i<mBookmarked->Size() ; i++)
        {
            if ((mBookmarked->Get7(i) == fileId) &&
                (mBookmarked->Get1(i) == anno) &&
                (mBookmarked->Get2(i) == rect))
            {
                return false;
            }
        }
        if (mBookmarked->Add(anno, rect, mDataSet->GetFile(fileId),
                             mDataSet->GetSectionOfFile(fileId),
                             mDataSet->GetDirOfFile(fileId), "", fileId))
        {
            return true;
        }
        return false;
    }

    virtual bool
    RemoveCursorFromBookmarked()
    {
        // todo : check whether cursor is same as current bookmark??
        if (! HasCurBookmark())
            return false;
        int cursor = mBookmarked->GetCursor();
        Table::RemoveRow(mBookmarked, mBookmarked->GetCursor());
        CursorToBookmark(cursor);
        return true;
    }

    virtual void
    ClearBookmarked()
    {
        mBookmarked->SetEmpty();
    }

    virtual void
    LoadBookmarked(std::string fileName)
    {
        mBookmarkedFileName = fileName;
        mBookmarked->ReadIxsFile(fileName);
        Database::RawDataSet* dataSet = GetDataSet();
        for (int i=0 ; i<mBookmarked->Size() ; i++)
        {
            int fileId = dataSet->GetFileId(mBookmarked->Get4(i),
                                            mBookmarked->Get5(i),
                                            mBookmarked->Get3(i));
            mBookmarked->GetColumn7()->Set(i, fileId);
        }
    }

    // conceptName is used only when bookmark does not have its own annotation
    virtual void
    SaveBookmarked(std::string fileName, std::string conceptName)
    {
        /* todo
        std::vector<CxIxRectZ> irList;
        CxIdSetWithAny<CxIxRectZ>* bookm = GetBookmarked();
        CxDataSet* dataSet = GetDataSet();
        for (int i=0 ; i<bookm->NrFilled() ; i++)
        {
            int fileId = bookm->GetId(i);
            CxIxRectZ ir;
            ir.mImageName = dataSet->GetFile(fileId);
            ir.mSection = dataSet->GetSectionOfFile(fileId);
            ir.mDir = dataSet->GetDirOfFile(fileId);
            ir.mRect = bookm->GetAny(i).mRect;
            ir.mAnno = bookm->GetAny(i).mAnno;
            if (ir.mAnno == std::string(""))
                ir.mAnno = conceptName;
            irList.push_back(ir);
        }
        CxFxWriteIxRectZ(fileName, irList.begin(), irList.end());
        */
    }

    std::string
    GetBookmarkedFileName()
    {
        return mBookmarkedFileName;
    }

    void
    LoadConceptsFromBookmarks()
    {
        for (int i=0 ; i<mBookmarked->Size() ; i++)
            AddConcept(mBookmarked->Get1(i));
    }

    // misc

    virtual void
    Clear()
    {
        Database::DataDocument::Clear();
        mBookmarked->SetEmpty();
    }

private:

    ImageSet*   mImSet;
    TableIxs*   mBookmarked;
    TableIds*   mBookmarkedIds;
    std::string mBookmarkedFileName; // filename of last loaded

};

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

#endif

---