#include <cpExtensions/Visualization/MPRActors.h>

#include <vtkImageData.h>
#include <vtkRenderer.h>
#include <vtkRendererCollection.h>
#include <vtkRenderWindow.h>

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

// -------------------------------------------------------------------------
cpExtensions::Visualization::
ImageSliceActors* cpExtensions::Visualization::MPRActors::
GetSliceActors( const int& i ) const
{
  if( i < 3 )
    return( this->Slices[ 0 ][ i ] );
  else
    return( NULL );
}

// -------------------------------------------------------------------------
int cpExtensions::Visualization::MPRActors::
AddInputConnection(
  vtkAlgorithmOutput* aout, ImageSliceActors::LUTType lut
  )
{
  int N = this->Slices[ 0 ][ 0 ]->GetNumberOfImageActors( );
  if( N == 0 )
  {
    this->Slices[ 0 ][ 0 ]->AddInputConnection( aout, 0, lut );
    vtkImageMapToColors* imap = this->Slices[ 0 ][ 0 ]->GetImageMap( 0 );
    for( unsigned int i = 0; i < 2; ++i )
      for( unsigned int j = 0; j < 3; ++j )
        if( i != 0 || j != 0 )
          this->Slices[ i ][ j ]->AddInputConnection(
            ( ( imap != NULL )? imap->GetOutputPort( ): aout ), j,
            ImageSliceActors::LUTType_None
            );
  }
  else
  {
    /*
    // Check if the image share the same space
    vtkImageData* ref_image = this->_Image( 0 );
    vtkImageData* new_image =
      vtkImageData::SafeDownCast(
        aout->GetProducer( )->GetOutputInformation( 0 )->
        Get( vtkDataObject::DATA_OBJECT( ) )
        );
    int ref_ext[ 6 ], new_ext[ 6 ];
    ref_image->GetExtent( ref_ext );
    new_image->GetExtent( new_ext );
    if(
      ref_ext[ 0 ] == new_ext[ 0 ] && ref_ext[ 1 ] == new_ext[ 1 ] &&
      ref_ext[ 2 ] == new_ext[ 2 ] && ref_ext[ 3 ] == new_ext[ 3 ] &&
      ref_ext[ 4 ] == new_ext[ 4 ] && ref_ext[ 5 ] == new_ext[ 5 ]
      )
    {
      this->ImageMaps.push_back(
        vtkSmartPointer< vtkImageMapToColors >::New( )
        );
      this->ImageMaps[ N ]->SetInputConnection( aout );
      this->SetLookupTableToColor(
        N, double( 1 ), double( 0 ), double( 0 )
        );
      this->_Update( N );
      return( N );
    }
    else
    N = -1;
  */

  } // fi
  return( N );
}

// -------------------------------------------------------------------------
int cpExtensions::Visualization::MPRActors::
AddInputData( vtkImageData* image, ImageSliceActors::LUTType lut )
{
  int N = this->Slices[ 0 ][ 0 ]->GetNumberOfImageActors( );
  if( N == 0 )
  {
    this->Slices[ 0 ][ 0 ]->AddInputData( image, 0, lut );
    vtkImageMapToColors* imap = this->Slices[ 0 ][ 0 ]->GetImageMap( 0 );
    for( unsigned int i = 0; i < 2; ++i )
      for( unsigned int j = 0; j < 3; ++j )
        if( i != 0 || j != 0 )
        {
          if( imap != NULL )
            this->Slices[ i ][ j ]->AddInputConnection(
              imap->GetOutputPort( ), j,
              ImageSliceActors::LUTType_None
              );
          else
            this->Slices[ i ][ j ]->AddInputData(
              image, j,
              ImageSliceActors::LUTType_None
              );
        } // fi
  }
  else
  {
  } // fi
  return( N );
  /*
  int N = this->ImageMaps.size( );
  if( N == 0 )
  {
    this->ImageMaps.push_back(
      vtkSmartPointer< vtkImageMapToColors >::New( )
      );
    this->ImageMaps[ 0 ]->SetInputData( image );
    this->SetLookupTableToWindowLevel( 0 );
    this->_Update( 0 );
    this->ResetWindowLevel( 0 );
    return( 0 );
  }
  else
  {
    // Check if the image share the same space
    vtkImageData* ref_image = this->_Image( 0 );
    vtkImageData* new_image = image;
    int ref_ext[ 6 ], new_ext[ 6 ];
    ref_image->GetExtent( ref_ext );
    new_image->GetExtent( new_ext );
    if(
      ref_ext[ 0 ] == new_ext[ 0 ] && ref_ext[ 1 ] == new_ext[ 1 ] &&
      ref_ext[ 2 ] == new_ext[ 2 ] && ref_ext[ 3 ] == new_ext[ 3 ] &&
      ref_ext[ 4 ] == new_ext[ 4 ] && ref_ext[ 5 ] == new_ext[ 5 ]
      )
    {
      this->ImageMaps.push_back(
        vtkSmartPointer< vtkImageMapToColors >::New( )
        );
      this->ImageMaps[ N ]->SetInputData( image );
      this->SetLookupTableToColor(
        N, double( 1 ), double( 0 ), double( 0 )
        );
      this->_Update( N );
      return( N );
    }
    else
      return( -1 );

  } // fi
  */
}

// -------------------------------------------------------------------------
void cpExtensions::Visualization::MPRActors::
PushActorsInto(
  vtkRenderWindow* x, vtkRenderWindow* y, vtkRenderWindow* z,
  vtkRenderWindow* w
  )
{
  this->Slices[ 0 ][ 0 ]->PushActorsInto( x, true );
  this->Slices[ 0 ][ 1 ]->PushActorsInto( y, true );
  this->Slices[ 0 ][ 2 ]->PushActorsInto( z, true );

  vtkRenderer* wren =
    ( w != NULL )? w->GetRenderers( )->GetFirstRenderer( ): NULL;
  vtkRenderer* rends[ ] =
    {
      ( x != NULL )? x->GetRenderers( )->GetFirstRenderer( ): NULL,
      ( y != NULL )? y->GetRenderers( )->GetFirstRenderer( ): NULL,
      ( z != NULL )? z->GetRenderers( )->GetFirstRenderer( ): NULL
    };
  for( int i = 0; i < 3; ++i )
  {
    if( rends[ i ] != NULL )
      for( int j = 0; j < 3; ++j )
        if( i != j )
          rends[ i ]->AddActor( this->Slices[ 0 ][ j ]->GetPlaneActor( ) );
    if( wren != NULL )
    {
      for(
        unsigned int k = 0;
        k < this->Slices[ 1 ][ i ]->GetNumberOfImageActors( );
        ++k
        )
        wren->AddActor( this->Slices[ 1 ][ i ]->GetImageActor( k ) );
      wren->AddActor( this->Slices[ 1 ][ i ]->GetPlaneActor( ) );

    } // fi

  } // rof
  if( wren != NULL )
    wren->AddActor( this->ImageOutlineActor );

  for( unsigned int j = 0; j < 3; ++j )
  {
    ImageInteractorStyle* st =
      dynamic_cast< ImageInteractorStyle* >( this->Slices[ 0 ][ j ]->GetStyle( ) );
    if( w != NULL )
      st->AssociateInteractor( w->GetInteractor( ) );
    for( unsigned int l = 0; l < 3; ++l )
      if( j != l )
        st->AssociateInteractor(
          this->Slices[ 0 ][ l ]->GetStyle( )->GetInteractor( )
          );

  } // rof
}

// -------------------------------------------------------------------------
void cpExtensions::Visualization::MPRActors::
PopDataFrom(
  vtkRenderer* x,
  vtkRenderer* y,
  vtkRenderer* z,
  vtkRenderer* w
  )
{
  /*
  vtkRenderer* rends[] = { x, y, z };
  for( int i = 0; i < 3; ++i )
  {
    if( rends[ i ] != NULL )
    {
      for(
        unsigned int k = 0;
        k < this->Slices[ 0 ][ i ]->GetNumberOfImageActors( );
        ++k
        )
        rends[ i ]->RemoveActor( this->Slices[ 0 ][ i ]->GetImageActor( k ) );
      rends[ i ]->RemoveActor( this->Slices[ 0 ][ i ]->GetTextActor( ) );
      for( int j = 0; j < 3; ++j )
        rends[ i ]->RemoveActor( this->Slices[ 0 ][ j ]->GetPlaneActor( ) );

    } // fi
    if( w != NULL )
    {
      for(
        unsigned int k = 0;
        k < this->Slices[ 1 ][ i ]->GetNumberOfImageActors( );
        ++k
        )
        w->RemoveActor( this->Slices[ 1 ][ i ]->GetImageActor( k ) );
      w->RemoveActor( this->Slices[ 1 ][ i ]->GetPlaneActor( ) );

    } // fi

  } // rof
  if( w != NULL )
    w->RemoveActor( this->ImageOutlineActor );
  */
}

// -------------------------------------------------------------------------
  /*
void cpExtensions::Visualization::MPRActors::
LinkInteractors( )
{
  this->_Update( 0 );
  this->_Update( 1 );
  this->_Update( 2 );
}
  */

// -------------------------------------------------------------------------
void cpExtensions::Visualization::MPRActors::
SetLookupTable( unsigned int i, vtkScalarsToColors* lut )
{
  /*
  if( i < this->ImageMaps.size( ) )
  {
    this->ImageMaps[ i ]->SetLookupTable( lut );
    this->ImageMaps[ i ]->Update( );
    this->Modified( );

  } // fi
  */
}

// -------------------------------------------------------------------------
vtkScalarsToColors* cpExtensions::Visualization::MPRActors::
GetLookupTable( unsigned int i ) const
{
  /*
  if( i < this->ImageMaps.size( ) )
    return( this->ImageMaps[ i ]->GetLookupTable( ) );
  else
    return( NULL );
    */
}

// -------------------------------------------------------------------------
void cpExtensions::Visualization::MPRActors::
SetLookupTableToWindowLevel( unsigned int i )
{
  /*
  // Check if the input has been configured
  vtkImageData* image = this->_Image( i );
  if( image == NULL )
    return;

  double r[ 2 ];
  image->GetScalarRange( r );

  vtkSmartPointer< vtkWindowLevelLookupTable > lut =
    vtkSmartPointer< vtkWindowLevelLookupTable >::New( );
  lut->SetScaleToLinear( );
  lut->SetTableRange( r );
  lut->Build( );

  this->SetLookupTable( i, lut );
  */
}

// -------------------------------------------------------------------------
double cpExtensions::Visualization::MPRActors::
GetMinWindow( unsigned int i ) const
{
  return( 0 );
}

// -------------------------------------------------------------------------
double cpExtensions::Visualization::MPRActors::
GetMaxWindow( unsigned int i ) const
{
  /*
  // Check if the input has been configured
  vtkImageData* image = this->_Image( i );
  if( image == NULL )
    return( double( 0 ) );

  double r[ 2 ];
  image->GetScalarRange( r );
  return( r[ 1 ] - r[ 0 ] );
  */
}

// -------------------------------------------------------------------------
double cpExtensions::Visualization::MPRActors::
GetMinLevel( unsigned int i ) const
{
  /*
  // Check if the input has been configured
  vtkImageData* image = this->_Image( i );
  if( image == NULL )
    return( double( 0 ) );

  double r[ 2 ];
  image->GetScalarRange( r );
  return( r[ 0 ] );
  */
}

// -------------------------------------------------------------------------
double cpExtensions::Visualization::MPRActors::
GetMaxLevel( unsigned int i ) const
{
  /*
  // Check if the input has been configured
  vtkImageData* image = this->_Image( i );
  if( image == NULL )
    return( double( 0 ) );

  double r[ 2 ];
  image->GetScalarRange( r );
  return( r[ 1 ] );
  */
}

// -------------------------------------------------------------------------
double cpExtensions::Visualization::MPRActors::
GetWindow( unsigned int i ) const
{
  /*
  vtkWindowLevelLookupTable* lut =
    dynamic_cast< vtkWindowLevelLookupTable* >( this->GetLookupTable( i ) );
  if( lut != NULL )
    return( lut->GetWindow( ) );
  else
    return( double( 0 ) );
  */
}

// -------------------------------------------------------------------------
double cpExtensions::Visualization::MPRActors::
GetLevel( unsigned int i ) const
{
  /*
  vtkWindowLevelLookupTable* lut =
    dynamic_cast< vtkWindowLevelLookupTable* >( this->GetLookupTable( i ) );
  if( lut != NULL )
    return( lut->GetLevel( ) );
  else
    return( double( 0 ) );
  */
}

// -------------------------------------------------------------------------
void cpExtensions::Visualization::MPRActors::
SetWindow( unsigned int i, const double& w )
{
  /*
  vtkWindowLevelLookupTable* lut =
    dynamic_cast< vtkWindowLevelLookupTable* >( this->GetLookupTable( i ) );
  if( lut != NULL )
  {
    lut->SetWindow( w );
    lut->Build( );
    this->ImageMaps[ i ]->Modified( );
    this->Modified( );

  } // fi
  */
}

// -------------------------------------------------------------------------
void cpExtensions::Visualization::MPRActors::
SetLevel( unsigned int i, const double& l )
{
  /*
  vtkWindowLevelLookupTable* lut =
    dynamic_cast< vtkWindowLevelLookupTable* >( this->GetLookupTable( i ) );
  if( lut != NULL )
  {
    lut->SetLevel( l );
    lut->Build( );
    this->ImageMaps[ i ]->Modified( );
    this->Modified( );

  } // fi
  */
}

// -------------------------------------------------------------------------
void cpExtensions::Visualization::MPRActors::
SetWindowLevel( unsigned int i, const double& w, const double& l )
{
  /*
  vtkWindowLevelLookupTable* lut =
    dynamic_cast< vtkWindowLevelLookupTable* >( this->GetLookupTable( i ) );
  if( lut != NULL )
  {
    lut->SetWindow( w );
    lut->SetLevel( l );
    lut->Build( );
    this->ImageMaps[ i ]->Modified( );

    for( unsigned int j = 0; j < 3; ++j )
      this->Slices[ 0 ][ j ]->UpdateText( w, l );

    this->Modified( );

  } // fi
  */
}

// -------------------------------------------------------------------------
void cpExtensions::Visualization::MPRActors::
ResetWindowLevel( unsigned int i )
{
  /*
  vtkImageData* image = this->_Image( i );
  vtkWindowLevelLookupTable* lut =
    dynamic_cast< vtkWindowLevelLookupTable* >( this->GetLookupTable( i ) );
  if( image != NULL && lut != NULL )
  {
    double r[ 2 ];
    image->GetScalarRange( r );
    lut->SetTableRange( r );
    lut->SetWindow( r[ 1 ] - r[ 0 ] );
    lut->SetLevel( ( r[ 1 ] + r[ 0 ] ) / double( 2 ) );
    lut->Build( );
    this->ImageMaps[ i ]->Modified( );
    this->Modified( );

  } // fi
  */
}

// -------------------------------------------------------------------------
void cpExtensions::Visualization::MPRActors::
SetLookupTableToColor(
  unsigned int i, const double& r, const double& g, const double& b
  )
{
  /*
  static const double _0 = double( 0 );
  static const double _1 = double( 1 );
  static const double _2 = double( 2 );
  static const double _4 = double( 4 );
  static const double _6 = double( 6 );
  static const double _OPACITY = double( 0.6 );

  // Check if the input has been configured
  vtkImageData* image = this->_Image( i );
  if( image == NULL )
    return;

  double range[ 2 ];
  image->GetScalarRange( range );

  // Get HSV from display color
  double cmax = ( r > g )? r: g; cmax = ( b > cmax )? b: cmax;
  double cmin = ( r < g )? r: g; cmin = ( b < cmin )? b: cmin;
  double d = cmax - cmin;

  double saturation = ( std::fabs( cmax ) > _0 )? d / cmax: _0;
  double value = cmax;
  double hue = _0;
  if( d > _0 )
  {
    if( r == cmax )
      hue = std::fmod( ( g - b ) / d, _6 );
    else if( g == cmax )
      hue = ( ( b - r ) / d ) + _2;
    else if( b == cmax )
      hue = ( ( r - g ) / d ) + _4;
    hue *= _1 / _6;

  } // fi

  // Define new lookup table
  vtkSmartPointer< vtkLookupTable > lut =
    vtkSmartPointer< vtkLookupTable >::New( );
  lut->SetScaleToLinear( );
  lut->SetNanColor( _0, _0, _0, _0 );
  lut->SetTableRange( range[ 0 ], range[ 1 ] );
  lut->SetAlphaRange( _0, _OPACITY );
  lut->SetHueRange( _0, hue );
  lut->SetSaturationRange( _0, saturation );
  lut->SetValueRange( _0, value );
  lut->Build( );

  this->SetLookupTable( i, lut );
  */
}

// -------------------------------------------------------------------------
int cpExtensions::Visualization::MPRActors::
GetSliceNumberMinValue( const int& axis ) const
{
  return( this->Slices[ 0 ][ axis ]->GetSliceNumberMinValue( ) );
}

// -------------------------------------------------------------------------
int cpExtensions::Visualization::MPRActors::
GetSliceNumberMaxValue( const int& axis ) const
{
  return( this->Slices[ 0 ][ axis ]->GetSliceNumberMaxValue( ) );
}

// -------------------------------------------------------------------------
int cpExtensions::Visualization::MPRActors::
GetSlice( const int& axis ) const
{
  return( this->Slices[ 0 ][ axis ]->GetSliceNumber( ) );
}

// -------------------------------------------------------------------------
void cpExtensions::Visualization::MPRActors::
SetSlice( const int& axis, const int& slice )
{
  vtkImageData* image = this->_Image( 0 );
  if( image == NULL )
    return;

  // Get image data extent
  int ext[ 6 ];
  image->GetExtent( ext );

  // Check if the slice is valid
  int real = slice;
  if( slice < ext[ axis << 1 ] )
    real = ext[ axis << 1 ];
  if( ext[ ( axis << 1 ) + 1 ] < slice )
    real = ext[ ( axis << 1 ) + 1 ];

  // Change slice
  this->Slices[ 0 ][ axis ]->SetSliceNumber( real );
  this->Slices[ 1 ][ axis ]->SetSliceNumber( real );
  this->Modified( );
}

// -------------------------------------------------------------------------
void cpExtensions::Visualization::MPRActors::
SetSlice( const int& axis, const double& slice )
{
  vtkImageData* image = this->_Image( 0 );
  if( image == NULL )
    return;

  double x[ 3 ] = { double( 0 ) };
  double pcoords[ 3 ];
  int ijk[ 3 ];

  x[ axis ] = slice;
  image->ComputeStructuredCoordinates( x, ijk, pcoords );
  this->SetSlice( axis, ijk[ axis ] );
}

// -------------------------------------------------------------------------
void cpExtensions::Visualization::MPRActors::
ResetSlices( )
{
  for( unsigned int i = 0; i < 2; ++i )
    for( unsigned int j = 0; j < 3; ++j )
      this->Slices[ i ][ j ]->SetSliceNumber(
        this->Slices[ i ][ j ]->GetSliceNumberMinValue( )
        );
}

// -------------------------------------------------------------------------
cpExtensions::Visualization::MPRActors::
MPRActors( )
  : Superclass( )
{
  this->ImageOutlineActor = vtkSmartPointer< vtkActor >::New( );
  for( unsigned int i = 0; i < 2; ++i )
    for( unsigned int j = 0; j < 3; ++j )
      this->Slices[ i ][ j ] = vtkSmartPointer< ImageSliceActors >::New( );

  this->Slices[ 0 ][ 0 ]->AssociateSlice( this->Slices[ 1 ][ 0 ] );
  this->Slices[ 0 ][ 1 ]->AssociateSlice( this->Slices[ 1 ][ 1 ] );
  this->Slices[ 0 ][ 2 ]->AssociateSlice( this->Slices[ 1 ][ 2 ] );

  this->Slices[ 0 ][ 0 ]->SetSlicesCommand( Self::_SetSlices, this );
  this->Slices[ 0 ][ 1 ]->SetSlicesCommand( Self::_SetSlices, this );
  this->Slices[ 0 ][ 2 ]->SetSlicesCommand( Self::_SetSlices, this );
}

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

// -------------------------------------------------------------------------
vtkImageData* cpExtensions::Visualization::MPRActors::
_Image( unsigned int i ) const
{
  /*
  if( i < this->ImageMaps.size( ) )
  {
    vtkAlgorithm* algo = this->ImageMaps[ i ]->GetInputAlgorithm( );
    vtkInformation* info = algo->GetOutputInformation( 0 );
    return(
      vtkImageData::SafeDownCast(
        info->Get( vtkDataObject::DATA_OBJECT( ) )
        )
      );
  }
  else
  */
  return( NULL );
}

// -------------------------------------------------------------------------
void cpExtensions::Visualization::MPRActors::
_Update( unsigned int i )
{
  /*
  // Check if the input has been configured
  vtkImageData* image = this->_Image( i );
  if( image == NULL )
    return;
  this->ImageMaps[ i ]->Update( );

  for( int j = 0; j < 2; ++j )
  {
    for( int k = 0; k < 3; ++k )
    {
      this->Slices[ j ][ k ]->AddInputConnection(
        this->ImageMaps[ i ]->GetOutputPort( ), k
        );
      this->Slices[ j ][ k ]->UpdateText( );

      // Add all of slice's props
      this->Slices[ j ][ k ]->InitTraversal( );
      vtkProp* prop = this->Slices[ j ][ k ]->GetNextProp( );
      while( prop != NULL )
      {
        this->AddItem( prop );
        prop = this->Slices[ j ][ k ]->GetNextProp( );

      } // elihw

    } // rof

  } // rof

  if( i == 0 )
  {
    // Create 3D outline
    double bb[ 6 ];
    image->GetBounds( bb );

    vtkSmartPointer< vtkOutlineSource > img_ol =
      vtkSmartPointer< vtkOutlineSource >::New( );
    img_ol->SetBounds( bb );

    vtkSmartPointer< vtkPolyDataMapper > img_ol_mapper =
      vtkSmartPointer< vtkPolyDataMapper >::New( );
    img_ol_mapper->SetInputConnection( img_ol->GetOutputPort( ) );
    this->ImageOutlineActor->SetMapper( img_ol_mapper );
    this->ImageOutlineActor->GetProperty( )->SetColor( 1, 1, 1 );
    this->ImageOutlineActor->GetProperty( )->SetLineWidth( 1 );

    this->AddItem( this->ImageOutlineActor );

  } // fi
  */
}

// -------------------------------------------------------------------------
void cpExtensions::Visualization::MPRActors::
_SetSlices( double* pos, int axis, void* data )
{
  MPRActors* actors = reinterpret_cast< MPRActors* >( data );
  if( actors == NULL )
    return;
  for( unsigned int j = 0; j < 3; ++j )
    if( actors->Slices[ 0 ][ j ]->GetAxis( ) != axis )
      actors->Slices[ 0 ][ j ]->SetSlice( pos );
  actors->Modified( );
}

// eof - $RCSfile$