#include <mitkImageBackground2D.h>

Collaboration diagram for mitk::ImageBackground2D:

Public Types
typedef ImageBackground2D	Self
typedef itk::Object	Superclass
typedef itk::SmartPointer< Self >	Pointer
typedef itk::SmartPointer < const Self >	ConstPointer
Public Member Functions
virtual const char *	GetClassName () const
vtkRenderWindow *	GetRenderWindow ()
void	SetRenderWindow (vtkRenderWindow *renderWindow)
void	SetImageDimensions (int x, int y, int nrOfScalarComponents)
void	SetParallelScale (int scale)
int	GetParallelScale ()
void	Update (char *dataPointer)
void	Update (char *dataPointer, int width, int height, int imageScalarComponents)
void	Enable ()
void	Disable ()
bool	IsEnabled ()
Static Public Member Functions
static Pointer	New ()
Protected Member Functions
	ImageBackground2D ()
	~ImageBackground2D ()
void	InitVtkImageImport ()
Protected Attributes
vtkRenderWindow *	m_RenderWindow
vtkRenderer *	m_ImageRenderer
vtkImageActor *	m_Actor
vtkImageImport *	m_VtkImageImport
vtkVideoSizeCallback *	m_SizeCallback
unsigned char *	m_ImageData
int	m_ImageWidth
int	m_ImageHeight
int	m_ImageScalarComponents
int	m_ParallelScale

Detailed Description

Displays a 2D image (currently unsigned char) in the background of a vtkRenderWindow. Caution: As the data is not being copied, a user is responsible for a valid pointer to the image. Also the image dimensions needs to be set correctly before enabling the background.

Definition at line 44 of file mitkImageBackground2D.h.

Member Typedef Documentation

typedef itk::SmartPointer<const Self> mitk::ImageBackground2D::ConstPointer

Definition at line 47 of file mitkImageBackground2D.h.

typedef itk::SmartPointer<Self> mitk::ImageBackground2D::Pointer

Definition at line 47 of file mitkImageBackground2D.h.

typedef ImageBackground2D mitk::ImageBackground2D::Self

Definition at line 47 of file mitkImageBackground2D.h.

typedef itk::Object mitk::ImageBackground2D::Superclass

Definition at line 47 of file mitkImageBackground2D.h.

Constructor & Destructor Documentation

mitk::ImageBackground2D::ImageBackground2D ( ) [protected]

Definition at line 60 of file mitkImageBackground2D.cpp.

References m_Actor, m_ImageData, m_ImageHeight, m_ImageRenderer, m_ImageScalarComponents, m_ImageWidth, m_ParallelScale, m_RenderWindow, m_VtkImageImport, and New().

{
  m_ImageWidth              = 0;
  m_ImageHeight             = 0;
  m_ImageScalarComponents   = 3;
  m_ParallelScale           = 0;
  m_RenderWindow = NULL;
  
  m_Actor             = vtkImageActor::New();
  m_ImageRenderer     = vtkRenderer::New();
  m_VtkImageImport    = vtkImageImport::New();
  
  m_ImageData         = NULL;
}

mitk::ImageBackground2D::~ImageBackground2D ( ) [protected]

Definition at line 85 of file mitkImageBackground2D.cpp.

{
  if ( m_RenderWindow != NULL )
    if ( this->IsEnabled() )
      this->Disable();
  if ( m_Actor!=NULL )
    m_Actor->Delete();
  if ( m_ImageRenderer != NULL )
    m_ImageRenderer->Delete();
  if ( m_VtkImageImport != NULL)
    m_VtkImageImport->Delete();
}

Member Function Documentation

void mitk::ImageBackground2D::Disable ( )

Disables drawing of the color Video background. If you want to enable it, call the Enable() function.

Definition at line 151 of file mitkImageBackground2D.cpp.

References mitk::VtkLayerController::GetInstance(), and mitk::VtkLayerController::RemoveRenderer().

{
  if ( this->IsEnabled() )
    mitk::VtkLayerController::GetInstance(m_RenderWindow)->RemoveRenderer(m_ImageRenderer);        
}

void mitk::ImageBackground2D::Enable ( )

Enables drawing of the color Video background. If you want to disable it, call the Disable() function.

Definition at line 125 of file mitkImageBackground2D.cpp.

References mitk::VtkLayerController::GetInstance(), and mitk::VtkLayerController::InsertBackgroundRenderer().

{
  m_ImageRenderer = vtkRenderer::New();

  mitk::VtkLayerController::GetInstance(m_RenderWindow)->InsertBackgroundRenderer(m_ImageRenderer,true);
     
  char * c = 0;
  Update(c);
  m_Actor->SetInput(m_VtkImageImport->GetOutput());
 
  m_ImageRenderer->AddActor2D(m_Actor);
  m_ImageRenderer->ResetCamera();
  m_ImageRenderer->InteractiveOff();
  m_ImageRenderer->GetActiveCamera()->ParallelProjectionOn();
  if(m_ParallelScale == 0)
    m_ImageRenderer->GetActiveCamera()->SetParallelScale(m_ImageHeight/2);
 
  //m_SizeCallback->SetVtkVideoRenderer(m_ImageRenderer);
  //m_SizeCallback->SetVideoDimensions(m_ImageWidth, m_ImageHeight);
   
}

virtual const char* mitk::ImageBackground2D::GetClassName ( ) const [virtual]

int mitk::ImageBackground2D::GetParallelScale ( )

Definition at line 116 of file mitkImageBackground2D.cpp.

{
  // TODO someone who knows this, check if double->int could cause problems
  return static_cast<int>(m_ImageRenderer->GetActiveCamera()->GetParallelScale());
}

vtkRenderWindow* mitk::ImageBackground2D::GetRenderWindow ( )

void mitk::ImageBackground2D::InitVtkImageImport ( ) [protected]

Definition at line 75 of file mitkImageBackground2D.cpp.

{ 
  /*m_VtkImageImport->Delete();
  m_VtkImageImport  = vtkImageImport::New();*/
  m_VtkImageImport->SetDataScalarTypeToUnsignedChar();
  m_VtkImageImport->SetNumberOfScalarComponents(m_ImageScalarComponents);
  m_VtkImageImport->SetWholeExtent(0,m_ImageWidth-1,0,m_ImageHeight-1,0,1-1);
  m_VtkImageImport->SetDataExtentToWholeExtent();  
}

bool mitk::ImageBackground2D::IsEnabled ( )

Checks, if the Video background is currently enabled (visible)

Definition at line 160 of file mitkImageBackground2D.cpp.

References mitk::VtkLayerController::GetInstance().

{
  if ( mitk::VtkLayerController::GetInstance(m_RenderWindow)->IsRendererInserted(m_ImageRenderer)) 
      return true;
  else
      return false;    
}

static Pointer mitk::ImageBackground2D::New ( ) [static]

Referenced by ImageBackground2D().

void mitk::ImageBackground2D::SetImageDimensions	(	int	x,
		int	y,
		int	nrOfScalarComponents
	)		`[inline]`

Definition at line 60 of file mitkImageBackground2D.h.

    {
      m_ImageWidth  = x;
      m_ImageHeight = y;
      m_ImageScalarComponents = nrOfScalarComponents;
      InitVtkImageImport();
    }

void mitk::ImageBackground2D::SetParallelScale ( int scale )

Definition at line 111 of file mitkImageBackground2D.cpp.

{
  m_ParallelScale = scale;
  m_ImageRenderer->GetActiveCamera()->SetParallelScale(m_ParallelScale);
}

void mitk::ImageBackground2D::SetRenderWindow ( vtkRenderWindow * renderWindow )

Sets the renderwindow, in which the Video background will be shown. Make sure, you have called this function before calling Enable()

Definition at line 102 of file mitkImageBackground2D.cpp.

{
  m_RenderWindow = renderWindow;

  /*m_SizeCallback = vtkVideoSizeCallback::New();
  m_RenderWindow->GetVtkRenderWindow()->AddObserver(vtkCommand::ModifiedEvent,m_SizeCallback);*/
  
}

void mitk::ImageBackground2D::Update	(	char *	dataPointer,
		int	width,
		int	height,
		int	imageScalarComponents
	)

Definition at line 191 of file mitkImageBackground2D.cpp.

{
  // no image-backround layer is rendered
  if(!IsEnabled())
    return;

  // image contains no data, OR image scalar components missmatch (no RGB, no greyscale)
  if(!dataPointer || (imageScalarComponents != 1 && imageScalarComponents != 3))
  {
    // no valid image pointer provided -> we initialize black image
    if(m_ImageData == NULL)
      m_ImageData = new unsigned char[m_ImageHeight*m_ImageWidth*m_ImageScalarComponents];
    
    unsigned char* b = m_ImageData;
    for ( int textCounter = 0; textCounter < (m_ImageHeight*m_ImageWidth*m_ImageScalarComponents); textCounter++ )
      *b++ = 0;
  }
  else
  {
    if(m_ImageWidth == 0)
    { // VTK Image Import has to be initialized properly
      m_ImageHeight = height;
      m_ImageWidth  = width;
      m_ImageScalarComponents = imageScalarComponents;
      InitVtkImageImport();
    }
    

    // VTK import image data must be allocated before import (with correct parameters)
    if(m_ImageData == NULL)
      m_ImageData = new unsigned char[m_ImageHeight*m_ImageWidth*m_ImageScalarComponents];
    
    int column, row;
    unsigned char* tex  = m_ImageData;
    char*          data = dataPointer;

    // PREPARE image Data for VTKImageImport Filter //
    
     
    if(imageScalarComponents == 1)
    {
      m_VtkImageImport->SetNumberOfScalarComponents(m_ImageScalarComponents);

      unsigned char g;
      for (column = 0; column < m_ImageHeight; column++)
        for (row = 0; row < m_ImageWidth; row++)
        {
              g   = *data++;
              *tex++  = g;
        }      
    }
    else if(imageScalarComponents == 3)
    {
      // flip image, change color channels
      unsigned char r, g, b;
      for (column = 0; column < m_ImageHeight; column++)
        for (row = 0; row < m_ImageWidth; row++)
        {   //change r with b
            b = *data++;
            g = *data++;
            r = *data++;
            *tex++ = r;
            *tex++ = g;
            *tex++ = b;
          }        
    } // else if(imageScalarComponents == 3)
    
  } // end else image data present


  // Initialize VTK-ImageImport Filter //
  m_VtkImageImport->SetImportVoidPointer(m_ImageData);
  m_VtkImageImport->Modified();
  m_VtkImageImport->Update();
  m_RenderWindow->Render();
   
}

void mitk::ImageBackground2D::Update ( char * dataPointer )

Definition at line 168 of file mitkImageBackground2D.cpp.

{
  if(!IsEnabled())
    return;

  // VTK import image data must be allocated before import (with correct parameters)
  if(m_ImageData == NULL)
    m_ImageData = new unsigned char[m_ImageHeight*m_ImageWidth*m_ImageScalarComponents];

  if(!dataPointer)
  {// no valid image pointer provided -> initialize black image
    unsigned char* b = m_ImageData;
    for ( int textCounter = 0; textCounter < (m_ImageHeight*m_ImageWidth*m_ImageScalarComponents); textCounter++ )
      *b++ = 0;
  }
  
  m_VtkImageImport->SetImportVoidPointer(m_ImageData);
  m_VtkImageImport->Modified();
  m_VtkImageImport->Update();
  m_RenderWindow->Render();
   
}