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

  Program:   wxMaracas
  Module:    $RCSfile: marDynData.cpp,v $
  Language:  C++
  Date:      $Date: 2008/10/31 16:32:55 $
  Version:   $Revision: 1.1 $

  Copyright: (c) 2002, 2003
  License:
  
     This software is distributed WITHOUT ANY WARRANTY; without even 
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
     PURPOSE.  See the above copyright notice for more information.

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

#include <vtkImageResample.h>
#include <vtkExtractVOI.h>
#include <vtkImageData.h>
#include <vtkImageChangeInformation.h>
#include <vtkImageShiftScale.h> 
#include <vtkImageThreshold.h> 
#include "marDynData.h"

// -------------------------------------------------------------------------
marDynData::marDynData( marParameters* p ) : marObject( p ), _volume( NULL )
{
	_marimagedata = new marImageData(NULL); 
}

// -------------------------------------------------------------------------
marDynData::~marDynData() 
{
//	_marimagedata->SetImageData(NULL);
	delete _marimagedata;
	reset( );
}
// -------------------------------------------------------------------------

void marDynData::loadData( kVolume* vol, int* voi )
 {
   int ext[6];
   reset( );
 
   vtkExtractVOI *crop = vtkExtractVOI::New();
   crop->SetInput( vol->castVtk( ) );

   crop->SetVOI( voi );
   //crop->SetSampleRate( getParameters( )->getVoxelSize( ), getParameters( )->getVoxelSize( ), getParameters( )->getVoxelSize( ));
   
   float RescalaSlope		=  getParameters()->getRescaleSlope();
   float RescalaIntercept	=  getParameters()->getRescaleIntercept();

//EED
//	RescalaSlope		= 1;
//	RescalaIntercept	= 0;

   vtkImageShiftScale *scale = vtkImageShiftScale::New();
   scale->SetInput( crop->GetOutput( ) );
   scale->SetScale(RescalaSlope);
   scale->SetShift(0);
   scale->SetOutputScalarTypeToShort();
   scale->Update();
   vtkImageShiftScale *shift = vtkImageShiftScale::New();
   shift->SetInput( scale->GetOutput( ) );
   shift->SetScale(1); 
   shift->SetShift(RescalaIntercept);
   shift->SetOutputScalarTypeToShort();
   shift->Update();


   vtkImageThreshold *threshold = vtkImageThreshold::New();
   threshold->SetInput( shift->GetOutput( ) );
   threshold->ThresholdByUpper (-10000); 
   threshold->ThresholdByLower (-1); 
   threshold->SetInValue(0);   
   threshold->ReplaceOutOff ();
   threshold->ReplaceInOn ();
   threshold->SetOutputScalarTypeToUnsignedShort();
   
   vtkImageResample* ir = vtkImageResample::New( );
   ir->SetInput( threshold->GetOutput( ) );
   ir->SetDimensionality( 3 );
   double voxelSize= getParameters( )->getVoxelSize( );
   ir->SetAxisOutputSpacing( 0, voxelSize );
   ir->SetAxisOutputSpacing( 1, voxelSize );
   ir->SetAxisOutputSpacing( 2, voxelSize );


//	ir->SetAxisMagnificationFactor(0,1/getParameters( )->getVoxelSize( )); 

//EEDx1
   ir->InterpolateOn( );
//   ir->InterpolateOff( );


   ir->Update( );    //important
   ir->GetOutput()->GetExtent( ext );
 
  /**
   * Before we were using kgfoCrop which assume extent start at 0,0,0
   */
   vtkImageChangeInformation* change = vtkImageChangeInformation::New();
   change->SetInput( ir->GetOutput() );
   change->SetExtentTranslation( -ext[0], -ext[2], -ext[4] );
   change->SetOutputSpacing ( voxelSize , voxelSize , voxelSize );
   change->Update();    //important
 
   _volume = new kVolume( change->GetOutput( ) );

	_marimagedata->AddImageData( _volume->castVtk() );
	double spc[3];
	vol->castVtk()->GetSpacing(spc);
	_marimagedata->SetSpcOriginal( spc );
	_marimagedata->SetVoiOriginal(voi);


   crop		-> Delete();
   ir		-> Delete();
   change	-> Delete();
   shift	-> Delete();
   scale	-> Delete();
   threshold-> Delete();
 }


// -------------------------------------------------------------------------
void marDynData::reset( )
{
  //Efface car _volume est juste un pointeur ver _volume de marGdcmDicom qui
  //est detruit par le reset correspondant
// PS ->   #ifndef DXMM
// PS ->   if( _volume ) delete _volume;
// PS ->   #endif
  _volume = NULL;
}

// -------------------------------------------------------------------------
void marDynData::copyFrom( const marObject& from )
{
  reset( );
  _volume = new kVolume( *( ( ( marDynData& )from )._volume ) );
}

// -------------------------------------------------------------------------
bool marDynData::save( std::ofstream& os )
{
    void* data = _volume->getData1D( );
    uint dims[ 3 ];
    ulong dSize = _volume->getRawSizeInBytes( );
    double sizes[ 3 ];
    kVolume::Type type = _volume->getType( );

    dims[ 0 ] = _volume->getXdim( );
    dims[ 1 ] = _volume->getYdim( );
    dims[ 2 ] = _volume->getZdim( );
    sizes[ 0 ] = _volume->getXsize( );
    sizes[ 1 ] = _volume->getYsize( );
    sizes[ 2 ] = _volume->getZsize( );

    os.write( ( const char* )dims, 3 * sizeof( uint ) );
    os.write( ( const char* )sizes, 3 * sizeof( double ) );
    os.write( ( const char* )&type, sizeof( kVolume::Type ) );
    os.write( ( const char* )&dSize, sizeof( ulong ) );
    os.write( ( const char* )data, dSize );

    return( true );
}

// -------------------------------------------------------------------------
bool marDynData::load( std::ifstream& is )
{
    uchar* data;
    uint dims[ 3 ];
    ulong dSize;
    double sizes[ 3 ];
    kVolume::Type type;

    reset( );

    is.read( ( char* )dims, 3 * sizeof( uint ) );
    is.read( ( char* )sizes, 3 * sizeof( double ) );
    is.read( ( char* )&type, sizeof( kVolume::Type ) );
    is.read( ( char* )&dSize, sizeof( ulong ) );
    data = new uchar[ dSize ];
    is.read( ( char* )data, dSize );
	
    _volume = new kVolume( type, dims, sizes, ( void* )data );
	
    //cleaning
    delete[] data;

    return( true );
}

// ----------------------------------------------------------------------------------------------
marImageData *marDynData::GetMarImageData()
{
	return _marimagedata;
}
// ----------------------------------------------------------------------------------------------

// eof - dynData.cxx