albaVME.h

Go to the documentation of this file.

/*=========================================================================
 
 Program: ALBA (Agile Library for Biomedical Applications)
 Module: albaVME
 Authors: Marco Petrone
 
 Copyright (c) BIC
 All rights reserved. See Copyright.txt or
 
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notice for more information.
 
=========================================================================*/
#ifndef __albaVME_h
#define __albaVME_h
//----------------------------------------------------------------------------
// includes :
//----------------------------------------------------------------------------
#include "albaReferenceCounted.h"
#include "albaStorable.h"
#include "albaSmartPointer.h"
#include "albaObserver.h"
#include "albaEventBroadcaster.h"
#include "albaTagItem.h"
#include "albaString.h"
#include "albaTimeStamped.h"
#include "albaAttribute.h"
#include "albaDecl.h"
#include <vector>
#include <map>
#include <set>
#include <string>
 
#include "albaVMEOutput.h"
#include "albaDataPipe.h"
#include "albaMatrixPipe.h"
#include "albaAbsMatrixPipe.h"
#include "albaServiceClient.h"
#include "albaAbsLogicManager.h"
 
//----------------------------------------------------------------------------
// forward declarations :
//----------------------------------------------------------------------------
class albaMatrix;
class albaTransform;
class albaInteractor;
class albaVMEIterator;
class albaTagArray;
class albaGUI;
 
 
typedef enum LinkType
{
   NORMAL_LINK,
   MANDATORY_LINK,
} LinkType;
 
struct ALBA_EXPORT albaOldSubIdLink :public albaUtility
{
public:
   albaOldSubIdLink(albaString name,albaID id = -1, albaID sub_id = -1):m_Name(name), m_NodeId(id), m_NodeSubId(sub_id) {}
   albaString m_Name;
   albaID   m_NodeId;
   albaID   m_NodeSubId;
};
 
struct ALBA_EXPORT albaVMELink :public albaUtility
{
public:
   albaVMELink(albaID id = -1, albaVME *node = NULL, LinkType type = NORMAL_LINK) :m_NodeId(id), m_Node(node), m_Type(type) {}
   albaID   m_NodeId;
   albaVME *m_Node;
   LinkType m_Type;
};
 
struct ALBA_EXPORT albaVMEBackLink :public albaUtility
{
public:
   albaVMEBackLink(albaString name, albaVME *node = NULL):m_Name(name), m_Node(node) {}
   albaString m_Name;
   albaVME *m_Node;
};
 
 
 
#ifdef ALBA_EXPORTS
#include "albaDllMacros.h"
EXPORT_STL_VECTOR(ALBA_EXPORT, albaAutoPointer<albaVME>);
#endif
 
 
#ifdef ALBA_EXPORTS
template class ALBA_EXPORT albaAutoPointer<albaDataPipe>;
template class ALBA_EXPORT albaAutoPointer<albaMatrixPipe>;
template class ALBA_EXPORT albaAutoPointer<albaAbsMatrixPipe>;
#endif
 
class ALBA_EXPORT albaVME : public albaReferenceCounted, public albaEventBroadcaster, public albaStorable, public albaObserver, public albaTimeStamped, public albaServiceClient
{
public:
  
   albaAbstractTypeMacro(albaVME, albaReferenceCounted);
 
   enum VME_WIDGET_ID
   {
      ID_NAME = MINID,
      ID_PRINT_INFO,
      ID_HELP,
      ID_LAST
   };
 
   virtual albaObject *NewObjectInstance() const { return NULL; }
 
   albaVME *NewInstance() { return SafeDownCast(NewObjectInstance()); }
 
   int Initialize();
 
   void Shutdown();
 
   int IsInitialized() { return m_Initialized; }
 
   int Store();
 
   int Restore();
 
   const char *GetName() { return m_Name; }
 
   virtual void SetName(const char *name);
 
   
   //virtual int ShallowCopy(albaVME *a);
 
   virtual bool CanCopy(albaVME *vme);
 
   static albaVME *MakeCopy(albaVME *a);
   albaVME *MakeCopy() { return MakeCopy(this); }
 
   static albaVME *CopyTree(albaVME *vme, albaVME *parent = NULL);
 
   albaVME *CopyTree() { return CopyTree(this); }
 
   albaVME *GetChild(albaID idx, bool onlyVisible = false);
   albaVME *GetFirstChild(bool onlyVisible = false);
   albaVME *GetLastChild(bool onlyVisible = false);
 
   albaVME *GetByPath(const char *path, bool onlyVisible = true);
 
   virtual int AddChild(albaVME *node);
 
   virtual void RemoveChild(const albaID idx, bool onlyVisible = false);
   virtual void RemoveChild(albaVME *node);
 
   int FindNodeIdx(albaVME *a, bool onlyVisible = false);
 
   int FindNodeIdx(const char *name, bool onlyVisible = false);
 
   albaVME *FindInTreeByTag(const char *name, const char *value = "", int type = ALBA_STRING_TAG);
 
   albaVME *FindInTreeByName(const char *name, bool match_case = true, bool whole_word = true);
 
   albaVME *FindInTreeById(const albaID id);
 
   virtual int ReparentTo(albaVME *parent);
 
   void Import(albaVME *tree);
 
   bool IsAChild(albaVME *a);
 
   bool IsInTree(albaVME *a);
 
   albaVME *GetRoot();
 
   bool IsEmpty() const { return GetNumberOfChildren() == 0; }
 
   bool IsOnVMETree() { return m_Parent !=NULL; };
 
   unsigned long GetNumberOfChildren() const;
 
   unsigned long GetNumberOfChildren(bool onlyVisible);
 
   void CleanTree();
 
   void RemoveAllChildren();
 
   albaVMEIterator *NewIterator();
 
   void SetVisibleToTraverse(bool flag) { m_VisibleToTraverse = flag; }
   bool GetVisibleToTraverse() { return m_VisibleToTraverse; }
 
   bool IsVisible() { return m_VisibleToTraverse; }
 
   bool CompareTree(albaVME *vme);
 
   virtual void UnRegister(void *o);
 
   virtual void OnEvent(albaEventBase *e);
 
   typedef std::vector<albaAutoPointer<albaVME> > albaChildrenVector;
 
   const albaChildrenVector *GetChildren() { return &m_Children; }
 
   typedef std::map<albaString, albaAutoPointer<albaAttribute> > albaAttributesMap;
 
   albaAttributesMap *GetAttributes() { return &m_Attributes; }
 
   void SetAttribute(const char *name, albaAttribute *a);
 
   albaAttribute *GetAttribute(const char *name);
 
   void RemoveAttribute(const char *name);
 
   void RemoveAllAttributes();
 
   albaTagArray  *GetTagArray();
         
   typedef std::map<albaString, albaVMELink> albaLinksMap;
   typedef std::set<albaVME *> albaVMESet;
   typedef std::vector<albaVMEBackLink> albaVMEBackLinks;
 
   albaVME *GetLink(const char *name);
 
   void SetLink(const char *name, albaVME *node);
 
   void SetMandatoryLink(const char *name, albaVME *node);
 
   void SetLink(const char *name, albaVME *node, LinkType type);
 
   void SetLinkToMandatory(char* link);
 
   void SetLinkToNonMandatory(char* link);
 
   void AddBackLink(const char *name, albaVME *node);
 
   void RemoveBackLink(const char *name, albaVME *node);
 
   void SetOldSubIdLink(albaString link_name, albaID link_node_id, albaID link_node_subid);
 
   void RemoveLink(const char *name);
 
   albaID GetNumberOfLinks() { return m_Links.size(); }
 
   albaID GetNumberOfBackLinks() { return m_BackLinks.size(); }
 
   albaVMEBackLinks GetBackLinks() { return m_BackLinks; }
 
   void RemoveAllLinks();
 
   void RemoveAllBackLinks() { m_BackLinks.clear(); }
 
   albaVMESet GetDependenciesVMEs();
   
   void RemoveDependenciesVMEs();
 
   bool WillBeRemovedWithDependencies(albaVME *vme);
 
   albaLinksMap *GetLinks() { return &m_Links; }
 
   void ForwardUpEvent(albaEventBase *alba_event);
   void ForwardUpEvent(albaEventBase &alba_event);
 
   void ForwardDownEvent(albaEventBase *alba_event);
   void ForwardDownEvent(albaEventBase &alba_event);
 
 
   albaGUI *GetGui();
 
   void DeleteGui();
 
   albaID GetId() const;
 
   static char ** GetIcon();
 
   void UpdateId();
 
   virtual unsigned long GetMTime();
 
   void DependsOnLinkedNodeOn() { m_DependsOnLinkedNode = true; };
 
   void DependsOnLinkedNodeOff() { m_DependsOnLinkedNode = false; };
 
  enum VME_VISUAL_MODE
  {
    DEFAULT_VISUAL_MODE = 0,
    NO_DATA_VISUAL_MODE
  };
 
  //typedef std::vector<albaTimeStamp> std::vector<albaTimeStamp>;
 
  virtual void Print(std::ostream& os, const int tabs=0);// const;
 
      albaVME *GetParent() const { return m_Parent; };
  
  virtual int DeepCopy(albaVME *a);
 
  virtual int ShallowCopy(albaVME *a);
 
  virtual bool Equals(albaVME *vme);
 
  virtual void SetTimeStamp(albaTimeStamp t);
  virtual albaTimeStamp GetTimeStamp();  
 
  void SetTreeTime(albaTimeStamp t);
 
  virtual void SetMatrix(const albaMatrix &mat)=0;
 
  void SetPose(const albaMatrix &mat,albaTimeStamp t);
 
  void SetPose(double x,double y,double z,double rx,double ry,double rz, albaTimeStamp t);
 
  void SetPose(double xyz[3],double rxyz[3], albaTimeStamp t);
 
  void ApplyMatrix(const albaMatrix &matrix,int premultiply,albaTimeStamp t=-1);
  
  void SetAbsPose(double x,double y,double z,double rx,double ry,double rz, albaTimeStamp t=-1);
  void SetAbsPose(double xyz[3],double rxyz[3], albaTimeStamp t=-1);
  void SetAbsMatrix(const albaMatrix &matrix,albaTimeStamp t);
  virtual void SetAbsMatrix(const albaMatrix &matrix);
 
  void ApplyAbsMatrix(const albaMatrix &matrix,int premultiply,albaTimeStamp t=-1);
 
  virtual bool CanReparentTo(albaVME *parent);
  
  // to be revised
   //int SetAuxiliaryRefSys(mflTransform *AuxRefSys, const char *RefSysName, int type = MFL_LOCAL_FRAME_TAG);
  //int SetAuxiliaryRefSys(vtkMatrix4x4 *AuxRefSys, const char *RefSysName, int type = MFL_LOCAL_FRAME_TAG);
  
  // to be revises
  //int GetAuxiliaryRefSys(mflTransform *AuxRefSys, const char *RefSysName, int type = MFL_LOCAL_FRAME_TAG);
  //int GetAuxiliaryRefSys(vtkMatrix4x4 *AuxRefSys, const char *RefSysName, int type = MFL_LOCAL_FRAME_TAG);
  
  albaMatrixPipe *GetMatrixPipe() {return m_MatrixPipe;}
  
  albaAbsMatrixPipe *GetAbsMatrixPipe() {return m_AbsMatrixPipe;}
  
  albaDataPipe *GetDataPipe() {return m_DataPipe;}
 
  virtual void Update();
  
  virtual void GetLocalTimeStamps(std::vector<albaTimeStamp> &kframes)=0;
 
  virtual void GetLocalTimeBounds(albaTimeStamp tbounds[2]) {tbounds[0] = m_CurrentTime; tbounds[1] = m_CurrentTime;};
  
   virtual void GetAbsTimeStamps(std::vector<albaTimeStamp> &kframes);
  
  virtual void GetTimeStamps(std::vector<albaTimeStamp> &kframes);  
  
  int GetNumberOfTimeStamps();
  
  int GetNumberOfLocalTimeStamps();
  
  virtual bool IsAnimated();
 
  virtual bool IsDataAvailable();
  
  void SetCrypting(int crypting);
  
  int GetCrypting();
 
  virtual albaVMEOutput *GetOutput() {return m_Output;}
 
   virtual albaString GetVisualPipe() { return albaString(""); };
 
   virtual albaString GetVisualPipeSlice() { return albaString(""); };
 
  void SetVisualMode(int mode);
 
  int GetVisualMode() {return m_VisualMode;};
 
  albaInteractor *GetBehavior() {return m_Behavior;}
 
  void SetBehavior(albaInteractor *bh) {m_Behavior=bh;};
  
  void TestModeOn() {m_TestMode = true;};
 
  void TestModeOff() {m_TestMode = false;};
 
  bool GetTestMode(){return m_TestMode;};
 
 
   bool WasVMEExpandedWhenStored() const { return m_VMEExpandedWhenStored; }
 
protected:
  albaVME(); // to be allocated with New()
   virtual ~albaVME(); // to be deleted with Delete()
 
 
   void SetId(albaID id);
 
   virtual int InternalStore(albaStorageElement *parent);
   virtual int InternalRestore(albaStorageElement *node);
      
   
   virtual void InternalShutdown() {};
 
   virtual int SetParent(albaVME *parent);
 
   void OnNodeDetachedFromTree(albaEventBase *e);
   void OnNodeAttachedToTree(albaEventBase *e);
   void OnNodeDestroyed(albaEventBase *e);
 
   void GetDependenciesVMEs(albaVMESet &dependencies,albaVME *vme);
 
  virtual int InternalInitialize();
 
  virtual void InternalPreUpdate() {}
 
  virtual void InternalUpdate() {}
 
   virtual void InternalSetTimeStamp(albaTimeStamp t);
 
   // Make a Copy of Subtree and Update new Links (Recursive Function)
   static albaVME* InternalCopyTree(albaVME * vme, albaVME * parent);
 
  void SetOutput(albaVMEOutput *output);
  
  virtual int SetDataPipe(albaDataPipe *dpipe);
 
  int SetMatrixPipe(albaMatrixPipe *pipe);
 
   albaString GetTypeNameFromType(albaString typeName);
 
  void SetAbsMatrixPipe(albaAbsMatrixPipe *pipe);
 
   virtual albaGUI  *CreateGui();
 
   void NodeOnEvent(albaEventBase *e);
 
 
   albaGUI            *m_Gui;         
 
   albaChildrenVector m_Children;     
   albaVME           *m_Parent;      
 
   albaAttributesMap  m_Attributes;   
 
   albaLinksMap       m_Links;               
   albaVMEBackLinks m_BackLinks;      
   std::vector<albaOldSubIdLink> m_OldSubIdLinks;
 
   albaString         m_Name;         
   albaString         m_GuiName;      
   albaID             m_Id;           
 
   bool m_VisibleToTraverse;         
   bool m_Initialized;               
   bool m_DependsOnLinkedNode;       
   bool m_TestMode; 
 
  albaAutoPointer<albaDataPipe>       m_DataPipe;
  albaAutoPointer<albaMatrixPipe>     m_MatrixPipe;
  albaAutoPointer<albaAbsMatrixPipe>  m_AbsMatrixPipe;
 
  albaVMEOutput*   m_Output;       
  albaTimeStamp    m_CurrentTime;  
  int             m_Crypting;     
  
  albaInteractor*  m_Behavior;     
 
  int             m_VisualMode; 
 
   albaID      m_VMEExpandedWhenStored;
  
   typedef struct
   {
      albaVME *oldPointer;
      albaVME *newPointer;
   } VmePointerMap;
 
   typedef struct
   {
      albaString name;
      albaVME *vme;
   } VmeLinks;
 
private:
  albaVME(const albaVME&); // Not implemented
  void operator=(const albaVME&); // Not implemented
 
};
 
#endif