#include <cpExtensions/Visualization/ImageSliceActors.h>

#include <vtkAlgorithmOutput.h>
#include <vtkCellArray.h>
#include <vtkImageData.h>
#include <vtkInformation.h>
#include <vtkPlane.h>
#include <vtkPoints.h>
#include <vtkProperty.h>
#include <vtkStreamingDemandDrivenPipeline.h>
#include <vtkTextProperty.h>

// -------------------------------------------------------------------------
cpExtensions::Visualization::ImageSliceActors*
cpExtensions::Visualization::ImageSliceActors::
New( )
{
  return( new Self( ) );
}

// -------------------------------------------------------------------------
void cpExtensions::Visualization::ImageSliceActors::
AddInputConnection( vtkAlgorithmOutput* aout, int axis )
{
  unsigned int nImages = this->SliceMappers.size( );

  vtkSmartPointer< vtkImageSliceMapper > mapper =
    vtkSmartPointer< vtkImageSliceMapper >::New( );
  this->SliceMappers.push_back( mapper );
  mapper->SetInputConnection( aout );
  mapper->SetOrientation(
    ( nImages == 0 )? axis: this->SliceMappers[ 0 ]->GetOrientation( )
    );
  mapper->Update( );
  
  vtkSmartPointer< vtkImageActor > actor =
    vtkSmartPointer< vtkImageActor >::New( );
  this->ImageActors.push_back( actor );
  actor->SetMapper( mapper );
  actor->Modified( );

  if( nImages == 0 )
  {
    this->AddItem( this->TextActor );
    this->AddItem( this->PlaneActor );

  } // fi
  this->AddItem( actor );
  this->Modified( );
}

// -------------------------------------------------------------------------
void cpExtensions::Visualization::ImageSliceActors::
AddInputData( vtkImageData* data, int axis )
{
  unsigned int nImages = this->SliceMappers.size( );

  vtkSmartPointer< vtkImageSliceMapper > mapper =
    vtkSmartPointer< vtkImageSliceMapper >::New( );
  this->SliceMappers.push_back( mapper );
  mapper->SetInputData( data );
  mapper->SetOrientation(
    ( nImages == 0 )? axis: this->SliceMappers[ 0 ]->GetOrientation( )
    );
  mapper->Update( );

  vtkSmartPointer< vtkImageActor > actor =
    vtkSmartPointer< vtkImageActor >::New( );
  this->ImageActors.push_back( actor );
  actor->SetMapper( mapper );
  actor->Modified( );

  if( nImages == 0 )
  {
    this->AddItem( this->TextActor );
    this->AddItem( this->PlaneActor );

  } // fi
  this->AddItem( actor );
  this->Modified( );
}

// -------------------------------------------------------------------------
void cpExtensions::Visualization::ImageSliceActors::
Clear( )
{
  // Unbind from container
  this->RemoveAllItems( );

  // Delete all images
  this->SliceMappers.clear( );
  this->ImageActors.clear( );

  // Reconfigure unique objects
  this->PlaneSource = vtkSmartPointer< vtkPolyData >::New( );
  this->PlaneMapper = vtkSmartPointer< vtkPolyDataMapper >::New( );
  this->TextActor   = vtkSmartPointer< vtkTextActor >::New( );
  this->PlaneActor  = vtkSmartPointer< vtkActor >::New( );
  this->TextBuffer[ 0 ] = '\0';

  // Unique objects configuration
  vtkSmartPointer< vtkPoints > plane_points =
    vtkSmartPointer< vtkPoints >::New( );
  vtkSmartPointer< vtkCellArray > plane_lines =
    vtkSmartPointer< vtkCellArray >::New( );

  plane_points->InsertNextPoint( 0, 0, 0 );
  plane_points->InsertNextPoint( 0, 1, 0 );
  plane_points->InsertNextPoint( 1, 1, 0 );
  plane_points->InsertNextPoint( 1, 0, 0 );
  plane_lines->InsertNextCell( 5 );
  plane_lines->InsertCellPoint( 0 );
  plane_lines->InsertCellPoint( 1 );
  plane_lines->InsertCellPoint( 2 );
  plane_lines->InsertCellPoint( 3 );
  plane_lines->InsertCellPoint( 0 );
  this->PlaneSource->SetPoints( plane_points );
  this->PlaneSource->SetLines( plane_lines );

  this->PlaneMapper->SetInputData( this->PlaneSource );
  this->PlaneActor->SetMapper( this->PlaneMapper );

  this->TextActor->SetTextScaleModeToNone( );
  vtkTextProperty* textprop = this->TextActor->GetTextProperty( );
  textprop->SetColor( 1, 1, 1 );
  textprop->SetFontFamilyToCourier( );
  textprop->SetFontSize( 18 );
  textprop->BoldOff( );
  textprop->ItalicOff( );
  textprop->ShadowOff( );
  textprop->SetJustificationToLeft( );
  textprop->SetVerticalJustificationToBottom( );
  vtkCoordinate* coord = this->TextActor->GetPositionCoordinate( );
  coord->SetCoordinateSystemToNormalizedViewport( );
  coord->SetValue( 0.01, 0.01 );
}

// -------------------------------------------------------------------------
unsigned int cpExtensions::Visualization::ImageSliceActors::
GetNumberOfImageActors( ) const
{
  return( this->ImageActors.size( ) );
}

// -------------------------------------------------------------------------
vtkImageActor* cpExtensions::Visualization::ImageSliceActors::
GetImageActor( unsigned int id )
{
  if( id < this->ImageActors.size( ) )
    return( this->ImageActors[ id ] );
  else
    return( NULL );
}

// -------------------------------------------------------------------------
const vtkImageActor* cpExtensions::Visualization::ImageSliceActors::
GetImageActor( unsigned int id ) const
{
  if( id < this->ImageActors.size( ) )
    return( this->ImageActors[ id ] );
  else
    return( NULL );
}

// -------------------------------------------------------------------------
vtkTextActor* cpExtensions::Visualization::ImageSliceActors::
GetTextActor( )
{
  return( this->TextActor );
}

// -------------------------------------------------------------------------
const vtkTextActor* cpExtensions::Visualization::ImageSliceActors::
GetTextActor( ) const
{
  return( this->TextActor );
}

// -------------------------------------------------------------------------
vtkActor* cpExtensions::Visualization::ImageSliceActors::
GetPlaneActor( )
{
  return( this->PlaneActor );
}

// -------------------------------------------------------------------------
const vtkActor* cpExtensions::Visualization::ImageSliceActors::
GetPlaneActor( ) const
{
  return( this->PlaneActor );
}

// -------------------------------------------------------------------------
double* cpExtensions::Visualization::ImageSliceActors::
GetDisplayBounds( ) const
{
  if( this->ImageActors.size( ) > 0 )
    return( this->ImageActors[ 0 ]->GetDisplayBounds( ) );
  else
    return( NULL );
}

// -------------------------------------------------------------------------
void cpExtensions::Visualization::ImageSliceActors::
GetDisplayBounds( double bounds[ 6 ] ) const
{
  if( this->ImageActors.size( ) > 0 )
    this->ImageActors[ 0 ]->GetDisplayBounds( bounds );
}

// -------------------------------------------------------------------------
int cpExtensions::Visualization::ImageSliceActors::
GetAxis( ) const
{
  if( this->SliceMappers.size( ) > 0 )
    return( this->SliceMappers[ 0 ]->GetOrientation( ) );
  else
    return( -1 );
}

// -------------------------------------------------------------------------
int cpExtensions::Visualization::ImageSliceActors::
GetSliceNumber( ) const
{
  if( this->SliceMappers.size( ) > 0 )
    return( this->SliceMappers[ 0 ]->GetSliceNumber( ) );
  else
    return( -1 );
}

// -------------------------------------------------------------------------
int cpExtensions::Visualization::ImageSliceActors::
GetSliceNumberMinValue( ) const
{
  if( this->SliceMappers.size( ) > 0 )
    return( this->SliceMappers[ 0 ]->GetSliceNumberMinValue( ) );
  else
    return( -1 );
}

// -------------------------------------------------------------------------
int cpExtensions::Visualization::ImageSliceActors::
GetSliceNumberMaxValue( ) const
{
  if( this->SliceMappers.size( ) > 0 )
    return( this->SliceMappers[ 0 ]->GetSliceNumberMaxValue( ) );
  else
    return( -1 );
}

// -------------------------------------------------------------------------
void cpExtensions::Visualization::ImageSliceActors::
SetSliceNumber( const int& slice )
{
  unsigned int nImages = this->SliceMappers.size( );
  if( nImages == 0 )
    return;

  // Change visualization extent
  for( unsigned int i = 0; i < nImages; ++i )
  {
    this->SliceMappers[ i ]->SetSliceNumber( slice );
    this->SliceMappers[ i ]->Modified( );
    this->ImageActors[ i ]->Modified( );
    this->SliceMappers[ i ]->Update( );

  } // rof

  // Compute plane
  vtkAlgorithm* algo = this->SliceMappers[ 0 ]->GetInputAlgorithm( );
  vtkInformation* info = algo->GetOutputInformation( 0 );
  int ext[ 6 ];
  double ori[ 3 ], spac[ 3 ], pos[ 3 ];
  info->Get( vtkStreamingDemandDrivenPipeline::WHOLE_EXTENT( ), ext );
  info->Get( vtkDataObject::ORIGIN( ), ori );
  info->Get( vtkDataObject::SPACING( ), spac );
  this->SliceMappers[ 0 ]->GetSlicePlane( )->GetOrigin( pos );

  // Prevent obscuring voxels by offsetting the plane geometry
  double xbnds[ ] =
    {
      ori[ 0 ] + ( spac[ 0 ] * double( ext[ 0 ] ) ),
      ori[ 0 ] + ( spac[ 0 ] * double( ext[ 1 ] ) )
    };
  double ybnds[ ] =
    {
      ori[ 1 ] + ( spac[ 1 ] * double( ext[ 2 ] ) ),
      ori[ 1 ] + ( spac[ 1 ] * double( ext[ 3 ] ) )
    };
  double zbnds[ ] =
    {
      ori[ 2 ] + ( spac[ 2 ] * double( ext[ 4 ] ) ),
      ori[ 2 ] + ( spac[ 2 ] * double( ext[ 5 ] ) )
    };

  if( spac[ 0 ] < double( 0 ) )
  {
    double t = xbnds[ 0 ];
    xbnds[ 0 ] = xbnds[ 1 ];
    xbnds[ 1 ] = t;

  } // fi
  if( spac[ 1 ] < double( 0 ) )
  {
    double t = ybnds[ 0 ];
    ybnds[ 0 ] = ybnds[ 1 ];
    ybnds[ 1 ] = t;

  } // fi
  if( spac[ 2 ] < double( 0 ) )
  {
    double t = zbnds[ 0 ];
    zbnds[ 0 ] = zbnds[ 1 ];
    zbnds[ 1 ] = t;

  } // fi

  int axis = this->SliceMappers[ 0 ]->GetOrientation( );
  this->PlaneActor->GetProperty( )->SetRepresentationToWireframe( );
  this->PlaneActor->GetProperty( )->SetLineWidth( 2 );
  vtkPoints* plane_points = this->PlaneSource->GetPoints( );
  if( axis == 0 ) // YZ, x-normal
  {
    plane_points->SetPoint( 0, pos[ 0 ], ybnds[ 0 ], zbnds[ 0 ] );
    plane_points->SetPoint( 1, pos[ 0 ], ybnds[ 1 ], zbnds[ 0 ] );
    plane_points->SetPoint( 2, pos[ 0 ], ybnds[ 1 ], zbnds[ 1 ] );
    plane_points->SetPoint( 3, pos[ 0 ], ybnds[ 0 ], zbnds[ 1 ] );
    this->PlaneActor->GetProperty( )->SetColor( 1, 0, 0 );
  }
  else if( axis == 1 ) // ZX, y-normal
  {
    plane_points->SetPoint( 0, xbnds[ 0 ], pos[ 1 ], zbnds[ 0 ] );
    plane_points->SetPoint( 1, xbnds[ 0 ], pos[ 1 ], zbnds[ 1 ] );
    plane_points->SetPoint( 2, xbnds[ 1 ], pos[ 1 ], zbnds[ 1 ] );
    plane_points->SetPoint( 3, xbnds[ 1 ], pos[ 1 ], zbnds[ 0 ] );
    this->PlaneActor->GetProperty( )->SetColor( 0, 1, 0 );
  }
  else // XY, z-normal
  {
    plane_points->SetPoint( 0, xbnds[ 0 ], ybnds[ 0 ], pos[ 2 ] );
    plane_points->SetPoint( 1, xbnds[ 1 ], ybnds[ 0 ], pos[ 2 ] );
    plane_points->SetPoint( 2, xbnds[ 1 ], ybnds[ 1 ], pos[ 2 ] );
    plane_points->SetPoint( 3, xbnds[ 0 ], ybnds[ 1 ], pos[ 2 ] );
    this->PlaneActor->GetProperty( )->SetColor( 0, 0, 1 );

  } // fi
  this->PlaneSource->Modified( );
  this->PlaneMapper->Modified( );
  this->PlaneActor->Modified( );
  this->Modified( );
}

// -------------------------------------------------------------------------
void cpExtensions::Visualization::ImageSliceActors::
UpdateText( )
{
  if( this->SliceMappers.size( ) > 0 )
  {
    char axis;
    int axId = this->SliceMappers[ 0 ]->GetOrientation( );
    if     ( axId == 0 ) axis = 'X';
    else if( axId == 1 ) axis = 'Y';
    else if( axId == 2 ) axis = 'Z';

    std::sprintf(
      this->TextBuffer, "Axis: %c (%d)",
      axis, this->SliceMappers[ 0 ]->GetSliceNumber( )
      );
  }
  else
    this->TextBuffer[ 0 ] = '\0';
  this->TextActor->SetInput( this->TextBuffer );
  this->TextActor->Modified( );
  this->Modified( );
}

// -------------------------------------------------------------------------
cpExtensions::Visualization::ImageSliceActors::
ImageSliceActors( )
  : Superclass( )
{
  this->Clear( );
}

// -------------------------------------------------------------------------
cpExtensions::Visualization::ImageSliceActors::
~ImageSliceActors( )
{
}

// eof - $RCSfile$