itkVTKImageExportBase.cxx

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkVTKImageExportBase.cxx,v $
  Language:  C++
  Date:      $Date: 2008-10-09 15:31:37 $
  Version:   $Revision: 1.12 $

  Copyright (c) Insight Software Consortium. All rights reserved.
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm 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.

=========================================================================*/
#include "itkVTKImageExportBase.h"
#include "itkCommand.h"

namespace itk
{

VTKImageExportBase::VTKImageExportBase()
{
  m_LastPipelineMTime = 0;
}

void VTKImageExportBase::PrintSelf(std::ostream& os, Indent indent) const
{
  Superclass::PrintSelf(os,indent);
  
  os << indent << "Last Pipeline MTime: "
     << m_LastPipelineMTime<< std::endl;  
}

//----------------------------------------------------------------------------
void* VTKImageExportBase::GetCallbackUserData()
{
  return this;
}

VTKImageExportBase::UpdateInformationCallbackType
VTKImageExportBase::GetUpdateInformationCallback() const
{
  return &VTKImageExportBase::UpdateInformationCallbackFunction;
}

VTKImageExportBase::PipelineModifiedCallbackType
VTKImageExportBase::GetPipelineModifiedCallback() const
{
  return &VTKImageExportBase::PipelineModifiedCallbackFunction;
}

VTKImageExportBase::WholeExtentCallbackType
VTKImageExportBase::GetWholeExtentCallback() const
{
  return &VTKImageExportBase::WholeExtentCallbackFunction;
}

VTKImageExportBase::CallbackTypeProxy
VTKImageExportBase::GetOriginCallback() const
{
  return CallbackTypeProxy(&VTKImageExportBase::OriginCallbackFunction,
                           &VTKImageExportBase::FloatOriginCallbackFunction);
}

VTKImageExportBase::CallbackTypeProxy
VTKImageExportBase::GetSpacingCallback() const
{
  return CallbackTypeProxy(&VTKImageExportBase::SpacingCallbackFunction,
                           &VTKImageExportBase::FloatSpacingCallbackFunction);
}

VTKImageExportBase::ScalarTypeCallbackType
VTKImageExportBase::GetScalarTypeCallback() const
{
  return &VTKImageExportBase::ScalarTypeCallbackFunction;
}

VTKImageExportBase::NumberOfComponentsCallbackType
VTKImageExportBase::GetNumberOfComponentsCallback() const
{
  return &VTKImageExportBase::NumberOfComponentsCallbackFunction;
}

VTKImageExportBase::PropagateUpdateExtentCallbackType
VTKImageExportBase::GetPropagateUpdateExtentCallback() const
{
  return &VTKImageExportBase::PropagateUpdateExtentCallbackFunction;
}

VTKImageExportBase::UpdateDataCallbackType
VTKImageExportBase::GetUpdateDataCallback() const
{
  return &VTKImageExportBase::UpdateDataCallbackFunction;
}

VTKImageExportBase::DataExtentCallbackType
VTKImageExportBase::GetDataExtentCallback() const
{
  return &VTKImageExportBase::DataExtentCallbackFunction;
}

VTKImageExportBase::BufferPointerCallbackType
VTKImageExportBase::GetBufferPointerCallback() const
{
  return &VTKImageExportBase::BufferPointerCallbackFunction;
}


//----------------------------------------------------------------------------

void VTKImageExportBase::UpdateInformationCallback()
{
  this->UpdateOutputInformation();
}


int VTKImageExportBase::PipelineModifiedCallback()
{
  DataObjectPointer input = this->GetInput(0);
  if( !input )
    {
    itkExceptionMacro(<< "Need to set an input");
    return -1;
    }

  unsigned long pipelineMTime = input->GetPipelineMTime();

  if( this->GetMTime() > pipelineMTime)
    {
    pipelineMTime = this->GetMTime();
    }

  if(pipelineMTime > m_LastPipelineMTime)
    {
    m_LastPipelineMTime = pipelineMTime;
    return 1;
    }
  else
    {
    return 0;
    }
}


void VTKImageExportBase::UpdateDataCallback()
{
  // Get the input.
  DataObjectPointer input = this->GetInput(0);
  if( !input )
    {
    itkExceptionMacro(<< "Need to set an input");
    return;
    }
 
  // Notify start event observers
  this->InvokeEvent( StartEvent() );

  // Make sure input is up to date.
  input->Update();
  
  // Notify end event observers
  this->InvokeEvent( EndEvent() );
}

//----------------------------------------------------------------------------
void VTKImageExportBase::UpdateInformationCallbackFunction(void* userData)
{
  static_cast<VTKImageExportBase*>
    (userData)->UpdateInformationCallback();
}

int VTKImageExportBase::PipelineModifiedCallbackFunction(void* userData)
{
  return static_cast<VTKImageExportBase*>
    (userData)->PipelineModifiedCallback();
}

int* VTKImageExportBase::WholeExtentCallbackFunction(void* userData)
{
  return static_cast<VTKImageExportBase*>
    (userData)->WholeExtentCallback();
}

double* VTKImageExportBase::OriginCallbackFunction(void* userData)
{
  return static_cast<VTKImageExportBase*>
    (userData)->OriginCallback();
}

float* VTKImageExportBase::FloatOriginCallbackFunction(void* userData)
{
  return static_cast<VTKImageExportBase*>
    (userData)->FloatOriginCallback();
}

double* VTKImageExportBase::SpacingCallbackFunction(void* userData)
{
  return static_cast<VTKImageExportBase*>
    (userData)->SpacingCallback();
}

float* VTKImageExportBase::FloatSpacingCallbackFunction(void* userData)
{
  return static_cast<VTKImageExportBase*>
    (userData)->FloatSpacingCallback();
}

const char* VTKImageExportBase::ScalarTypeCallbackFunction(void* userData)
{
  return static_cast<VTKImageExportBase*>
    (userData)->ScalarTypeCallback();
}
 
int VTKImageExportBase::NumberOfComponentsCallbackFunction(void* userData)
{
  return static_cast<VTKImageExportBase*>
    (userData)->NumberOfComponentsCallback();
}

void VTKImageExportBase::PropagateUpdateExtentCallbackFunction(void* userData,
                                                               int* extent)
{
  static_cast<VTKImageExportBase*>
    (userData)->PropagateUpdateExtentCallback(extent);
}

int* VTKImageExportBase::DataExtentCallbackFunction(void* userData)
{
  return static_cast<VTKImageExportBase*>
    (userData)->DataExtentCallback();
}

void* VTKImageExportBase::BufferPointerCallbackFunction(void* userData)
{
  return static_cast<VTKImageExportBase*>
    (userData)->BufferPointerCallback();
}

void VTKImageExportBase::UpdateDataCallbackFunction(void* userData)
{
  static_cast<VTKImageExportBase*>(userData)->UpdateDataCallback();
}


} // end namespace itk