mitkMapper.h

Go to the documentation of this file.

/*=========================================================================

Program:   Medical Imaging & Interaction Toolkit
Language:  C++
Date:      $Date$
Version:   $Revision$

Copyright (c) German Cancer Research Center, Division of Medical and
Biological Informatics. All rights reserved.
See MITKCopyright.txt or https://www.mitk.org/copyright.html for details.

This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE.  See the above copyright notices for more information.

=========================================================================*/


#ifndef MAPPER_H_HEADER_INCLUDED_C1E6EA08
#define MAPPER_H_HEADER_INCLUDED_C1E6EA08

#include "mitkCommon.h"
#include "mitkBaseRenderer.h"
#include "mitkLevelWindow.h"

#include <itkObject.h>
#include <itkWeakPointer.h>

//Just included to get VTK version
#include <vtkConfigure.h>

class vtkWindow;
class vtkProp;

namespace mitk {

  class BaseRenderer;
  class BaseData;
  class DataNode;
  

  class BaseLocalStorageHandler
  {
    public:
      virtual ~BaseLocalStorageHandler() {}
      virtual void ClearLocalStorage(mitk::BaseRenderer *renderer,bool unregisterFromBaseRenderer=true )=0;
  };


  //##Documentation
  //## @brief Base class of all mappers, 2D as well as 3D
  //##
  //## Base class of all Mappers, 2D as well as 3D. 
  //## Subclasses of mitk::Mapper control the creation of rendering primitives
  //## that interface to the graphics library (e.g., OpenGL, vtk). 
  //## @todo Should Mapper be a subclass of ImageSource?
  //## @ingroup Mapper
  class MITK_CORE_EXPORT Mapper : public itk::Object
  {
  public:

    mitkClassMacro(Mapper, itk::Object);

    //##Documentation
    //## @brief Set the DataNode containing the data to map
    itkSetObjectMacro(DataNode, DataNode);

    //##Documentation
    //## @brief Get the data to map
    //## 
    //## Returns the mitk::BaseData object associated with this mapper.
    //## @returns the mitk::BaseData associated with this mapper.
    BaseData* GetData() const;

    //##Documentation
    //## @brief Get the DataNode containing the data to map
    virtual DataNode* GetDataNode() const;

    //##Documentation
    //## @brief Convenience access method for color properties (instances of
    //## ColorProperty)
    //## @return @a true property was found
    virtual bool GetColor(float rgb[3], BaseRenderer* renderer, const char* name = "color") const;

    //##Documentation
    //## @brief Convenience access method for visibility properties (instances
    //## of BoolProperty)
    //## @return @a true property was found
    //## @sa IsVisible
    virtual bool GetVisibility(bool &visible, BaseRenderer* renderer, const char* name = "visible") const;

    //##Documentation
    //## @brief Convenience access method for opacity properties (instances of
    //## FloatProperty)
    //## @return @a true property was found
    virtual bool GetOpacity(float &opacity, BaseRenderer* renderer, const char* name = "opacity") const;

    //##Documentation
    //## @brief Convenience access method for color properties (instances of
    //## LevelWindoProperty)
    //## @return @a true property was found
    virtual bool GetLevelWindow(LevelWindow &levelWindow, BaseRenderer* renderer, const char* name = "levelwindow") const;

    //##Documentation
    //## @brief Convenience access method for visibility properties (instances
    //## of BoolProperty). Return value is the visibility. Default is
    //## visible==true, i.e., true is returned even if the property (@a
    //## propertyKey) is not found.
    //## 
    //## Thus, the return value has a different meaning than in the
    //## GetVisibility method!
    //## @sa GetVisibility
    virtual bool IsVisible(BaseRenderer* renderer, const char* name = "visible") const;

    virtual void Update(BaseRenderer* renderer);

    virtual void MitkRenderOverlay(BaseRenderer* renderer) = 0;
    virtual void MitkRenderOpaqueGeometry(BaseRenderer* renderer) = 0;
    virtual void MitkRenderTranslucentGeometry(BaseRenderer* renderer) = 0;
    
    #if ( ( VTK_MAJOR_VERSION >= 5 ) && ( VTK_MINOR_VERSION>=2)  )
      virtual void MitkRenderVolumetricGeometry(BaseRenderer* renderer) = 0;
    #endif

    bool IsVtkBased() const
    {
      return m_VtkBased;
    }

    virtual bool HasVtkProp( const vtkProp* /*prop*/, BaseRenderer* /*renderer*/ )
    { 
      return false; 
    }

    virtual void ReleaseGraphicsResources(vtkWindow*) { };

    static void SetDefaultProperties(DataNode* node, BaseRenderer* renderer = NULL, bool overwrite = false);

    int GetTimestep() const {return m_TimeStep;}; 

    
    virtual bool IsLODEnabled( BaseRenderer * /*renderer*/ ) const { return false; }

  protected:

    Mapper();

    virtual ~Mapper();

    //##Documentation
    //## @brief Generate the data needed for rendering (independent of a specific renderer)
    virtual void GenerateData();
    //##Documentation
    //## @brief Generate the data needed for rendering into @a renderer
    virtual void GenerateData(BaseRenderer* renderer);

    //## Updates the time step, which is sometimes needed in subclasses
    virtual void CalculateTimeStep( BaseRenderer* renderer );
    
    //## Reset the mapper (i.e., make sure that nothing is displayed) if no
    //## valid data is present.
    //##
    //## To be implemented in sub-classes.
    virtual void ResetMapper( BaseRenderer* /*renderer*/ ) { };


    bool m_VtkBased;

    itk::WeakPointer<DataNode> m_DataNode;

    //##Documentation
    //## @brief timestamp of last update of stored data
    itk::TimeStamp m_LastUpdateTime;

  private:


    //## The current time step of the dataset to be rendered, for use in subclasses
    //## The momentary timestep can be accessed via the GetTimestep() method.
    int m_TimeStep;


  public:

    class BaseLocalStorage
    {
    };

     
    template<class L> class LocalStorageHandler : public mitk::BaseLocalStorageHandler
    {
      protected:
    
        std::map<mitk::BaseRenderer *,L*> m_BaseRenderer2LS;
      
      public:

        virtual void ClearLocalStorage(mitk::BaseRenderer *renderer,bool unregisterFromBaseRenderer=true )
        {
          //MITK_INFO << "deleting a localstorage on a mapper request";
          if(unregisterFromBaseRenderer)
            renderer->UnregisterLocalStorageHandler( this );
          L *l = m_BaseRenderer2LS[renderer];
          m_BaseRenderer2LS.erase( renderer );
          delete l;
        }
      
        L *GetLocalStorage(mitk::BaseRenderer *forRenderer)
        {
          L *l = m_BaseRenderer2LS[ forRenderer ];
          if(!l)
          {
            //MITK_INFO << "creating new localstorage";
            l = new L;
            m_BaseRenderer2LS[ forRenderer ] = l;
            forRenderer->RegisterLocalStorageHandler( this );
          }
          return l;
        }
        
        ~LocalStorageHandler()
        {
          typename std::map<mitk::BaseRenderer *,L*>::iterator it;

          for ( it=m_BaseRenderer2LS.begin() ; it != m_BaseRenderer2LS.end(); it++ )
          {
            (*it).first->UnregisterLocalStorageHandler(this);
            delete (*it).second;
          }
          
          m_BaseRenderer2LS.clear();
        }
             
    };




  };

} // namespace mitk

#endif /* MAPPER_H_HEADER_INCLUDED_C1E6EA08 */