vtkCalibratedModelRenderingPipeline.h

Go to the documentation of this file.

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

  NifTK: A software platform for medical image computing.

  Copyright (c) University College London (UCL). All rights reserved.

  This software is distributed WITHOUT ANY WARRANTY; without even
  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  PURPOSE.

  See LICENSE.txt in the top level directory for details.

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

#ifndef vtkCalibratedModelRenderingPipeline_h
#define vtkCalibratedModelRenderingPipeline_h

#include "niftkIGIExports.h"

#include <cv.h>

#include <mitkVector.h>
#include <mitkPoint.h>

#include <vtkObject.h>
#include <vtkIndent.h>
#include <vtkSmartPointer.h>
#include <vtkOpenGLMatrixDrivenCamera.h>
#include <vtkRenderer.h>
#include <vtkRenderWindow.h>
#include <vtkPNGReader.h>
#include <vtkPolyDataReader.h>
#include <vtkPolyDataWriter.h>
#include <vtkPolyDataMapper.h>
#include <vtkProperty.h>
#include <vtkTransformPolyDataFilter.h>
#include <vtkMatrixToLinearTransform.h>
#include <vtkSphereSource.h>
#include <vtkGlyph3D.h>
#include <vtkWindowToImageFilter.h>
#include <vtkPNGWriter.h>
#include <vtkBMPWriter.h>
#include <vtkSetGet.h>
#include <vtkPlaneSource.h>
#include <vtkTexture.h>
#include <vtkImageFlip.h>

class NIFTKIGI_EXPORT vtkCalibratedModelRenderingPipeline {

public:

  vtkCalibratedModelRenderingPipeline(
    const std::string& name,
    const mitk::Point2I& windowSize,
    const mitk::Point2I& calibratedWindowSize,
    const std::string& leftIntrinsicsFileName,
    const std::string& rightIntrinsicsFileName,
    const std::string& visualisationModelFileName,
    const std::string& rightToLeftFileName,
    const std::string& textureFileName,
    const std::string& trackingModelFileName,
    const std::string& ultrasoundCalibrationMatrixFileName,
    const std::string& ultrasoundImageFileName,
    const float& trackingGlyphRadius
    );

  virtual ~vtkCalibratedModelRenderingPipeline();

  std::string GetName() const { return m_Name; }

  void SetIsRightHandCamera(const bool& isRight);

  bool GetIsRightHandCamera() const { return m_IsRightHandCamera; }

  virtual void Render();

  void DumpScreen(const std::string fileName);

  void SaveModelToWorld(const std::string& fileName);

  void SaveCameraToWorld(const std::string& fileName);

  void SetModelToWorldMatrix(const vtkMatrix4x4& modelToWorld);

  void SetModelToWorldTransform(const std::vector<float>&);

  void SetCameraToWorldMatrix(const vtkMatrix4x4& cameraToWorld);

  void SetCameraToWorldTransform(const std::vector<float>&);

  void SetWorldToCameraMatrix(const vtkMatrix4x4& worldToCamera);

  void SetWorldToCameraTransform(const std::vector<float>&);

  bool IsFacingCamera(const double normal[3]);

  void ProjectPoint(const double world[3], double imagePoint[2]);

  void ProjectToCameraSpace(const double worldPoint[3], double cameraPoint[3]);

  vtkPolyData* GetTrackingModel() const;

  vtkRenderWindow* GetRenderWindow() const;

private:

  vtkCalibratedModelRenderingPipeline(const vtkCalibratedModelRenderingPipeline&);  // Purposefully not implemented.
  void operator=(const vtkCalibratedModelRenderingPipeline&);  // Purposefully not implemented.

  void UpdateCamera();
  void UpdateUltrasoundPlanePosition();
  vtkSmartPointer<vtkMatrix4x4> GetTransform(const std::vector<float> &transform);

  std::string                                  m_Name;

  bool                                         m_UseDistortion;
  bool                                         m_IsRightHandCamera;
  cv::Mat                                      m_LeftIntrinsicMatrix;
  cv::Mat                                      m_LeftDistortionVector;
  cv::Mat                                      m_RightIntrinsicMatrix;
  cv::Mat                                      m_RightDistortionVector;

  vtkSmartPointer<vtkOpenGLMatrixDrivenCamera> m_Camera;
  vtkSmartPointer<vtkMatrix4x4>                m_RightToLeftMatrix;

  vtkSmartPointer<vtkMatrix4x4>                m_ModelToWorldMatrix;
  vtkSmartPointer<vtkMatrixToLinearTransform>  m_ModelToWorldTransform;
  vtkSmartPointer<vtkMatrix4x4>                m_CameraToWorldMatrix;
  vtkSmartPointer<vtkMatrix4x4>                m_CameraMatrix; // combines m_CameraToWorldMatrix and m_RightToLeftMatrix if necessary.
  vtkSmartPointer<vtkMatrix4x4>                m_CameraMatrixInverted;

  vtkSmartPointer<vtkPolyDataReader>           m_TrackingModelReader;
  vtkSmartPointer<vtkSphereSource>             m_SphereForGlyph;
  vtkSmartPointer<vtkGlyph3D>                  m_GlyphFilter;
  vtkSmartPointer<vtkTransformPolyDataFilter>  m_TrackingModelTransformFilter;
  vtkSmartPointer<vtkPolyDataMapper>           m_TrackingModelMapper;
  vtkSmartPointer<vtkActor>                    m_TrackingModelActor;
  vtkSmartPointer<vtkPolyDataWriter>           m_TrackingModelWriter;

  vtkSmartPointer<vtkPNGReader>                m_TextureReader;
  vtkSmartPointer<vtkTexture>                  m_Texture;
  vtkSmartPointer<vtkPolyDataReader>           m_VisualisationModelReader;
  vtkSmartPointer<vtkTransformPolyDataFilter>  m_VisualisationModelTransformFilter;
  vtkSmartPointer<vtkPolyDataMapper>           m_VisualisationModelMapper;
  vtkSmartPointer<vtkActor>                    m_VisualisationModelActor;
  vtkSmartPointer<vtkPolyDataWriter>           m_VisualisationModelWriter;

  vtkSmartPointer<vtkMatrix4x4>                m_UltrasoundCalibrationMatrix;
  vtkSmartPointer<vtkMatrix4x4>                m_UltrasoundTransformMatrix;
  vtkSmartPointer<vtkPNGReader>                m_UltrasoundImageReader;
  vtkSmartPointer<vtkImageFlip>                m_UltrasoundImageYAxisFlipper;
  vtkSmartPointer<vtkPlaneSource>              m_UltrasoundImagePlane;
  vtkSmartPointer<vtkTexture>                  m_UltrasoundImageTexture;
  vtkSmartPointer<vtkPolyDataMapper>           m_UltrasoundImageMapper;
  vtkSmartPointer<vtkActor>                    m_UltrasoundImageActor;

  vtkSmartPointer<vtkRenderer>                 m_Renderer;
  vtkSmartPointer<vtkRenderWindow>             m_RenderWin;
};

#endif