NodeInfo.hh

#ifndef __NodeInfo_hh__
#define __NodeInfo_hh__

#include <bias_config.h>
#include <Base/Debug/Error.hh>
#include <Base/Debug/Exception.hh>
#include <osg/Node>
#include <Base/Common/XMLBase.hh>
#include <sstream>
#include <GLviewer/OpenSceneGraphHelper.hh>
#include <GLviewer/Scenes/SceneOpenSceneGraphDefines.hh>

namespace BIAS
{
  
  enum eNodeType { eNT_Default = 0, 
                   eNT_FromDisk, 
                   eNT_FromImageFile, 
                   eNT_Marker, 
                   eNT_Light,
                   eNT_PointCloud, 
                   eNT_BBox, 
                   eNT_VNTriMesh};
  //add strings for xml output here -
  //( the enum is index in array - keep an eye on the right order)
  static std::string NodeTypeXMLStrings[]  = { "NT_Default",
                                               "NT_FromDisk",
                                               "NT_FromImageFile",
                                               "NT_Marker", 
                                               "NT_Light",
                                               "NT_PointCloud",
                                               "NT_BBox",
                                               "NT_VNTriMesh"};

  inline enum eNodeType String2NodeType(const std::string &val)
  {
    for(unsigned int s=0; s<sizeof(NodeTypeXMLStrings); s++){
      if(NodeTypeXMLStrings[s]==val){
        return (eNodeType) s;
      }
    }
    BEXCEPTION("String2NodeType(): Invalid string \""+val+"\"");
  }

  inline std::string NodeType2String(const enum eNodeType &t)
  { return NodeTypeXMLStrings[t]; }

  inline enum eNodeType GetNodeType(const osg::ref_ptr<osg::Node> node)
  {
    std::string stype;
    const bool found = 
      OpenSceneGraphHelper::HasInfo(node, SOSG_KEY_NODE_TYPE, stype);
    if (!found) return eNT_Default;
    return String2NodeType(stype);
  }
  
  
  /** @struct NodeInfo
      struct containing details of a OSG::Node when used in a 
      wxTreeCtrlOpenSGWx  */
  struct NodeInfo: public BIAS::XMLBase
  {
    NodeInfo()
    {
      Name       = "(Unnamed)";
      FileName   = "";
      NodeType   = eNT_Default;
      IsVisible  = true;
      IsEditable = false;
      IsExpanded = false;
      IsOccluder = false;
      IsClippingOutSide = true;
      SizeMM = 0.;
    };
    
    std::string  Name;
    std::string  FileName;
    
    //  bool         IsFromDisk;
    eNodeType    NodeType;
    bool         IsVisible; //is this node visible in treectrl?
    bool         IsEditable;
    bool         IsExpanded; //is tree item collapsed or expanded?
    bool         IsOccluder; 
    bool         IsClippingOutSide; //is clips bounding volume inside or outside
    double       SizeMM; // necessary for models generated from image files
    unsigned long long MarkerID;
    
    std::string  Id;  //only used for file io - move along. nothing to see here.
    
    virtual int XMLGetClassName(std::string &TopLevelTag, double &Version) const
    {
      TopLevelTag = "NodeInfo";
      Version = 1.0;
      return 0;
    };
    
    virtual int XMLIn(const xmlNodePtr Node, BIAS::XMLIO &XMLObject)
    {
      Id = XMLObject.getAttributeValueString(Node, "Id");
      Name = XMLObject.getAttributeValueString(Node, "Name");
      FileName = XMLObject.getAttributeValueString(Node, "FileName");
      
      std::string NodeInfoStr 
    = XMLObject.getAttributeValueString(Node, "NodeType");
      NodeType = eNT_Default;
      for(unsigned int s=0; s<sizeof(NodeTypeXMLStrings); s++)
    {
      if(NodeTypeXMLStrings[s]==NodeInfoStr)
        {
          NodeType =(eNodeType) s;
          break;
        }
    }
      if(NodeType==eNT_Marker)
    {
      std::stringstream ss;
      ss << XMLObject.getAttributeValueString(Node, "MarkerID");
      ss>>MarkerID;
    }
      IsVisible = XMLObject.getAttributeValueBool(Node, "IsVisible");
      IsEditable = XMLObject.getAttributeValueBool(Node, "IsEditable");
      IsExpanded = XMLObject.getAttributeValueBool(Node, "IsExpanded");
      IsOccluder = XMLObject.getAttributeValueBool(Node, "IsOccluder");
      if(NodeType==eNT_BBox)
      {
        IsClippingOutSide = 
            XMLObject.getAttributeValueBool(Node,"IsClippingOutSide");
      }
      return 0;
    }
    
    virtual int XMLOut(const xmlNodePtr Node, BIAS::XMLIO &XMLObject) const
    {
      XMLObject.addAttribute(Node, "Id", Id);
      XMLObject.addAttribute(Node, "Name", Name);
      XMLObject.addAttribute(Node, "FileName", FileName);
      // XMLObject.addAttribute(Node, "IsFromDisk", IsFromDisk);
      XMLObject.addAttribute(Node, "NodeType", NodeTypeXMLStrings[NodeType]);
      if(NodeType==eNT_Marker)
    {
      std::stringstream ss;
      ss<<MarkerID;
      XMLObject.addAttribute(Node, "MarkerID", ss.str());
    }
      XMLObject.addAttribute(Node, "IsVisible", IsVisible);
      XMLObject.addAttribute(Node, "IsEditable", IsEditable);
      XMLObject.addAttribute(Node, "IsExpanded", IsExpanded);
      XMLObject.addAttribute(Node, "IsOccluder", IsOccluder);
      if(NodeType==eNT_BBox)
      {
        XMLObject.addAttribute(Node, "IsClippingOutSide", 
                               IsClippingOutSide);
      }
      return 0;
    };
  };
  
  
  class NodeInfoMap:public std::map< osg::Node*, NodeInfo >,
                    public BIAS::XMLBase
  {
  public:
    NodeInfoMap()
    {
      areKeyPointersValid_ = true;
    }
    virtual int XMLGetClassName(std::string &TopLevelTag, double &Version) const
    {
      TopLevelTag = "NodeInfoMap";
      Version = 1.0;
      return 0;
    };
    
    virtual int XMLIn(const xmlNodePtr Node, BIAS::XMLIO &XMLObject)
    {      
      clear();
      xmlNodePtr Cur = XMLObject.getFirstChild(Node);
      areKeyPointersValid_ = false; //after loading the pointers can't be valid
      unsigned int dummycouter = 1;
      //read node infos
      while(Cur!=NULL)
      {
        osg::Node* invalidcrap = 
            (osg::Node* ) (long)dummycouter;//for this coding crime god kills a kitten
        NodeInfo temp;
        temp.XMLIn(Cur,XMLObject);
        (*this)[invalidcrap] = temp;
        Cur = XMLObject.getNextChild(Cur);
        dummycouter++;
      }
      return 0;
    }
    
    virtual int XMLOut(const xmlNodePtr Node, BIAS::XMLIO &XMLObject) const
    {
      //add children tag
      std::map< osg::Node*, NodeInfo >::const_iterator it;
      for(it=begin(); it!=end(); it++)
      {
        (*it).second.XMLAdd(Node,XMLObject);
      }
      return 0;
    };
    
    bool NodeHasNodeInfo(osg::Node* node) const
    {
      return(find(node)!=end());
    }
    
    bool AreKeyPointersValid()
    {
      return areKeyPointersValid_;
    };
    
  protected:
    bool areKeyPointersValid_;
  };
  
  
  /** @struct TreeDescr
      @brief container for scene root and ptr to nodeinfomap 
  */
  struct TreeDescr
  {
    osg::ref_ptr<osg::Node> RootNode;
    NodeInfoMap* pNodeInfoMap;
  };
  
}//end of namespace

#endif