---

DAGDatabase.h

Go to the documentation of this file.

#ifndef __DAGFILE_H__
#define __DAGFILE_H__

#include <iostream.h>
#include <LEDA/list.h>
#include <LEDA/sortseq.h>
#include <LEDA/array.h>

#include "DAGSearchDatabase.h"
#include "DAGDBFile.h"

class DAGList : public leda_list<DAGPtr>
{
        int nMaxDim;

public:
        DAGList() { nMaxDim = 0; }
        int GetMaxDim() const { return nMaxDim; }
        //void SetMaxDim(int nDim) { nMaxDim = nDim; }
        void Append(DAGPtr pDAG) 
        { 
           int n = ((const DAGPtr)pDAG)->GetMaxTSVDimension();

           if (n > nMaxDim)
                 nMaxDim = n;

          append(pDAG); 
        }
        int GetSize() const { return size(); }
};

struct MatchInfo
{
    int nDAGId;
        int nDAGOffset;
        double dSimilarity;
        DAGPtr ptrDAG;

        MatchInfo()
        {
                nDAGId = 0;
                nDAGOffset = 0;
                dSimilarity = 0;
        }

        void Set(int id, int offset, double similarity)
        {
                nDAGId = id;
                nDAGOffset = offset;
                dSimilarity = similarity;
        }

        void Set(DAGPtr ptr, double similarity)
        {
                ptrDAG = ptr;
                dSimilarity = similarity;
                nDAGOffset = ((const DAG*)ptr)->GetFileOffset();
                nDAGId = ((const DAG*)ptr)->GetDAGId();
        }

        const char* GetDAGLbl() const
        {
                return ptrDAG->GetDAGLbl();
        }

        friend int compare(const MatchInfo& a, const MatchInfo& b);
        
        // The stream operators are implemented only to satisfy LEDA requirements
        friend ostream& operator<<(ostream &os, const MatchInfo& mi) { return os; }
        friend istream& operator>>(istream &is, MatchInfo& mi) { return is; }
};

struct Vote
{
        int modelNode;
        leda_node imgNode;
        double vote;
        int dagId;
    int dagOffset;
    const DAG* pDag;

        Vote(const DAG* pImgDag) { pDag = pImgDag; modelNode = 0; imgNode = nil; vote = 0; }
        void operator=(const Vote& v)
        {
                modelNode = v.modelNode; 
                imgNode   = v.imgNode; 
                vote      = v.vote;
                dagOffset = v.dagOffset;
                dagId     = v.dagId;
        }
};

class VoteList //: public leda_list<Vote>
{
        int dagId;              //<! DAG's ID.
        int dagOffset;  //<! In case we need direct acces to the record. Not used anymore.
        LEDA_GRAPH<int, double> bipGraph;
        leda_list<leda_node> modelNodeSet; // Smaller set in general
        leda_list<leda_node> imgNodeSet; // Larger in general
        leda_edge_map<double> votes;

        leda_sortseq<int, leda_node> modelNodes;
        leda_sortseq<int, leda_node> imgNodes;

        double totalVote;

public:
        VoteList(int prot = -1) { dagId = -1; dagOffset = -1; totalVote = 0; }
        void AddVote(Vote& vote);
        double GetTotalVote(const DAG& dag, const double& minTotalVote);
        double SumAllVotes() const { return totalVote; }
        int GetDAGFileOffset() const { return dagOffset; }
};

typedef SmartPtr<DAGList> DAGListPtr;

class DAGDatabase
{
        DAGDBFile                       m_dagFile;
        DAGSearchDatabase       m_index;
        bool                            m_bIndexOpened;

public:
        DAGList                         m_dagList;

public:
        DAGDatabase() { m_bIndexOpened = false; }

        bool Create(const char* szName)
        {
                bool bFileExist = Open(szName, ios_base::in | ios_base::binary | ios_base::ate) && m_dagFile.tellg() > 0;
                Close();
                
                if (bFileExist)
                        return false;

                return Open(szName, ios_base::out | ios_base::binary | ios_base::trunc); //noreplace
        }

        bool Open(const char* szName, ios_base::openmode nMode = ios_base::in | ios_base::binary | ios_base::ate);
        bool OpenIndex();

        void Clear()
        {
                if (m_dagFile.is_open())
                        m_dagFile.close();

                if (m_bIndexOpened)
                {
                        m_index.Close();
                        m_bIndexOpened = false;
                }

                m_dagList.clear();
        }
        
        void Close() { Clear(); }

        int GetDAGCount() const { return m_dagFile.GetDAGCount(); }
        String GetFileName() const { return m_dagFile.GetName(); }

        DAGPtr ReadDAG(int nDagId, bool bOnlyDataForMatching = false)
        {
                return m_dagFile.ReadDAG(nDagId, bOnlyDataForMatching);
        }

        DAGPtr ReadDAG(streamoff nDagOffset, const String& strClassName)
        { 
                return m_dagFile.ReadDAG(nDagOffset, strClassName); 
        }

        bool AddDAG(const DAG* pDag, bool bReadSaveTailInfo = false)
        {
                return m_dagFile.AddDAG(pDag, bReadSaveTailInfo);
        }

        bool ReadObjView(DAG* pDAG, const char* szDAGLabel);
        bool ReadObjView(DAG* pDAG, int nRRN);
        bool ReadObjClass(DAG* pDAGReader, const char* szObjName);
        bool ReadAll(DAG* pDAGReader, int nMaxCount = -1);

        int GetSimilar(const DAG& dag, leda_array<MatchInfo>& matched, double range, 
                const double& w, const double& minSimilarity);

        int GetMaxTSVDimension() const
        {
                return m_index.GetDim();
        }

        const DAGPtr ChooseDAG() const;
        void ShowDAGList(ostream& os = cout);
        void ListDAGs(ostream& os = cout);

        DAGSearchDatabase& GetIndexDB() { ASSERT(m_bIndexOpened); return m_index; }
};

#endif //__DAGFILE_H__

---