---

GestureGraph.cpp

Go to the documentation of this file.

#include "DAG.h"
#include "GestureGraph.h"
#include "HelperFunctions.h"
#include "Exceptions.h"
#include "CompareHistogram.h"

void SkipComments(ifstream& is)
{
        char ch;

        is.get(ch);
        
        while (ch == '#' || ch == '\n' || ch == ' ')
        {
                // read comments
                if(ch == '#')
                        while (ch != '\n')
                                is.get(ch);
                        
                is.get(ch);
        }
        
        is.seekg(-1, ios::cur);
}

// GestureGraph class implementation

void GestureGraph::Clear()
{ 
        DAG::Clear();

        relationMatrix.Clear();
        hierarchicalMatrix.Clear();
        hierarchyLevels.Clear();
        m_nRootNodeCount = 0;
}

bool GestureGraph::Read(String strFileName)
{
        GGNode* p;
        int n, m, nVertices;
        char szNodeLbl[50];
        
        ifstream is(strFileName, ios::in);
        
        if (is.fail()) 
        {
                cerr << "Error: Cannot open file " << strFileName << endl;
                return false;
        }

        SkipComments(is);

        is >> m_nRootNodeCount;

        SkipComments(is);
        
        is >> nVertices;

        relationMatrix.ReSize(nVertices, nVertices);
        hierarchicalMatrix.ReSize(nVertices, nVertices);
        hierarchyLevels.ReSize(nVertices);
  
        SkipComments(is);
        
        for(n = 0; n < nVertices; n++)
        {
                p = new GGNode;
                
                is >> p->m_nType >> p->m_dSign >> p->m_dScale >> p->m_nXPos 
                        >> p->m_nYPos >> p->m_dA >> p->m_dB >> p->m_dOrientation 
                        >> p->m_dAnisotropy >> p->m_dUnkField;

                p->m_nNodeIndex = n;
                sprintf(szNodeLbl, "%d:%d", n, p->m_nType);
                p->SetNodeLbl(szNodeLbl);

                NewNode(p);
        }

        SkipComments(is);
        
        for(n = 0; n < nVertices; n++)
                for(m = 0; m < nVertices; m++)
                        is >> relationMatrix[n][m];

        SkipComments(is);
        
        for(n = 0; n < nVertices; n++)
                is >> hierarchyLevels[n];

        SkipComments(is);
        
        for(n = 0; n < nVertices; n++)
        {
                for (m = 0; m < nVertices; m++)
                {
                        is >> hierarchicalMatrix[n][m];

                        if (hierarchicalMatrix[n][m] == 1)
                                NewEdge(GetNode(n), GetNode(m), 1);
                }
        }                       

        SetDAGLbl(strFileName);
        strObjectName = strFileName;
        ComputeDerivedValues();
  BuildMatrices();
  BuildNodeHistograms();
  
        return true;
}

void GestureGraph::BuildMatrices()
{
  int nVertices = ;
  leda_node v,u;
  float distance;
  int indexV, indexU;
  
  EuclideanDistance.ReSize(nVertices, nVertices);
  Scale.ReSize(nVertices,1);
  Bearing.ReSize(nVertices,1); //to fill in later

  forall_nodes(v, *this) {
    const GGNode* pV = GetNode(v);
    indexV = pV->GetDFSIndex();
    
    forall_nodes(u, *this){
      const GGNode* pU = GetNode(u);
      
      distance = sqrt(pow((pV->m_nXPos - pU->m_nXPos),2)
        + pow((pV->m_nYPos - pU->m_nYPos),2));
      
      indexU = pU->GetDFSIndex();
      EuclideanDistance(indexV,indexU) = distance;
    }
    /*
    sum_scales = pV->m_dScale;
    forall_adj_nodes(u, v){
      const GGNode* pU = GetNode(u);
      sum_scales += pV->m_dScale;
    }
    Scale(indexV,1) = pV->m_dScale / sum_scales;
    */
    Scale(indexV,1) = pV->m_dScale;
    
  }
  
}

void GestureGraph::BuildNodeHistograms()
{
        float sum_distance = 0, sum_scale = 0;
        int indexV, indexU, n, i;
        
        forall_nodes(v, *this) {
                const GGNode* pV = GetNode(v);
                indexV = pV->GetDFSIndex();

                sum_scale = pV->m_dScale;
                forall_adj_nodes(u, v) {
                        const GGNode* pU = GetNode(u);
                        indexU = pU->GetDFSIndex();

                        sum_scales += pU->m_dScale;
                        sum_distance += EuclideanDistance(indexV,indexU);
                }
        }

        
        forall_nodes(v, *this) {
                const GGNode* pV = GetNode(v);
                n = degree(v);
                m_xCoords.ReSize(n);
                m_weights.ReSize(n);
                m_scales.ReSize(n);
                indexV = pV->GetDFSIndex();

                i = 0;
                forall_adj_nodes(u, v) {
                        const GGNode* pU = GetNode(u);
                        indexU = pU->GetDFSIndex();

                        m_xCoords[i] = EuclideanDistance(indexV,indexU) / sum_distance;
                        m_weights[i] = 1.0;
                        m_scales[i] = pU->m_dScale / sum_scale;
                        i++;
                        
                }
        }

        
}

istream& GestureGraph::Read(istream& is, bool bOnlyDataForMatching /*= false*/)
{
        DAG::Read(is);

        hierarchyLevels.Read(is);
        hierarchicalMatrix.Read(is);
        relationMatrix.Read(is);
        is.read((char*) &m_nRootNodeCount, sizeof(m_nRootNodeCount));

        return is;
}

ostream& GestureGraph::Write(ostream& os) const
{
        DAG::Write(os);

        hierarchyLevels.Write(os);
        hierarchicalMatrix.Write(os);
        relationMatrix.Write(os);
        os.write((char*) &m_nRootNodeCount, sizeof(m_nRootNodeCount));

        return os;
}

void GestureGraph::Print(ostream& os) const
{
        DAG::Print(os);

        // add new stuff here
}

DAG& GestureGraph::operator=(const DAG& rhs)
{
        DAG::operator=(rhs);

        const GestureGraph* pRhs = dynamic_cast<const GestureGraph*>(&rhs);
        
        if (!pRhs)
                THROW_EXCEPTION("Invalid pointer type.");

        hierarchyLevels    = pRhs->hierarchyLevels;
        hierarchicalMatrix = pRhs->hierarchicalMatrix;
        relationMatrix     = pRhs->relationMatrix;
        m_nRootNodeCount   = pRhs->m_nRootNodeCount;

        return *this;
}

bool GestureGraph::AreNodesRelated(leda_node u, const DAG& from, leda_node v) const
{
        const GestureGraph& sgFrom = dynamic_cast<const GestureGraph&>(from);

        // add stuff here

        return true;
}

DAG* GestureGraph::CreateObject() const
{
        return new GestureGraph;
}

DAGNodePtr GestureGraph::CreateNodeObject(NODE_LABEL lbl) const
{
        return new GGNode;
}

DAGNodePtr GestureGraph::ReadNode(istream& is) const
{
        DAGNodePtr node(new GGNode);

        node->Read(is);

        return node;
}

String GestureGraph::ClassName() const
{
        return "GestureGraph";
}

double GestureGraph::NodeDistance(leda_node u, const DAG& from, leda_node v) const
{
 int i;
 double hist_distance, hist_scale;
 leda_list_item it;
 cerr << "GestureGraph::NodeDistance not implemented!" << endl;
 const GestureGraph& ggFrom = dynamic_cast<const GestureGraph&>(from);
 const GGNode* pU = GetNode(u);
 const GGNode* pV = ggFrom->GetNode(v);

 hist_distance = CompareHistograms(pU->m_xCoords, pU->m_weights,
                pV->m_xCoords, pV->m_weights);
 hist_scale = CompareHistograms(pU->m_scales, pU->m_scales,
                pV->m_scales, pV->m_scales);
 

 //For now, we'll return the average
 return (hist_distance + hist_scale) / 2.0;
}

/*
 * For a given node, the         following method counts the number of its siblings,
 * parents and children, if any.
 * This number is necassary to create an input file to
 * feed the earth mover's distance code.
 */
int GestureGraph::Get_number_of_relations(int node){
                                                                                
 int counter = 0; //The first number accounts for the node itself.
 int nVertices = hierarchyLevels.GetSize();

//cout << "no_vertices from size :" << hierarchyLevels.GetSize() << endl;   
                                                                            
 for(int i=0; i < nVertices; i++){
                                                                                
        if (hierarchicalMatrix[node][i]!=0) //count all the relations.
                 counter++;
                                                                                
 }

 return counter;
                                                                                
}


int GestureGraph::Get_nth_relation(int n, int node){
                                                                                
  int no = 0;
  int nVertices = hierarchyLevels.GetSize();
                                                                                
        for (int i=0; i<nVertices; i++){
                if (hierarchicalMatrix[node][i] != 0)
                        no++;
                                                                                
                if (no==n)
                        return i;
        }
                                                                                
 return 0;
}

/*
 * Computing the Euclidean distance between 2 nodes.
 */

float GestureGraph::Get_distance(int node1, int node2){

 const DAGNode *dag_ptr1 = GetNode(GetNode(node1));
 const GGNode *p1 = dynamic_cast<const GGNode*>(dag_ptr1);

 const DAGNode *dag_ptr2 = GetNode(GetNode(node2));
 const GGNode *p2 = dynamic_cast<const GGNode*>(dag_ptr2);

 int x1 = p1->m_nXPos;
 int y1 = p1->m_nYPos;
 int x2 = p2->m_nXPos;
 int y2 = p2->m_nYPos;
 float temp = (x1-x2)*(x1-x2) + (y1-y2)*(y1-y2);
 
 return sqrt(temp);
}


int GestureGraph::Get_xpos(int node){

 const DAGNode *dag_ptr = GetNode(GetNode(node));
 const GGNode *p = dynamic_cast<const GGNode*>(dag_ptr);

 return p->m_nXPos;

}

int GestureGraph::Get_ypos(int node){

 const DAGNode *dag_ptr = GetNode(GetNode(node));
 const GGNode *p = dynamic_cast<const GGNode*>(dag_ptr);

 return p->m_nYPos;

}

---