#ifndef __cpPlugins__DataObjects__BoundingBox__hxx__
#define __cpPlugins__DataObjects__BoundingBox__hxx__

#include <cpPlugins/DataObjects/Image.h>
#include <cpPlugins/DataObjects/Mesh.h>
#include <itkBoundingBox.h>
#include <itkPointSet.h>

// -------------------------------------------------------------------------
template< class _TPoint >
void cpPlugins::DataObjects::BoundingBox::
SetMinimum( const _TPoint& p )
{
  this->_SetPoint( 0, p );
}

// -------------------------------------------------------------------------
template< class _TPoint >
void cpPlugins::DataObjects::BoundingBox::
SetMaximum( const _TPoint& p )
{
  this->_SetPoint( 1, p );
}

// -------------------------------------------------------------------------
template< class _TPoint >
_TPoint cpPlugins::DataObjects::BoundingBox::
GetMinimum( ) const
{
  return( this->_GetPoint< _TPoint >( 0 ) );
}

// -------------------------------------------------------------------------
template< class _TPoint >
_TPoint cpPlugins::DataObjects::BoundingBox::
GetMaximum( ) const
{
  return( this->_GetPoint< _TPoint >( 1 ) );
}

// -------------------------------------------------------------------------
template< class _TPoint >
void cpPlugins::DataObjects::BoundingBox::
_SetPoint( unsigned int m, const _TPoint& p )
{
  this->m_Points[ m ].clear( );
  for( unsigned int d = 0; d < _TPoint::PointDimension; ++d )
    this->m_Points[ m ].push_back( double( p[ d ] ) );
  this->_UpdateVTK( );
  this->Modified( );
}

// -------------------------------------------------------------------------
template< class _TPoint >
_TPoint cpPlugins::DataObjects::BoundingBox::
_GetPoint( unsigned int m ) const
{
  unsigned int dim = this->m_Points[ m ].size( );
  dim = ( _TPoint::PointDimension < dim )? _TPoint::PointDimension: dim;
  _TPoint p;
  p.Fill( 0 );
  for( unsigned int d = 0; d < dim; ++d )
    p[ d ] = this->m_Points[ m ][ d ];
  return( p );
}

// -------------------------------------------------------------------------
template< unsigned int _NDim >
bool cpPlugins::DataObjects::BoundingBox::
_ITKImage( itk::LightObject* o )
{
  auto image = dynamic_cast< itk::ImageBase< _NDim >* >( o );
  if( image == NULL )
    return( false );

  auto region = image->GetLargestPossibleRegion( );
  auto i0 = region.GetIndex( );
  auto i1 = i0 + region.GetSize( );

  typename itk::ImageBase< _NDim >::PointType p0, p1;
  image->TransformIndexToPhysicalPoint( i0, p0 );
  image->TransformIndexToPhysicalPoint( i1, p1 );
  this->m_Points[ 0 ].clear( );
  this->m_Points[ 1 ].clear( );

  for( unsigned int d = 0; d < _NDim; ++d )
  {
    this->m_Points[ 0 ].push_back( double( p0[ d ] ) );
    this->m_Points[ 1 ].push_back( double( p1[ d ] ) );

  } // rof
  this->Modified( );
  return( true );
}

// -------------------------------------------------------------------------
template< class _TScalar, unsigned int _NDim >
bool cpPlugins::DataObjects::BoundingBox::
_ITKPointSet( itk::LightObject* o )
{
  typedef itk::PointSet< _TScalar, _NDim > _TPointSet;
  typedef itk::BoundingBox< typename _TPointSet::PointIdentifier, _NDim, _TScalar, typename _TPointSet::PointsContainer > _TBBox;

  auto ps = dynamic_cast< _TPointSet* >( o );
  if( ps == NULL )
    return( false );

  this->m_Points[ 0 ].clear( );
  this->m_Points[ 1 ].clear( );

  typename _TBBox::Pointer bb = _TBBox::New( );
  bb->SetPoints( ps->GetPoints( ) );
  if( bb->ComputeBoundingBox( ) )
  {
    auto p0 = bb->GetMinimum( );
    auto p1 = bb->GetMaximum( );
    for( unsigned int d = 0; d < _NDim; ++d )
    {
      this->m_Points[ 0 ].push_back( double( p0[ d ] ) );
      this->m_Points[ 1 ].push_back( double( p1[ d ] ) );

    } // rof
    this->Modified( );
    return( true );
  }
  else
    return( false );
}

#endif // __cpPlugins__DataObjects__BoundingBox__hxx__

// eof - $RCSfile$