itkProcessObject.cxx

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkProcessObject.cxx,v $
  Language:  C++
  Date:      $Date: 2009-03-03 15:08:01 $
  Version:   $Revision: 1.75 $

  Copyright (c) Insight Software Consortium. All rights reserved.
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.

  Portions of this code are covered under the VTK copyright.
  See VTKCopyright.txt or http://www.kitware.com/VTKCopyright.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 "itkProcessObject.h"
#include "itkDataObject.h"
#include "itkObjectFactory.h"
#include "itkCommand.h"

#include <functional>
#include <algorithm>

namespace itk
{

ProcessObject
::ProcessObject()
{
  m_NumberOfRequiredInputs = 0;

  m_NumberOfRequiredOutputs = 0;

  m_AbortGenerateData = false;
  m_Progress = 0.0f;
  m_Updating = false;
  
  m_Threader = MultiThreader::New();
  m_NumberOfThreads = m_Threader->GetNumberOfThreads();

  m_ReleaseDataBeforeUpdateFlag = true;
}

DataObject::Pointer
ProcessObject
::MakeOutput(unsigned int)
{
  return static_cast<DataObject*>(DataObject::New().GetPointer());
}
  
ProcessObject
::~ProcessObject()
{
  // Tell each output that we are going away.  If other objects have a 
  // reference to one of these outputs, the data object will not be deleted
  // when the process object is deleted.  However, the data object's source
  // will still point back to the now nonexistent process object if we do not
  // clean things up now.
  unsigned int idx;
  for (idx = 0; idx < m_Outputs.size(); ++idx)
    {
    if (m_Outputs[idx])
      {
      // let the output know we no longer want to associate with the object
      m_Outputs[idx]->DisconnectSource(this, idx);
      // let go of our reference to the data object
      m_Outputs[idx] = 0;
      }
    }
}

//typedef DataObject *DataObjectPointer;

void 
ProcessObject
::SetNumberOfInputs(unsigned int num)
{
  // in case nothing has changed.
  if (num == m_Inputs.size())
    {
    return;
    }
  m_Inputs.resize(num);
  this->Modified();
}

ProcessObject::DataObjectPointerArraySizeType
ProcessObject
::GetNumberOfValidRequiredInputs() const
{
  DataObjectPointerArraySizeType num;
  if (m_NumberOfRequiredInputs < m_Inputs.size())
    {
    num = m_NumberOfRequiredInputs;
    }
  else
    {
    num = m_Inputs.size();
    }
  // count the number of non-null inputs
  // this used to use std::count_if, but that function object
  // did not work correctly with SunPro CC 5.6.
  int count = 0;
  for(std::vector<DataObjectPointer>::const_iterator i = m_Inputs.begin();
      i < (m_Inputs.begin() + num); ++i)
    {
    if((*i).IsNotNull())
      {
      count++;
      }
    }
  return count;
}
 
void 
ProcessObject
::AddInput(DataObject *input)
{
  DataObjectPointerArraySizeType idx;
  
  this->Modified();
  
  for (idx = 0; idx < m_Inputs.size(); ++idx)
    {
    if (!m_Inputs[idx])
      {
      m_Inputs[idx] = input;
      return;
      }
    }
  
  this->SetNumberOfInputs( static_cast<int>( m_Inputs.size() + 1 ) );
  m_Inputs[ static_cast<int>( m_Inputs.size() ) - 1] = input;
}


void 
ProcessObject
::RemoveInput(DataObject *input)
{
  if (!input)
    {
    return;
    }
  
  // find the input in the list of inputs
  DataObjectPointerArray::iterator pos = 
    std::find(m_Inputs.begin(), m_Inputs.end(), input);

  if(pos == m_Inputs.end())
    {
    itkDebugMacro("tried to remove an input that was not in the list");
    return;
    }

  // Set the position in the m_Inputs containing input to 0
  *pos = 0;

  // if that was the last input, then shrink the list
  if (pos == m_Inputs.end() - 1 )
    {
    this->SetNumberOfInputs( static_cast<int>( m_Inputs.size() ) - 1);
    }

  this->Modified();
}

void 
ProcessObject
::SetNthInput(unsigned int idx, DataObject *input)
{
  // does this change anything?
  if ( idx < m_Inputs.size() && m_Inputs[idx] == input )
    {
    return;
    }
  
  // Expand array if necessary.
  if (idx >= m_Inputs.size())
    {
    this->SetNumberOfInputs(idx + 1);
    }
  
  m_Inputs[idx] = input;

  this->Modified();
}

void
ProcessObject
::PushBackInput(const DataObject *input)
{
  m_Inputs.push_back(const_cast<DataObject*>(input));
  this->Modified();
}

void
ProcessObject
::PopBackInput()
{
  if (!m_Inputs.empty())
    {
    m_Inputs.pop_back();
    this->Modified();
    }
}

void
ProcessObject
::PushFrontInput(const DataObject* input)
{
  // add an empty element to the end of the vector to make sure that
  // we have enough space for the copy
  m_Inputs.push_back(0);

  // shift the current inputs down by one place
  std::copy_backward(m_Inputs.begin(), m_Inputs.end()-1,
                     m_Inputs.end());

  // put in the new input in the front
  m_Inputs[0] = const_cast<DataObject*>(input);

  this->Modified();
}

void
ProcessObject
::PopFrontInput()
{
  if (!m_Inputs.empty())
    {
    std::copy(m_Inputs.begin()+1, m_Inputs.end(),
              m_Inputs.begin());

    m_Inputs.pop_back();
    this->Modified();
    }
}

void 
ProcessObject
::RemoveOutput(DataObject *output)
{
  if (!output)
    {
    return;
    }
  
  // find the input in the list of inputs
  DataObjectPointerArray::iterator pos = 
    std::find(m_Outputs.begin(), m_Outputs.end(), output);

  if(pos == m_Outputs.end())
    {
    itkDebugMacro("tried to remove an output that was not in the list");
    return;
    }

  // let the output know we no longer want to associate with the object
  (*pos)->DisconnectSource(this, pos - m_Outputs.begin());
  // let go of our reference to the data object
  *pos = 0;

  // if that was the last output, then shrink the list
  if (pos == m_Outputs.end() - 1 )
    {
    this->SetNumberOfOutputs( static_cast<int>( m_Outputs.size() ) - 1);
    }

  this->Modified();
}


void 
ProcessObject
::SetNthOutput(unsigned int idx, DataObject *output)
{
  // does this change anything?
  if ( idx < m_Outputs.size() && output == m_Outputs[idx])
    {
    return;
    }

  // Expand array if necessary.
  if (idx >= m_Outputs.size())
    {
    this->SetNumberOfOutputs(idx + 1);
    }

  // Keep a handle to the original output and disconnect the old output from
  // the pipeline
  DataObjectPointer oldOutput;
  if ( m_Outputs[idx] )
    {
    oldOutput = m_Outputs[idx];
    m_Outputs[idx]->DisconnectSource(this, idx);
    }

  if (output)
    {
    output->ConnectSource(this, idx);
    }
  // save the current reference (which releases the previous reference)
  m_Outputs[idx] = output;

  // if we are clearing an output, we need to create a new blank output
  // so we are prepared for the next Update(). this copies the requested
  // region ivar
  if (!m_Outputs[idx])
    {
    itkDebugMacro( " creating new output object." );
    DataObjectPointer newOutput = this->MakeOutput(idx);
    this->SetNthOutput(idx, newOutput);

    // If we had an output object before, copy the requested region
    // ivars and release data flag to the the new output
    if (oldOutput)
      {
      newOutput->SetRequestedRegion( oldOutput );
      newOutput->SetReleaseDataFlag( oldOutput->GetReleaseDataFlag() );
      }
    }

  this->Modified();
}

void 
ProcessObject
::AddOutput(DataObject *output)
{
  unsigned int idx;
  
  for (idx = 0; idx < m_Outputs.size(); ++idx)
    {
    if ( m_Outputs[idx].IsNull() )
      {
      m_Outputs[idx] = output;

      if (output)
        {
        output->ConnectSource(this, idx);
        }
      this->Modified();
  
      return;
      }
    }
  
  this->SetNumberOfOutputs( static_cast<int>( m_Outputs.size() ) + 1);
  m_Outputs[ static_cast<int>( m_Outputs.size() ) - 1] = output;
  if (output)
    {
    output->ConnectSource(this, static_cast<int>( m_Outputs.size() ) - 1 );
    }
  this->Modified();
}

void 
ProcessObject
::SetNumberOfOutputs(unsigned int num)
{

  // in case nothing has changed.
  if (num == m_Outputs.size())
    {
    return;
    }
  m_Outputs.resize(num);
  this->Modified();
}


DataObject *
ProcessObject
::GetOutput(unsigned int i)
{
  if (m_Outputs.size() < i+1)
    {
    return NULL;
    }
  
  return m_Outputs[i].GetPointer();
}

const DataObject *
ProcessObject
::GetOutput(unsigned int i) const
{
  if (m_Outputs.size() < i+1)
    {
    return NULL;
    }
  
  return m_Outputs[i].GetPointer();
}


DataObject *
ProcessObject
::GetInput(unsigned int i)
{
  if (m_Inputs.size() < i+1)
    {
    return NULL;
    }
  
  return m_Inputs[i].GetPointer();
}

const DataObject *
ProcessObject
::GetInput(unsigned int i) const
{
  if (m_Inputs.size() < i+1)
    {
    return NULL;
    }
  
  return m_Inputs[i].GetPointer();
}


void 
ProcessObject
::UpdateProgress(float amount)
{
  m_Progress = amount;
  this->InvokeEvent( ProgressEvent() );
}


bool 
ProcessObject
::GetReleaseDataFlag() const
{
  if (this->GetOutput(0))
    {
    return this->GetOutput(0)->GetReleaseDataFlag();
    }
  itkWarningMacro(<<"Output doesn't exist!");
  return false;
}


void 
ProcessObject
::SetReleaseDataFlag(bool val)
{
  unsigned int idx;
  
  for (idx = 0; idx < m_Outputs.size(); idx++)
    {
    if (m_Outputs[idx])
      {
      m_Outputs[idx]->SetReleaseDataFlag(val);
      }
    }
}


void 
ProcessObject
::PrintSelf(std::ostream& os, Indent indent) const
{
  Superclass::PrintSelf(os,indent);

  os << indent << "Number Of Required Inputs: "
     << m_NumberOfRequiredInputs << std::endl;

  os << indent << "Number Of Required Outputs: "
     << m_NumberOfRequiredOutputs << std::endl;

  os << indent << "Number Of Threads: "
     << m_NumberOfThreads << std::endl;

  os << indent << "ReleaseDataFlag: " 
     << (this->GetReleaseDataFlag() ? "On" : "Off") << std::endl;

  os << indent << "ReleaseDataBeforeUpdateFlag: "
     << (m_ReleaseDataBeforeUpdateFlag ? "On" : "Off") << std::endl;
  
  if ( m_Inputs.size())
    {
    DataObjectPointerArraySizeType idx;
    for (idx = 0; idx < m_Inputs.size(); ++idx)
      {
      os << indent << "Input " << static_cast<int>( idx );
      os << ": (" << m_Inputs[idx].GetPointer() << ")\n";
      }
    }
  else
    {
    os << indent <<"No Inputs\n";
    }
  if ( m_Outputs.size())
    {
    DataObjectPointerArraySizeType idx;
    for (idx = 0; idx < m_Outputs.size(); ++idx)
      {
      os << indent << "Output " << static_cast<int>( idx );
      os << ": (" << m_Outputs[idx].GetPointer() << ")\n";
      }
    }
  else
    {
    os << indent <<"No Output\n";
    }

  os << indent << "AbortGenerateData: " << (m_AbortGenerateData ? "On\n" : "Off\n");
  os << indent << "Progress: " << m_Progress << "\n";

  os << indent << "Multithreader: " << std::endl;
  m_Threader->PrintSelf(os, indent.GetNextIndent());
}

void 
ProcessObject
::Update()
{
  if (this->GetOutput(0))
    {
    this->GetOutput(0)->Update();
    }
}

void
ProcessObject
::ResetPipeline()
{
  if (this->GetOutput(0))
    {
    this->GetOutput(0)->ResetPipeline();
    }
}

void
ProcessObject
::PropagateResetPipeline()
{
  // 
  // Reset this object.
  //
  // Clear the updating flag.
  m_Updating = 0;

  //
  // Loop through the inputs
  //
  unsigned int idx;
  DataObject::Pointer input;
  for (idx = 0; idx < m_Inputs.size(); ++idx)
    {
    if (m_Inputs[idx])
      {
      input = m_Inputs[idx];

      input->PropagateResetPipeline();
      }
    }
}


void 
ProcessObject
::UpdateOutputInformation()
{
  unsigned long t1, t2;
  DataObjectPointerArraySizeType idx;
  DataObject *input;
  DataObject *output;

  if ( m_Updating )
    {
    this->Modified();
    return;
    }

  t1 = this->GetMTime();

  for (idx = 0; idx < m_Inputs.size(); ++idx)
    {
    if (m_Inputs[idx])
      {
      input = m_Inputs[idx];

      m_Updating = true;
      input->UpdateOutputInformation();
      m_Updating = false;
      
      t2 = input->GetPipelineMTime();

      if (t2 > t1)
        {
        t1 = t2;
        }

      t2 = input->GetMTime();
      if (t2 > t1)
        {
        t1 = t2;
        }
      }
    }

  if (t1 > m_OutputInformationMTime.GetMTime())
    {
    for (idx = 0; idx < m_Outputs.size(); ++idx)
      {
      output = this->GetOutput( static_cast<int>( idx ) );
      if (output)
        {
        output->SetPipelineMTime(t1);
        }  
      }
    
    this->GenerateOutputInformation();

    m_OutputInformationMTime.Modified();
    }
}


void 
ProcessObject
::PropagateRequestedRegion(DataObject *output)
{
  if (m_Updating)
    {
    return;
    }

  this->EnlargeOutputRequestedRegion( output );

  this->GenerateOutputRequestedRegion( output );
  
  this->GenerateInputRequestedRegion();

  m_Updating = true;
  DataObjectPointerArraySizeType idx;
  for (idx = 0; idx < m_Inputs.size(); ++idx)
    {
    if (m_Inputs[idx])
      {
      m_Inputs[idx]->PropagateRequestedRegion();
      }
    }
  m_Updating = false;
}


void 
ProcessObject
::GenerateInputRequestedRegion()
{
  DataObjectPointerArraySizeType idx;
  for (idx = 0; idx < m_Inputs.size(); ++idx)
    {
    if (m_Inputs[idx])
      {
      m_Inputs[idx]->SetRequestedRegionToLargestPossibleRegion();
      }
    }  
}


void 
ProcessObject
::GenerateOutputRequestedRegion(DataObject *output)
{
  DataObjectPointerArraySizeType idx;
  for (idx = 0; idx < m_Outputs.size(); ++idx)
    {
    if (m_Outputs[idx] && m_Outputs[idx] != output)
      {
      m_Outputs[idx]->SetRequestedRegion(output);
      }
    }  
}


void 
ProcessObject
::PrepareOutputs()
{  
  unsigned int idx;
  
  if (this->GetReleaseDataBeforeUpdateFlag())
    {
    for (idx = 0; idx < m_Outputs.size(); idx++)
      {
      if (m_Outputs[idx])
        {
        m_Outputs[idx]->PrepareForNewData(); 
        }
      }
    }
}


void 
ProcessObject
::ReleaseInputs()
{  
  unsigned int idx;

  for (idx = 0; idx < m_Inputs.size(); ++idx)
    {
    if (m_Inputs[idx])
      {
      if ( m_Inputs[idx]->ShouldIReleaseData() )
        {
        m_Inputs[idx]->ReleaseData();
        }
      }  
    }
}


void 
ProcessObject
::UpdateOutputData(DataObject *itkNotUsed(output))
{
  DataObjectPointerArraySizeType idx;

  if (m_Updating)
    {
    return;
    }

  this->PrepareOutputs();

  m_Updating = true;
  if ( m_Inputs.size() == 1 )
    {
    if (m_Inputs[0])
      {
      m_Inputs[0]->UpdateOutputData();
      }
    }
  else
    {
    for (idx = 0; idx < m_Inputs.size(); ++idx)
      {
      if (m_Inputs[idx])
        {
        m_Inputs[idx]->PropagateRequestedRegion();
        m_Inputs[idx]->UpdateOutputData();
        }
      }
    }

  this->CacheInputReleaseDataFlags();
  
  this->InvokeEvent( StartEvent() );

  m_AbortGenerateData = false;
  m_Progress = 0.0f;

  DataObjectPointerArraySizeType ninputs = this->GetNumberOfValidRequiredInputs();
  if (ninputs < m_NumberOfRequiredInputs)
    {
    itkExceptionMacro(<< "At least " << m_NumberOfRequiredInputs 
                      << " inputs are required but only " << ninputs 
                      << " are specified.");
    }
  else
    {
    try
      {
      this->GenerateData();
      }
    catch( ProcessAborted & excp )
      {
      this->InvokeEvent( AbortEvent() );
      this->ResetPipeline();
      this->RestoreInputReleaseDataFlags();
      throw excp;
      }
    catch( ExceptionObject& excp )
      {
      this->ResetPipeline();
      this->RestoreInputReleaseDataFlags();
      throw excp;
      }
    }

  if ( m_AbortGenerateData )
    {
    this->UpdateProgress(1.0f);
    }

  this->InvokeEvent( EndEvent() );

  for (idx = 0; idx < m_Outputs.size(); ++idx)
    {
    if (m_Outputs[idx])
      {
      m_Outputs[idx]->DataHasBeenGenerated();
      }
    }
  
  this->RestoreInputReleaseDataFlags();
  
  this->ReleaseInputs();
  
  // Mark that we are no longer updating the data in this filter
  m_Updating = false;
}


void
ProcessObject
::CacheInputReleaseDataFlags()
{
  unsigned int idx;
  
  m_CachedInputReleaseDataFlags.resize( m_Inputs.size() );
  for (idx = 0; idx < m_Inputs.size(); ++idx)
    {
    if (m_Inputs[idx])
      {
      m_CachedInputReleaseDataFlags[idx]=m_Inputs[idx]->GetReleaseDataFlag();
      m_Inputs[idx]->ReleaseDataFlagOff();
      }
    else
      {
      m_CachedInputReleaseDataFlags[idx] = false;
      }
    }
} 


void
ProcessObject
::RestoreInputReleaseDataFlags()
{
  unsigned int idx;
  
  for (idx = 0;
       idx < m_Inputs.size() && idx < m_CachedInputReleaseDataFlags.size();
       ++idx)
    {
    if (m_Inputs[idx])
      {
      m_Inputs[idx]->SetReleaseDataFlag(m_CachedInputReleaseDataFlags[idx]);
      }
    }
} 

void 
ProcessObject
::GenerateOutputInformation()
{
  DataObjectPointer input, output;

  if (m_Inputs.size() && m_Inputs[0])
    {
    input = m_Inputs[0];

    for (unsigned int idx = 0; idx < m_Outputs.size(); ++idx)
      {
      output = this->GetOutput(idx);
      if (output)
        {
        output->CopyInformation(input);
        }  
      }
    }
}


void 
ProcessObject
::UpdateLargestPossibleRegion()
{
  this->UpdateOutputInformation();

  if (this->GetOutput(0))
    {
    this->GetOutput(0)->SetRequestedRegionToLargestPossibleRegion();
    this->GetOutput(0)->Update();
    }
}

} // end namespace itk