mitkImageMapperGL2D.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 MITKIMAGEMAPPER2D_H_HEADER_INCLUDED_C10E906E
#define MITKIMAGEMAPPER2D_H_HEADER_INCLUDED_C10E906E

#include "mitkCommon.h"
#include "mitkGLMapper2D.h"
#include "mitkBaseRenderer.h"

#include <map>
#include <assert.h>

#include <itkCommand.h>
#include <itkEventObject.h>

#include <vtkSystemIncludes.h>


class iil4mitkPicImage;
class Vtk2itk;
class vtkImageReslice;
class vtkLookupTable;
class vtkGeneralTransform;
class vtkImageChangeInformation;
class vtkPoints;
class vtkMitkThickSlicesFilter;

namespace mitk {



class MITK_CORE_EXPORT ImageMapperGL2D : public GLMapper2D
{

public:
  
  mitkClassMacro( ImageMapperGL2D,GLMapper2D );
  
  itkNewMacro(Self);

  typedef mitk::Image                    InputImageType;
  typedef InputImageType::Pointer        InputImagePointer;
  typedef InputImageType::ConstPointer   InputImageConstPointer;
  typedef SlicedData::RegionType         InputImageRegionType;

  const InputImageType *GetInput(void);

  virtual void GenerateAllData();

  virtual void Paint( mitk::BaseRenderer *renderer );

  virtual void Update(mitk::BaseRenderer * renderer);

  virtual void ApplyProperties(mitk::BaseRenderer* renderer);

  class MITK_CORE_EXPORT RendererInfo
  {
    int m_RendererID;

    iil4mitkPicImage* m_iil4mitkImage;
    mitk::BaseRenderer* m_Renderer;

  public:
    itk::TimeStamp m_LastUpdateTime;

    mitkIpPicDescriptor *m_Pic;

    Vector2D m_PixelsPerMM;

    Vector2D m_Extent;

    Vector2D m_Overlap;

    vtkImageChangeInformation *m_UnitSpacingImageFilter;

    vtkImageReslice *m_Reslicer;

    vtkMitkThickSlicesFilter *m_TSFilter;

    vtkImageData *m_Image;

    const Geometry3D *m_ReferenceGeometry;
   
    bool m_TextureInterpolation;

    unsigned long m_ObserverID;

    RendererInfo();

    ~RendererInfo();

    inline bool IsInitialized() const
    {
      return m_RendererID >= 0;
    }

    void Initialize( int rendererID, mitk::BaseRenderer *renderer, 
      unsigned long observerID );

    void Set_iil4mitkImage(iil4mitkPicImage* iil4mitkImage);

    inline iil4mitkPicImage* Get_iil4mitkImage() const
    {
      return m_iil4mitkImage;
    }

    inline int GetRendererID() const
    {
      return m_RendererID;
    }

    void RemoveObserver();

    void Squeeze();
  }; // RendererInfo



  virtual int GetAssociatedChannelNr( mitk::BaseRenderer *renderer );

  const RendererInfo *GetRendererInfo( mitk::BaseRenderer *renderer )
  {
    return &this->AccessRendererInfo(renderer);
  }

  virtual void Clear();

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

protected:
  ImageMapperGL2D();

  virtual ~ImageMapperGL2D();

  virtual void GenerateData(mitk::BaseRenderer *renderer);
  
  inline RendererInfo & AccessRendererInfo( mitk::BaseRenderer* renderer )
  {
    RendererInfo& rendererInfo = m_RendererInfo[renderer];
    if(rendererInfo.IsInitialized()==false)
    {
      // Add observer for renderer reset events (RendererInfo will 
      // automatically be removed from list when a Renderer is deleted)
      //
      // Note: observer ID is passed to rendererInfo, which will take
      // responsiblity to remove the observer upon its destruction
      typedef itk::MemberCommand< ImageMapperGL2D > MemberCommandType;
      MemberCommandType::Pointer deleteRendererCommand = 
        MemberCommandType::New();

      deleteRendererCommand->SetCallbackFunction(
        this, &ImageMapperGL2D::DeleteRendererCallback );
      
      unsigned long observerID = renderer->AddObserver( 
        BaseRenderer::RendererResetEvent(), deleteRendererCommand );

      // Initialize RendererInfo
      rendererInfo.Initialize( ImageMapperGL2D::numRenderer++, renderer, observerID );
    }

    return rendererInfo;
  }

  void DeleteRendererCallback( itk::Object *object, const itk::EventObject & );


  double CalculateSpacing( const mitk::Geometry3D *geometry, 
    const mitk::Vector3D &d ) const;

  bool LineIntersectZero( vtkPoints *points, int p1, int p2, 
    vtkFloatingPointType *bounds );

  bool CalculateClippedPlaneBounds( const Geometry3D *boundingGeometry, 
    const PlaneGeometry *planeGeometry, vtkFloatingPointType *bounds );

  static int numRenderer;

protected:
  typedef std::map<BaseRenderer*,RendererInfo> RendererInfoMap;


  RendererInfoMap m_RendererInfo;

  vtkGeneralTransform *m_ComposedResliceTransform;

private:
  int m_iil4mitkMode;

};

} // namespace mitk

#endif /* MITKIMAGEMAPPER2D_H_HEADER_INCLUDED_C10E906E */