mitk: mitkDataNode.cpp Source File

Go to the documentation of this file.
00001 /*=========================================================================
00002 
00003 Program:   Medical Imaging & Interaction Toolkit
00004 Language:  C++
00005 Date:      $Date$
00006 Version:   $Revision$
00007 
00008 Copyright (c) German Cancer Research Center, Division of Medical and
00009 Biological Informatics. All rights reserved.
00010 See MITKCopyright.txt or https://www.mitk.org/copyright.html for details.
00011 
00012 This software is distributed WITHOUT ANY WARRANTY; without even
00013 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
00014 PURPOSE.  See the above copyright notices for more information.
00015 
00016 =========================================================================*/
00017 
00018 
00019 #include "mitkDataNode.h"
00020 #include "mitkCoreObjectFactory.h"
00021 #include <vtkTransform.h>
00022 #include <itkSmartPointerForwardReference.txx>
00023 
00024 #include "mitkProperties.h"
00025 #include "mitkStringProperty.h"
00026 #include "mitkGroupTagProperty.h"
00027 #include "mitkSmartPointerProperty.h"
00028 //#include "mitkMaterialProperty.h"
00029 #include "mitkColorProperty.h"
00030 #include "mitkLevelWindowProperty.h"
00031 #include "mitkGeometry3D.h"
00032 #include "mitkRenderingManager.h"
00033 #include "mitkGlobalInteraction.h"
00034 #include "mitkEventMapper.h"
00035 #include "mitkGenericProperty.h"
00036 
00037 #include "mitkCoreObjectFactory.h"
00038 
00039 
00040 mitk::Mapper* mitk::DataNode::GetMapper(MapperSlotId id) const
00041 {
00042   if( (id >= m_Mappers.size()) || (m_Mappers[id].IsNull()) ) 
00043   {
00044     if(id >= m_Mappers.capacity())
00045     {
00046 //      int i, size=id-m_Mappers.capacity()+10;
00047       m_Mappers.resize(id+10);
00048     }
00049     m_Mappers[id] = CoreObjectFactory::GetInstance()->CreateMapper(const_cast<DataNode*>(this),id);
00050   }
00051   return m_Mappers[id];
00052 }
00053 
00054 mitk::BaseData* mitk::DataNode::GetData() const
00055 {
00056   return m_Data;
00057 }
00058 
00059 mitk::Interactor* mitk::DataNode::GetInteractor() const
00060 {
00061   return m_Interactor;
00062 }
00063 
00064 void mitk::DataNode::SetData(mitk::BaseData* baseData)
00065 {
00066   if(m_Data!=baseData)
00067   {
00068     m_Data=baseData;
00069 
00070     m_Mappers.clear();
00071     m_Mappers.resize(10);
00072 
00073     mitk::CoreObjectFactory::GetInstance()->SetDefaultProperties(this);
00074 
00075     m_DataReferenceChangedTime.Modified();
00076     Modified();
00077 
00078     //inform the interactor about the change
00079     if (m_Interactor.IsNotNull())
00080       m_Interactor->DataChanged();
00081   }
00082 }
00083 
00084 void mitk::DataNode::SetInteractor(mitk::Interactor* interactor)
00085 {
00086   m_Interactor = interactor;
00087   if(m_Interactor.IsNotNull())
00088   m_Interactor->SetDataNode(this);
00089 }
00090 
00091 mitk::DataNode::DataNode() : m_Data(NULL), m_PropertyListModifiedObserverTag(0)
00092 {
00093   m_Mappers.resize(10);
00094 
00095   m_PropertyList = PropertyList::New();
00096 
00097   // subscribe for modified event
00098   itk::MemberCommand<mitk::DataNode>::Pointer _PropertyListModifiedCommand =
00099     itk::MemberCommand<mitk::DataNode>::New();
00100   _PropertyListModifiedCommand->SetCallbackFunction(this, &mitk::DataNode::PropertyListModified);
00101   m_PropertyListModifiedObserverTag = m_PropertyList->AddObserver(itk::ModifiedEvent(), _PropertyListModifiedCommand);
00102 }
00103 
00104 
00105 mitk::DataNode::~DataNode()
00106 {
00107   if(m_PropertyList.IsNotNull())
00108     // remove modified event listener
00109     m_PropertyList->RemoveObserver(m_PropertyListModifiedObserverTag);
00110 
00111   Interactor* interactor = this->GetInteractor();
00112 
00113   if ( interactor )
00114   {
00115     mitk::GlobalInteraction::GetInstance()->RemoveInteractor( interactor );  
00116   }
00117   m_Mappers.clear();
00118   m_Data = NULL;
00119 }
00120 
00121 mitk::DataNode& mitk::DataNode::operator=(const DataNode& right)
00122 {
00123   mitk::DataNode* node=mitk::DataNode::New();
00124   node->SetData(right.GetData());
00125   return *node;
00126 }
00127 
00128 mitk::DataNode& mitk::DataNode::operator=(mitk::BaseData* right)
00129 {
00130   mitk::DataNode* node=mitk::DataNode::New();
00131   node->SetData(right);
00132   return *node;
00133 }
00134 
00135 #if (_MSC_VER > 1200) || !defined(_MSC_VER)
00136 MBI_STD::istream& mitk::operator>>( MBI_STD::istream& i, mitk::DataNode::Pointer& dtn )
00137 #endif
00138 #if ((defined(_MSC_VER)) && (_MSC_VER <= 1200))
00139 MBI_STD::istream& operator>>( MBI_STD::istream& i, mitk::DataNode::Pointer& dtn ) 
00140 #endif
00141 {
00142   dtn = mitk::DataNode::New();
00143   //i >> av.get();
00144   return i;
00145 }
00146 
00147 #if (_MSC_VER > 1200) || !defined(_MSC_VER)
00148 MBI_STD::ostream& mitk::operator<<( MBI_STD::ostream& o, mitk::DataNode::Pointer& dtn)
00149 #endif
00150 #if ((defined(_MSC_VER)) && (_MSC_VER <= 1200))
00151 MBI_STD::ostream& operator<<( MBI_STD::ostream& o, mitk::DataNode::Pointer& dtn)
00152 #endif
00153 {
00154   if(dtn->GetData()!=NULL)
00155     o<<dtn->GetData()->GetNameOfClass();
00156   else
00157     o<<"empty data";
00158   return o;
00159 }
00160 
00161 void mitk::DataNode::SetMapper(MapperSlotId id, mitk::Mapper* mapper)
00162 {
00163   m_Mappers[id] = mapper;
00164 
00165   if (mapper!=NULL)
00166     mapper->SetDataNode(this);
00167 }
00168 
00169 void mitk::DataNode::UpdateOutputInformation()
00170 {
00171   if (this->GetSource())
00172   {
00173     this->GetSource()->UpdateOutputInformation();
00174   }
00175 }
00176 
00177 void mitk::DataNode::SetRequestedRegionToLargestPossibleRegion()
00178 {
00179 }
00180 
00181 bool mitk::DataNode::RequestedRegionIsOutsideOfTheBufferedRegion()
00182 {
00183   return false;
00184 }
00185 
00186 bool mitk::DataNode::VerifyRequestedRegion()
00187 {
00188     return true;
00189 }
00190 
00191 void mitk::DataNode::SetRequestedRegion(itk::DataObject * /*data*/)
00192 {
00193 }
00194 
00195 void mitk::DataNode::CopyInformation(const itk::DataObject * /*data*/)
00196 {
00197 }
00198 mitk::PropertyList* mitk::DataNode::GetPropertyList(const mitk::BaseRenderer* renderer) const
00199 {
00200   if(renderer==NULL)
00201     return m_PropertyList;
00202 
00203   mitk::PropertyList::Pointer & propertyList = m_MapOfPropertyLists[renderer];
00204 
00205   if(propertyList.IsNull())
00206     propertyList = mitk::PropertyList::New();
00207 
00208   assert(m_MapOfPropertyLists[renderer].IsNotNull());
00209 
00210   return propertyList;
00211 }
00212 
00213 void mitk::DataNode::ConcatenatePropertyList(PropertyList *pList, bool replace)
00214 {
00215   m_PropertyList->ConcatenatePropertyList(pList, replace);
00216 }
00217 
00218 mitk::BaseProperty* mitk::DataNode::GetProperty(const char *propertyKey, const mitk::BaseRenderer* renderer) const
00219 {
00220   if(propertyKey==NULL)
00221     return NULL;
00222 
00223   //renderer specified?
00224   if (renderer)
00225   {
00226     std::map<const mitk::BaseRenderer*,mitk::PropertyList::Pointer>::const_iterator it;
00227     //check for the renderer specific property
00228     it=m_MapOfPropertyLists.find(renderer);
00229     if(it!=m_MapOfPropertyLists.end()) //found
00230     {
00231       mitk::BaseProperty::Pointer property;
00232       property=it->second->GetProperty(propertyKey);
00233       if(property.IsNotNull())//found an enabled property in the render specific list
00234         return property;
00235       else //found a renderer specific list, but not the desired property
00236         return m_PropertyList->GetProperty(propertyKey); //return renderer unspecific property
00237     }
00238     else //didn't find the property list of the given renderer
00239     {
00240       //return the renderer unspecific property if there is one
00241       return m_PropertyList->GetProperty(propertyKey); 
00242     }
00243   }
00244   else //no specific renderer given; use the renderer independent one
00245   {
00246     mitk::BaseProperty::Pointer property;
00247     property=m_PropertyList->GetProperty(propertyKey);
00248     if(property.IsNotNull())
00249       return property;
00250   }
00251   
00252   //only to satisfy compiler!
00253   return NULL;
00254 }
00255   
00256 mitk::DataNode::GroupTagList mitk::DataNode::GetGroupTags() const
00257 {
00258   GroupTagList groups;
00259   const PropertyList::PropertyMap* propertyMap = m_PropertyList->GetMap();
00260 
00261   for ( PropertyList::PropertyMap::const_iterator groupIter = propertyMap->begin(); // m_PropertyList is created in the constructor, so we don't check it here
00262         groupIter != propertyMap->end();
00263         ++groupIter )
00264   {
00265     const BaseProperty* bp = groupIter->second.first;
00266     if ( dynamic_cast<const GroupTagProperty*>(bp) && groupIter->second.second )
00267     {
00268       groups.insert( groupIter->first );
00269     }
00270   }
00271 
00272   return groups;
00273 }
00274 
00275 bool mitk::DataNode::GetBoolProperty(const char* propertyKey, bool& boolValue, mitk::BaseRenderer* renderer) const
00276 {
00277   mitk::BoolProperty::Pointer boolprop = dynamic_cast<mitk::BoolProperty*>(GetProperty(propertyKey, renderer));
00278   if(boolprop.IsNull())
00279     return false;
00280 
00281   boolValue = boolprop->GetValue();
00282   return true;
00283 }
00284 
00285 bool mitk::DataNode::GetIntProperty(const char* propertyKey, int &intValue, mitk::BaseRenderer* renderer) const
00286 {
00287   mitk::IntProperty::Pointer intprop = dynamic_cast<mitk::IntProperty*>(GetProperty(propertyKey, renderer));
00288   if(intprop.IsNull())
00289     return false;
00290 
00291   intValue = intprop->GetValue();
00292   return true;
00293 }
00294 
00295 bool mitk::DataNode::GetFloatProperty(const char* propertyKey, float &floatValue, mitk::BaseRenderer* renderer) const
00296 {
00297   mitk::FloatProperty::Pointer floatprop = dynamic_cast<mitk::FloatProperty*>(GetProperty(propertyKey, renderer));
00298   if(floatprop.IsNull())
00299     return false;
00300 
00301   floatValue = floatprop->GetValue();
00302   return true;
00303 }
00304 
00305 bool mitk::DataNode::GetStringProperty(const char* propertyKey, std::string& string, mitk::BaseRenderer* renderer) const
00306 {
00307   mitk::StringProperty::Pointer stringProp = dynamic_cast<mitk::StringProperty*>(GetProperty(propertyKey, renderer));
00308   if(stringProp.IsNull())
00309   {
00310     return false;
00311   } 
00312   else 
00313   {
00314     //memcpy((void*)string, stringProp->GetValue(), strlen(stringProp->GetValue()) + 1 ); // looks dangerous
00315     string = stringProp->GetValue();
00316     return true;
00317   }
00318 }
00319 
00320 bool mitk::DataNode::GetColor(float rgb[3], mitk::BaseRenderer* renderer, const char* propertyKey) const
00321 {
00322   mitk::ColorProperty::Pointer colorprop = dynamic_cast<mitk::ColorProperty*>(GetProperty(propertyKey, renderer));
00323   if(colorprop.IsNull())
00324     return false;
00325 
00326   memcpy(rgb, colorprop->GetColor().GetDataPointer(), 3*sizeof(float));
00327   return true;
00328 }
00329 
00330 bool mitk::DataNode::GetOpacity(float &opacity, mitk::BaseRenderer* renderer, const char* propertyKey) const
00331 {
00332   mitk::FloatProperty::Pointer opacityprop = dynamic_cast<mitk::FloatProperty*>(GetProperty(propertyKey, renderer));
00333   if(opacityprop.IsNull())
00334     return false;
00335 
00336   opacity=opacityprop->GetValue();
00337   return true;
00338 }
00339 
00340 bool mitk::DataNode::GetLevelWindow(mitk::LevelWindow &levelWindow, mitk::BaseRenderer* renderer, const char* propertyKey) const
00341 {
00342   mitk::LevelWindowProperty::Pointer levWinProp = dynamic_cast<mitk::LevelWindowProperty*>(GetProperty(propertyKey, renderer));
00343   if(levWinProp.IsNull())
00344     return false;
00345 
00346   levelWindow=levWinProp->GetLevelWindow();
00347   return true;
00348 }
00349 
00350 void mitk::DataNode::SetColor(const mitk::Color &color, mitk::BaseRenderer* renderer, const char* propertyKey)
00351 {
00352   mitk::ColorProperty::Pointer prop;
00353   prop = mitk::ColorProperty::New(color);
00354   GetPropertyList(renderer)->SetProperty(propertyKey, prop);
00355 }
00356 
00357 void mitk::DataNode::SetColor(float red, float green, float blue, mitk::BaseRenderer* renderer, const char* propertyKey)
00358 {
00359   float color[3];
00360   color[0]=red;
00361   color[1]=green;
00362   color[2]=blue;
00363   SetColor(color, renderer, propertyKey);
00364 }
00365 
00366 void mitk::DataNode::SetColor(const float rgb[3], mitk::BaseRenderer* renderer, const char* propertyKey)
00367 {
00368   mitk::ColorProperty::Pointer prop;
00369   prop = mitk::ColorProperty::New(rgb);
00370   GetPropertyList(renderer)->SetProperty(propertyKey, prop);
00371 }
00372 
00373 void mitk::DataNode::SetVisibility(bool visible, mitk::BaseRenderer* renderer, const char* propertyKey)
00374 {
00375   mitk::BoolProperty::Pointer prop;
00376   prop = mitk::BoolProperty::New(visible);
00377   GetPropertyList(renderer)->SetProperty(propertyKey, prop);
00378 }
00379 
00380 void mitk::DataNode::SetOpacity(float opacity, mitk::BaseRenderer* renderer, const char* propertyKey)
00381 {
00382   mitk::FloatProperty::Pointer prop;
00383   prop = mitk::FloatProperty::New(opacity);
00384   GetPropertyList(renderer)->SetProperty(propertyKey, prop);
00385 }
00386 
00387 void mitk::DataNode::SetLevelWindow(mitk::LevelWindow levelWindow, mitk::BaseRenderer* renderer, const char* propertyKey)
00388 {
00389   mitk::LevelWindowProperty::Pointer prop;
00390   prop = mitk::LevelWindowProperty::New(levelWindow);
00391   GetPropertyList(renderer)->SetProperty(propertyKey, prop);
00392 }
00393 
00394 void mitk::DataNode::SetIntProperty(const char* propertyKey, int intValue, mitk::BaseRenderer* renderer)
00395 {
00396   GetPropertyList(renderer)->SetProperty(propertyKey, mitk::IntProperty::New(intValue));
00397 }
00398 void mitk::DataNode::SetBoolProperty( const char* propertyKey, bool boolValue, mitk::BaseRenderer* renderer/*=NULL*/ )
00399 {
00400   GetPropertyList(renderer)->SetProperty(propertyKey, mitk::BoolProperty::New(boolValue));
00401 }
00402 
00403 void mitk::DataNode::SetFloatProperty( const char* propertyKey, float floatValue, mitk::BaseRenderer* renderer/*=NULL*/ )
00404 {
00405   GetPropertyList(renderer)->SetProperty(propertyKey, mitk::FloatProperty::New(floatValue));
00406 }
00407 
00408 void mitk::DataNode::SetStringProperty( const char* propertyKey, const char* stringValue, mitk::BaseRenderer* renderer/*=NULL*/ )
00409 {
00410   GetPropertyList(renderer)->SetProperty(propertyKey, mitk::StringProperty::New(stringValue));
00411 }
00412 
00413 void mitk::DataNode::SetProperty(const char *propertyKey, 
00414                                      BaseProperty* propertyValue, 
00415                                      const mitk::BaseRenderer* renderer)
00416 {
00417   GetPropertyList(renderer)->SetProperty(propertyKey, propertyValue);
00418 }
00419 
00420 void mitk::DataNode::ReplaceProperty(const char *propertyKey, 
00421                                          BaseProperty* propertyValue, 
00422                                          const mitk::BaseRenderer* renderer)
00423 {
00424   GetPropertyList(renderer)->ReplaceProperty(propertyKey, propertyValue);
00425 }
00426 
00427 void mitk::DataNode::AddProperty(const char *propertyKey, 
00428                                      BaseProperty* propertyValue, 
00429                                      const mitk::BaseRenderer* renderer,
00430                                      bool overwrite)
00431 {
00432   if((overwrite) || (GetProperty(propertyKey, renderer) == NULL))
00433   {
00434     SetProperty(propertyKey, propertyValue, renderer);
00435   }
00436 }
00437 
00438 
00439 vtkLinearTransform* mitk::DataNode::GetVtkTransform(int t) const
00440 {
00441   assert(m_Data.IsNotNull());
00442 
00443   mitk::Geometry3D* geometry = m_Data->GetGeometry(t);
00444 
00445   if(geometry == NULL)
00446     return NULL;
00447 
00448   return geometry->GetVtkTransform();
00449 }
00450 
00451 unsigned long mitk::DataNode::GetMTime() const
00452 {
00453   unsigned long time = Superclass::GetMTime();
00454   if(m_Data.IsNotNull())
00455   {
00456     if((time < m_Data->GetMTime()) ||
00457       ((m_Data->GetSource() != NULL) && (time < m_Data->GetSource()->GetMTime()))
00458     )
00459     {
00460       Modified();
00461       return Superclass::GetMTime();
00462     }
00463   }
00464   return time;
00465 }
00466 
00467 void mitk::DataNode::SetSelected(bool selected, mitk::BaseRenderer* renderer)
00468 {
00469   mitk::BoolProperty::Pointer selectedProperty = dynamic_cast<mitk::BoolProperty*>(GetProperty("selected"));
00470 
00471   if ( selectedProperty.IsNull() ) 
00472   {
00473     selectedProperty = mitk::BoolProperty::New();
00474     selectedProperty->SetValue(false);
00475     SetProperty("selected", selectedProperty, renderer);  
00476   }
00477 
00478   if( selectedProperty->GetValue() != selected ) 
00479   {
00480     selectedProperty->SetValue(selected);
00481     itk::ModifiedEvent event;
00482     InvokeEvent( event );
00483   }
00484 }
00485 
00486 /*
00487 class SelectedEvent : public itk::ModifiedEvent
00488 { 
00489 public: 
00490   typedef SelectedEvent Self; 
00491   typedef itk::ModifiedEvent Superclass; 
00492 
00493   SelectedEvent(DataNode* dataNode)
00494     { m_DataNode = dataNode; };
00495   DataNode* GetDataNode() 
00496     { return m_DataNode; };
00497   virtual const char * GetEventName() const 
00498     { return "SelectedEvent"; } 
00499   virtual bool CheckEvent(const ::itk::EventObject* e) const 
00500     { return dynamic_cast<const Self*>(e); } 
00501   virtual ::itk::EventObject* MakeObject() const 
00502     { return new Self(m_DataNode); } 
00503 private: 
00504   DataNode* m_DataNode;
00505   SelectedEvent(const Self& event)
00506     { m_DataNode = event.m_DataNode; }; 
00507   void operator=(const Self& event)
00508   { m_DataNode = event.m_DataNode; }
00509 };
00510 */
00511 
00512 bool mitk::DataNode::IsSelected(mitk::BaseRenderer* renderer)
00513 {
00514   bool selected;
00515 
00516   if ( !GetBoolProperty("selected", selected, renderer) )
00517     return false;
00518 
00519   return selected;
00520 }
00521 
00522 void mitk::DataNode::SetInteractorEnabled( const bool& enabled )
00523 {
00524   if ( m_Interactor.IsNull() )
00525   {
00526     itkWarningMacro("Interactor is NULL. Couldn't enable or disable interaction.");  
00527     return;
00528   }
00529   if ( enabled )
00530     mitk::GlobalInteraction::GetInstance()->AddInteractor( m_Interactor.GetPointer() );
00531   else
00532     mitk::GlobalInteraction::GetInstance()->RemoveInteractor( m_Interactor.GetPointer() );
00533 }
00534 
00535 void mitk::DataNode::EnableInteractor()
00536 {
00537   SetInteractorEnabled( true );
00538 }
00539 
00540 void mitk::DataNode::DisableInteractor()
00541 {
00542   SetInteractorEnabled( false );
00543 }
00544 
00545 bool mitk::DataNode::IsInteractorEnabled() const
00546 {
00547   return mitk::GlobalInteraction::GetInstance()->InteractorRegistered( m_Interactor.GetPointer() );
00548 }
00549 
00550 void mitk::DataNode::PropertyListModified( const itk::Object* /*caller*/, const itk::EventObject& )
00551 {
00552   Modified();
00553 }
00554 
00555 #ifndef _MSC_VER
00556 template <typename T>
00557 bool mitk::DataNode::GetPropertyValue(const char* propertyKey, T & value, mitk::BaseRenderer* renderer) const
00558 {
00559   GenericProperty<T>* gp= dynamic_cast<GenericProperty<T>*>(GetProperty(propertyKey, renderer) );
00560   if ( gp != NULL )
00561   {
00562     value = gp->GetValue();
00563     return true;
00564   }
00565   return false;
00566 }
00567 
00568 template bool mitk::DataNode::GetPropertyValue<double>(char const*, double&, mitk::BaseRenderer*) const;
00569 template bool mitk::DataNode::GetPropertyValue<float>(char const*, float&, mitk::BaseRenderer*) const;
00570 template bool mitk::DataNode::GetPropertyValue<int>(char const*, int&, mitk::BaseRenderer*) const;
00571 template bool mitk::DataNode::GetPropertyValue<bool>(char const*, bool&, mitk::BaseRenderer*) const;
00572 
00573 #endif
00574