---

SGNode.h

Go to the documentation of this file.

#ifndef __SG_NODE_H__
#define __SG_NODE_H__

#include "DAGNode.h"
#include "String.h"
#include "ApproxPoly.h"

#define  SHOCK_base 100
#define  SHOCK_2or3 100
#define  SHOCK_1        101
#define  SHOCK_2        102
#define  SHOCK_3        103
#define  SHOCK_4        104
#define  ROOT           105
#define  TEST_NODE      106

enum NODE_ROLE {UNK_ROLE = 0, BIRTH, PROTRUSION, UNION, DEATH, DUMMY};
enum ENDPT_TYPE {NOTSET_POINT, TERMINAL_POINT, JOINT_POINT, SPLIT_POINT};

struct ShockInfo
{
        double xcoord;  
        double ycoord;  
        double radius;  
        double speed;   
        double dr_ds;
        char color;
        double dr;              
        int type;
        int dir;                
        
        ShockInfo() { memset(this, 0, sizeof(ShockInfo)); } 
        
        virtual istream& Read(istream& is);
        virtual ostream& Write(ostream& os) const;
        void Print(ostream &os) const;
        
        friend ostream& operator<<(ostream& os, const ShockInfo& shock) { return shock.Write(os); }
        friend istream& operator>>(istream& is, ShockInfo& shock)               { return shock.Read(is); }
        
        bool operator==(const ShockInfo& rhs) const
        {
                return xcoord == rhs.xcoord && ycoord == rhs.ycoord;
        }
};

class ShockBranch : public SmartArray<ShockInfo>
{
        SEGMENTS segments;
        int dir;
        
        bool bValuesComputed;
        double area;
        double length;
        double avgRadius;
        double avgVelocity;
        
public:
        enum BRANCH_DIR {FORWARD, BACKWARD};

        ShockBranch() 
        {
                dir = 2; //diff than 0, 1, -1
                
                bValuesComputed = false;
                area = length = avgRadius = avgVelocity = 0;
        }
        
        void Clear()
        {
                SmartArray<ShockInfo>::Clear();
                
                segments.Clear();
                dir = 2; //diff than 0, 1, -1
                
                bValuesComputed = false;
                area = length = avgRadius = avgVelocity = 0;
        }
        
        ShockBranch(const ShockBranch& rhs)
        {
                operator=(rhs);
        }
        
        ShockBranch& operator=(const ShockBranch& rhs)
        {
                SmartArray<ShockInfo>::operator=(rhs);
                
                segments                = rhs.segments;
                dir                             = rhs.dir;
                                
                bValuesComputed = rhs.bValuesComputed;
                area                    = rhs.area;
                length                  = rhs.length;
                avgRadius               = rhs.avgRadius;
                avgVelocity     = rhs.avgVelocity;
                
                return *this;
        }
        
        ShockBranch& operator=(const SmartArray<ShockInfo>& rhs)
        {
                SmartArray<ShockInfo>::operator=(rhs);
                return *this;
        }

        bool operator==(const ShockBranch& rhs) const;
        bool operator!=(const ShockBranch& rhs) const { return !operator==(rhs); }

        bool operator>(const ShockBranch& rhs) const;
        bool operator<=(const ShockBranch& rhs) const { return !operator>(rhs); }

        bool operator<(const ShockBranch& rhs) const { return operator<=(rhs) && operator!=(rhs); }
        bool operator>=(const ShockBranch& rhs) const { return !operator<(rhs); }
        
        void GetEndPtRadius(double& r0, double& rN) const
        {       
                if (segments.GetSize() > 0) // Use segment' end pt, because the don't have outliers
                {
                        r0 = segments.GetHead().Y0();
                        rN = segments.GetTail().Y1();
                }
                else
                {
                        r0 = GetHead().radius;
                rN = GetTail().radius;
                }
        }
                
        const double& MinR() const 
        {
                double r0, rN;  
                GetEndPtRadius(r0, rN);
            return r0 < rN ? r0:rN;
        }

        const double& MaxR() const 
        { 
                double r0, rN;
                GetEndPtRadius(r0, rN);
            return r0 > rN ? r0:rN;
        }
        
        void SetDir(int d) { dir = d; }
        void SetSegments(const SEGMENTS& segs, const double& d);
        SEGMENTS GetSegments() const { return segments; }

        int GetDir(BRANCH_DIR d) const
        {
                ASSERT(dir == 0 || dir == 1 || dir == -1);
                return (d == FORWARD || dir == 0) ? dir:-dir;
        }       

        istream& Read(istream& is);
        ostream& Write(ostream& os) const;
        void Print(ostream &os = cout) const;
        
        void ComputeDerivedValues();
        
        double CompareAreas(const ShockBranch& rhs, const double& scale) const;
        double CompareRadii(const ShockBranch& rhs, const double& scale) const;
        double CompareVelocities(const ShockBranch& rhs, const double& scale) const;
        
        double Area() const             { ASSERT(bValuesComputed); return area; }
        double Length() const           { ASSERT(bValuesComputed); return length; }
        double AvgRadius() const        { ASSERT(bValuesComputed); return avgRadius; }
        double AvgVelocity() const      { ASSERT(bValuesComputed); return avgVelocity; }
};

class SGNode : public DAGNode
{
public:
        int m_nType;                            
        char m_cEndPt;                          
        double m_seg1, m_seg2;          
        String m_strBranchId;           
        ShockBranch m_shocks;           
        NODE_ROLE m_nRole;
        ENDPT_TYPE m_nEndPt0, m_nEndPtN;
        
        virtual DAGNode* CreateObject() const;
        
        // Operations
public:
        
        SGNode() { }
        SGNode(const SGNode &sb)                { SGNode::operator=(sb); }
        SGNode(String szId, int nType);
        
        void GetContourLength(double& seg1, double& seg2) const { seg1 = m_seg1; seg2 = m_seg2; }
        void SetContourLength(double& seg1, double& seg2) { m_seg1 = seg1; m_seg2 = seg2; }
        
        virtual void ComputeDerivedValues();
        
        void ComputeSpeeds();
        int GetShockCount() const { return m_shocks.GetSize(); }
        
        int GetType() const { return m_nType; }
        char GetEndPt() const { return m_cEndPt; }
        String GetBranchId() const { return m_strBranchId; }
        int GetBranchDir(ShockBranch::BRANCH_DIR d) const { return m_shocks.GetDir(d); }
        SEGMENTS GetSegments() const { return m_shocks.GetSegments(); }
        
        const ShockInfo& operator[](int i) const { return m_shocks[i]; }
        int GetSize() const { return m_shocks.GetSize(); }
        
        POINTS GetVelocityRadiusArray(int& d0, int& dn, bool bReverseOrder = false) const;
        
        void SetNodeType(int nType) { m_nType = nType; }
        
        NODE_ROLE GetNodeRole() const { return m_nRole; }
        void SetNodeRole(NODE_ROLE nRole) { m_nRole = nRole; }
        
        virtual void Clear();
        virtual DAGNode& operator=(const DAGNode& rhs);
        virtual void Print(ostream& os = cout) const;
        virtual istream& Read(istream& is);
        virtual ostream& Write(ostream& os) const;
        
        virtual NODE_LABEL GetLblForGraph() const;
        virtual leda_color GetColorForGraph() const;
        virtual int GetShapeForGraph() const;
};

#endif //__SG_NODE_H__

---