---

SGNode.cpp

Go to the documentation of this file.

#include "SGNode.h"
#include "HelperFunctions.h"
#include "Exceptions.h"
#include <stdio.h>
#include <ctype.h>

#include <LEDA/graphwin.h> // needed only for the gw_node_shape enum values

#define NOT_TO_COMPARE_PERCENTAGE .15
#define MIN_LIGATURE .7

// ShockInfo class implementation

istream& ShockInfo::Read(istream& is)
{
        return is.read((char*)this, sizeof(ShockInfo));
}

ostream& ShockInfo::Write(ostream& os) const
{
        return os.write((char*)this, sizeof(ShockInfo));
}

void ShockInfo::Print(ostream& os) const
{
        PRINT_OPEN(os, xcoord);
        PRINT(os, ycoord);
        PRINT(os, radius);
        PRINT(os, type);
        PRINT(os, dir);
        PRINT(os, dr);
        PRINT(os, speed);
        PRINT(os, dr_ds);
        PRINT_CLOSE(os, int(color));
}

// SGNode class implementation


// Begin DAGNode virtual functions

DAGNode* SGNode::CreateObject() const
{
        return (DAGNode*) new SGNode();
}

void SGNode::Clear()
{
        DAGNode::Clear();

        m_nType       = 0;
        m_nRole = UNK_ROLE;

        m_cEndPt          = 0;
        m_seg1            = 0;
        m_seg2            = 0;
        m_strBranchId.Clear();
        m_shocks.Clear();
        
        m_nEndPt0 = NOTSET_POINT;
        m_nEndPtN = NOTSET_POINT;
}

DAGNode& SGNode::operator=(const DAGNode& rhs)
{
        DAGNode::operator=(rhs);

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

        m_nType       = pRhs->m_nType;
        m_nRole           = pRhs->m_nRole;

        m_cEndPt          = pRhs->m_cEndPt;
        m_seg1            = pRhs->m_seg1;
        m_seg2            = pRhs->m_seg2;
        m_strBranchId = pRhs->m_strBranchId;
        m_shocks      = pRhs->m_shocks;
        
        m_nEndPt0     = pRhs->m_nEndPt0;
        m_nEndPtN     = pRhs->m_nEndPtN;

        return *this;
}

// End DAGNode virtual functions

SGNode::SGNode(String szId, int nType) : DAGNode(szId)
{
        m_nType = nType;
        m_strBranchId = szId;
        m_cEndPt = '\0';
        m_seg1 = m_seg2 = 0.0;

        for (int i = 0, len = szId.Len(); i < len; i++)
        {
                if (!isdigit(szId[i]))
                {
                        m_cEndPt = szId[i];
                        break;
                }
        }
}

void SGNode::ComputeDerivedValues()
{
        DAGNode::ComputeDerivedValues();

        m_shocks.ComputeDerivedValues();
}

void SGNode::ComputeSpeeds()
{
        for (int i = 1, size = m_shocks.GetSize(); i < size; i++)
                m_shocks[i].speed = m_shocks[i].radius - m_shocks[i-1].radius;

        m_shocks[0].speed = m_shocks[1].speed;
}

istream& SGNode::Read(istream& is)
{
        DAGNode::Read(is);

        is.read((char*) &m_nType, sizeof(m_nType));
        is.read((char*) &m_nRole, sizeof(m_nRole));
        is.read((char*) &m_cEndPt, sizeof(m_cEndPt));
        is.read((char*) &m_seg1, sizeof(m_seg1));
        is.read((char*) &m_seg2, sizeof(m_seg2));
        is.read((char*) &m_nEndPt0, sizeof(m_nEndPt0));
        is.read((char*) &m_nEndPtN, sizeof(m_nEndPtN));
        
        m_strBranchId.Read(is);
        m_shocks.Read(is);

        return is;
}

ostream& SGNode::Write(ostream& os) const
{
        DAGNode::Write(os);

        os.write((char*) &m_nType, sizeof(m_nType));
        os.write((char*) &m_nRole, sizeof(m_nRole));
        os.write((char*) &m_cEndPt, sizeof(m_cEndPt));
        os.write((char*) &m_seg1, sizeof(m_seg1));
        os.write((char*) &m_seg2, sizeof(m_seg2));
        os.write((char*) &m_nEndPt0, sizeof(m_nEndPt0));
        os.write((char*) &m_nEndPtN, sizeof(m_nEndPtN));

        m_strBranchId.Write(os);
        m_shocks.Write(os);

        return os;
}

void SGNode::Print(ostream& os) const
{
        DAGNode::Print(os);

        PRINT_OPEN(os, m_strBranchId);
        PRINT(os, m_nType);
        PRINT(os, m_nRole);
        PRINT(os, GetShockCount());
        PRINT(os, m_seg1);
        PRINT_CLOSE(os, m_seg2);
}

NODE_LABEL SGNode::GetLblForGraph() const
{
        char lbl[100];

        sprintf(lbl, "%s:%d",
                (const char*) GetNodeLbl(),
                m_nType - 100);
        
        /*sprintf(lbl, "%s:%d",
                (const char*) GetNodeLbl(),
                GetDFSIndex());*/

        //sprintf(lbl, "%d:%d", GetDFSIndex(), m_nType - 100);

        return lbl;
}

leda_color SGNode::GetColorForGraph() const 
{ 
        unsigned char c;

        /*if (m_seg1 < 2.0 && m_seg2 < 2.0)
                c = 128;
        else if (m_seg1 < 2.0 || m_seg2 < 2.0)
                c = 192;
        else*/
                c = 255;

        return leda_color(c, c, c);
}

int SGNode::GetShapeForGraph() const
{
  //using namespace LEDA;

        /*int nShockCount = GetShockCount();

        if (nShockCount == 0) // The root node has no shock
                return leda_ellipse_node;

        double r1 = m_seg1 / nShockCount;
        double r2 = m_seg2 / nShockCount;

        if (r1 >= MIN_LIGATURE && r2 >= MIN_LIGATURE)
                return ellipse_node;
        else if (r1 >= MIN_LIGATURE || r2 >= MIN_LIGATURE)
                return leda_roundrect_node;
        else
                return leda_rectangle_node;*/
        return leda_ellipse_node;
}

POINTS SGNode::GetVelocityRadiusArray(int& d0, int& dN, bool bReverseOrder /*=false*/) const
{
        int i, nSize = m_shocks.GetSize();
        double s;
        
        // we don't want to consider those end points that join branches
        // because they're usually outliers wrt to the branch pts.
        ASSERT(m_nEndPt0 != NOTSET_POINT && m_nEndPtN != NOTSET_POINT);
        
        d0 = (nSize > 3 && m_nEndPt0 == JOINT_POINT) ? 1:0;
        dN = (nSize > 3 && m_nEndPtN == JOINT_POINT) ? 1:0;
        nSize -= d0 + dN;

        POINTS data(nSize);
        
        if (!bReverseOrder)
        {
                for (i = 0, s = 0.0; i < nSize; i++)
                {
                        const ShockInfo& si = m_shocks[i + d0];
                        data[i].Set(s += si.speed, si.radius);
                }
        }
        else
        {
                int nLast = nSize - 1 + d0;
                
                for (i = 0, s = 0.0; i < nSize; i++)
                {
                        const ShockInfo& si = m_shocks[nLast - i];
                        data[i].Set(s += si.speed, si.radius);
                }
        }
                
        return data;
}

// ShockBranch

void ShockBranch::Print(ostream &os) const
{
  for (int i = 0; i < GetSize(); i++)
  {
    os << endl;
    operator[](i).Print(os);
  }

  os << endl;
  PRINT_OPEN(os, avgRadius);
  PRINT(os, area);
  PRINT(os, length);
  PRINT(os, avgVelocity);
  PRINT(os, MinR());
  PRINT_CLOSE(os, MaxR());
  segments.Print(os);
  os << endl;
}

double ShockBranch::CompareAreas(const ShockBranch& rhs, const double& scale) const
{
        double a1, a2;

        a1 = Area();
        a2 = rhs.Area() * scale;

        return SIMILARITY(a1, a2);
}

double ShockBranch::CompareRadii(const ShockBranch& rhs, const double& scale) const
{
        double a1, a2;

        a1 = AvgRadius();
        a2 = rhs.AvgRadius() * scale;

        return SIMILARITY(a1, a2);
}

int CompareShockDrDs(const void* elem1, const void* elem2)
{
        ShockInfo* e1 = (ShockInfo*) elem1;
        ShockInfo* e2 = (ShockInfo*) elem2;

        ASSERT(e1 && e2);

        if (e1->dr_ds > e2->dr_ds)
                return 1;
        else if (e1->dr_ds < e2->dr_ds)
                return -1;
        else
                return 0;
}

double ShockBranch::CompareVelocities(const ShockBranch& rhs, const double& scale) const
{
        double avg1, avg2;

        avg1 = AvgVelocity();
        avg2 = rhs.AvgVelocity() * scale;

        return SIMILARITY(avg1, avg2);
}

void ShockBranch::ComputeDerivedValues()
{
        int i, size = GetSize();
        double dx, dy, prevRadius, mean_x;

        area = 0;
        avgRadius = 0;
        avgVelocity = 0;
        length = 0;

        bValuesComputed = true;

        if (size == 0)
                return;
        else if (size == 1)
        {
                avgRadius = operator[](0).radius;
                area = 2 * avgRadius;
                return;
        }

        for (i = 0; i < size; i++)
        {
                const ShockInfo& si = (*this)[i];

                length += si.speed; // speed is delta s
                //avgRadius += si.radius;

                // The area is the sum of the trapezoids
                if (i > 0)
                        area += .5 * (prevRadius + si.radius) * si.speed;

                prevRadius = si.radius;
        }

        // Compute the average radius of the brach.
        //avgRadius /= size;
        
        ASSERT(segments.GetSize() > 0);
        
        for (i = 0; i < segments.GetSize(); i++)
        {
                const SEGMENT& s = segments[i];
                
                mean_x = (s.p0.x + s.p1.x) / 2.0;
                avgRadius += s.m * mean_x + s.b;
        }
        
        avgRadius /= segments.GetSize();
                
        ASSERT(avgRadius >= 0);


        // Compute the average velocity of the brach.
        // Firts, eliminate NOT_TO_COMPARE_PERCENTAGE percentage 
        // of the extreme values before computing avg.
        ShockBranch b(*this);
        int min, max, nanCount = 0;

        ASSERT(NOT_TO_COMPARE_PERCENTAGE > 0 && NOT_TO_COMPARE_PERCENTAGE <= 1);

        b.Sort(CompareShockDrDs);

        min = round(size * NOT_TO_COMPARE_PERCENTAGE);
        max = size - min;

        for (i = min; i < max; i++)
        {
                if (isnan(b[i].dr_ds) || !finite(b[i].dr_ds))
                {
                        //DBG_MSG("Illegal dr_ds value!!!");
                        nanCount++;
                        continue;
                }

                avgVelocity += b[i].dr_ds;
        }

        if (avgVelocity != 0)
                avgVelocity /= max - min - nanCount;
}

istream& ShockBranch::Read(istream& is)
{
        SmartArray<ShockInfo>::Read(is);
        
        segments.Read(is);
        is.read((char*) &dir, sizeof(dir));

        is.read((char*) &bValuesComputed, sizeof(bValuesComputed));
        is.read((char*) &area, sizeof(area));
        is.read((char*) &length, sizeof(length));
        is.read((char*) &avgRadius, sizeof(avgRadius));
        is.read((char*) &avgVelocity, sizeof(avgVelocity));
        
        return is;
}

ostream& ShockBranch::Write(ostream& os) const
{
        SmartArray<ShockInfo>::Write(os);

        segments.Write(os);     
        os.write((char*) &dir, sizeof(dir));

        os.write((char*) &bValuesComputed, sizeof(bValuesComputed));
        os.write((char*) &area, sizeof(area));
        os.write((char*) &length, sizeof(length));
        os.write((char*) &avgRadius, sizeof(avgRadius));
        os.write((char*) &avgVelocity, sizeof(avgVelocity));

        return os;
}

bool ShockBranch::operator==(const ShockBranch& rhs) const
{
        ASSERT(bValuesComputed && rhs.bValuesComputed);

        return AvgRadius() == rhs.AvgRadius();
}

bool ShockBranch::operator>(const ShockBranch& rhs) const
{
        ASSERT(bValuesComputed && rhs.bValuesComputed);

        // If either branch has only one shock, it is likely that this one shock
        // will have some error. So, we must treat this case differently.

        //if (GetSize() == rhs.GetSize() || (GetSize() > 1 && rhs.GetSize() > 1))       
                return AvgRadius() > rhs.AvgRadius();
        //else
        //      return MaxR() > rhs.MaxR() || MinR() > rhs.MinR();
}

void ShockBranch::SetSegments(const SEGMENTS& segs, const double& d)
{
        ASSERT(d >= 0);
        segments = segs;
        
        // first segment should start at point zero
        if (d > 0.0)
        {
                // Shift all the segments by d
                for(int i = 0; i < segments.GetSize(); i++)
                {
                        SEGMENT& s = segments[i];
                        s.p0.x -= d;
                        s.p1.x -= d;
                        s.b += s.m * d;
                }
        }
}

---