marInterfaceCT.cpp

Go to the documentation of this file.

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

 Program:   wxMaracas
 Module:    $RCSfile: marInterfaceCT.cpp,v $
 Language:  C++
 Date:      $Date: 2009/05/14 13:55:08 $
 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.
=========================================================================*/
#ifdef _MSC_VER
#pragma warning ( disable : 4786 )
#pragma warning ( disable : 4251 )
#endif //_MSC_VER

#include "marInterfaceCT.h"
#include <wx/file.h>
#include <wx/log.h>




// ----------------------------------------------------------------------------
marInterfaceCT::marInterfaceCT( )
: _parameters( NULL ), _dicom( NULL ),
_experiment( NULL )
{
        m_paramFileName=MAR_DEFAULT_FILE_PARAMETERS;
    _parameters = new marParameters( );

    _experiment = new marExperimentCT( _parameters );
        
    
}

// ----------------------------------------------------------------------------
marInterfaceCT::~marInterfaceCT( ){
    reset( );
}

// ----------------------------------------------------------------------------
bool marInterfaceCT::loadParameters( std::string pFile )
{
        std::ifstream is( pFile.c_str( ),std::ios::binary|std::ios::in);

//EEDxx2.4 DEBuG
//      wxLogDebug(wxString("Loading parameters from file ") 
//              + wxString(pFile.c_str()));
        
        if( is==NULL )
        {
                wxString errorMsg;
                errorMsg= wxString(_T("Error : Cannot open file "))
                                + wxString((wxChar*)pFile.c_str(), wxConvUTF8)
                                + wxString(_T(" to load parameters"));
//EEDxx2.4 DEBuG
//              wxLogDebug(errorMsg);
                return (false);
        }
        _parameters->reset( );
        if (_parameters->load( is ))
        {
                is.close( );
                return( true );
        }
        else
        {
                is.close();
//EEDxx2.4 DEBuG
//              wxLogDebug(wxString("Error : Cannot load parameters from file ")
//                              + wxString(pFile.c_str())
//                              + wxString(": file may be corrupted"));
                return (false);
        }
}

// ----------------------------------------------------------------------------
bool marInterfaceCT::saveParameters( std::string pFile )
{
        std::ofstream os(pFile.c_str( ),std::ios::binary | std::ios::out);
        
//EEDxx2.4 DEBuG
//      wxLogDebug(wxString("Saving parameters to file ") 
//                      + wxString(pFile.c_str()));
        
        
        if( os==NULL )
        {
                wxString errorMsg;
                errorMsg= wxString(_T("Error : Cannot open file "))
                                + wxString( (wxChar*)pFile.c_str(), wxConvUTF8)
                                + wxString(_T(" to save parameters"));
//EEDxx2.4 DEBuG
//              wxLogDebug(errorMsg);
                return( false );
        }
        if(_parameters->save( os ))
        {
                os.close( );
                return( true );
        }
        else
        {
                os.close();
//EEDxx2.4 DEBuG
//              wxLogDebug(wxString("Error : Cannot save parameters to file ")
//                              + wxString(pFile.c_str()));
                return (false);
        }

}

// ----------------------------------------------------------------------------
bool marInterfaceCT::initExperiment( )
{
    _experiment->reset( );
    _experiment->initExperiment( _dicom->getVolume( ) );
    return( true );
        
}
// ----------------------------------------------------------------------------
bool marInterfaceCT::saveExperiment( std::string nFile )
{
        std::ofstream os( nFile.c_str( ),std::ios::binary | std::ios::out );
        
//EEDxx2.4 DEBuG
//      wxLogDebug(wxString("Saving experiment to file ") 
//                      + wxString(nFile.c_str()));
        
        wxString errorMsg;
        errorMsg= wxString(_T("Cannot open file "))
                        + wxString((wxChar*)nFile.c_str(), wxConvUTF8)
                        + wxString(_T(" to save experiment"));

        
    if( os !=NULL ) {
                
        _parameters->save( os );
        _dicom->save( os );
        _experiment->save( os );
                os.close( );
                return( true );
                
    } // fi
//EEDxx2.4 DEBuG
//      wxLogDebug(errorMsg);
    return( false );
}

// ----------------------------------------------------------------------------
bool marInterfaceCT::loadExperiment( std::string nFile )
{
        std::ifstream is( nFile.c_str( ) ,std::ios::binary|std::ios::in );
        
//EEDxx2.4 DEBuG
//      wxLogDebug(wxString("Loading experiment from file ") 
//                      + wxString(nFile.c_str()));
        
        wxString errorMsg;
        errorMsg= wxString(_T("Cannot open file "))
                        + wxString((wxChar*)nFile.c_str(), wxConvUTF8)
                        + wxString(_T(" to load experiment"));
        
    if( is !=NULL) {
                
        _parameters->reset( );
        _dicom->reset( );
        _experiment->reset( );
                
        _parameters->load( is );
        _dicom->load( is );
        _experiment->load( is );
                is.close( );
                return( true );
                
    } // fi
//EEDxx2.4 DEBuG
//      wxLogDebug(errorMsg);
    return( false );
}

// ----------------------------------------------------------------------------
void marInterfaceCT::reset( ){
    if( _experiment != NULL ) delete _experiment;
    if( _dicom != NULL ) delete _dicom;
    if( _parameters != NULL ) delete _parameters;
    _experiment = NULL;
    _dicom = NULL;
    _parameters = NULL;
}
// ----------------------------------------------------------------------------
void marInterfaceCT::SetParamFileName(std::string pFileName) { 
        m_paramFileName=pFileName; 
}
// ----------------------------------------------------------------------------
std::string  marInterfaceCT::GetParamFileName() { 
        return m_paramFileName;  
}
// ----------------------------------------------------------------------------
void marInterfaceCT::SetDicom(marFilesBase *dicom) {
        _dicom=dicom;                            
}

// ----------------------------------------------------------------------------
void marInterfaceCT::appendAxis( marAxis* ax )
{
    _experiment->appendAxis(ax);
}


// ----------------------------------------------------------------------------
marAxisCT* marInterfaceCT::getAxis( int i ) {
        return (marAxisCT *) _experiment->getAxis(i);
}

// ----------------------------------------------------------------------------
void marInterfaceCT::setAxis( int i )
{
   _experiment->setAxis(i);
}

// ----------------------------------------------------------------------------
int marInterfaceCT::getQuantStart( ) {
        return _experiment->getQuantStart( );
}

// ----------------------------------------------------------------------------
int marInterfaceCT::getQuantFinish( ) {
        return _experiment->getQuantFinish( );
}
 
// ----------------------------------------------------------------------------
void marInterfaceCT::prepareQuantification( ) {
        _experiment->prepareQuantification( );
}


// ----------------------------------------------------------------------------
vtkImageData* marInterfaceCT::getSliceImage( int i ) {
        return _experiment->getSliceImage( i );
}

// ----------------------------------------------------------------------------
vtkProbeFilter* marInterfaceCT::get3DSlice( int i ) {
        return _experiment->get3DSlice( i );
}

// ----------------------------------------------------------------------------
double marInterfaceCT::getTotalLength( ) {
        return _experiment->getTotalLength( );
}

// ----------------------------------------------------------------------------
double marInterfaceCT::getSubAxisLength( ) {
        return _experiment->getSubAxisLength( );
}

// ----------------------------------------------------------------------------
double marInterfaceCT::getReferenceArea( ) {
                return _experiment->getReferenceArea( );
}

// ----------------------------------------------------------------------------
double  marInterfaceCT::getReferenceAverDiam() {
        return _experiment->getReferenceAverDiam( );
}

// ----------------------------------------------------------------------------
double marInterfaceCT::getAverageArea(int pIni, int pEnd) {
        return _experiment->getAverageArea(pIni,pEnd);
}

// ----------------------------------------------------------------------------
int marInterfaceCT::getNumberOfSlices( ) {
        return _experiment->getNumberOfSlices( );
}

// ---------------------------------------------------------------------------- 
int marInterfaceCT::getActualQuant( ) {
        return _experiment->getAxis()->getActualQuant();
}

// ----------------------------------------------------------------------------
marExperimentCT* marInterfaceCT::GetExperiment()
{
        return _experiment;
}

// ----------------------------------------------------------------------------
int marInterfaceCT::getHealthySlice( ) {
        return _experiment->getAxis( )->getHealthySlice( );
}

// ----------------------------------------------------------------------------
int marInterfaceCT::getHealthySliceStart( ) {
        return _experiment->getAxis()->getHealthySliceStart( );
}

// ----------------------------------------------------------------------------
int marInterfaceCT::getHealthySliceEnd( ) {
        return _experiment->getAxis()->getHealthySliceEnd( );
}

// ----------------------------------------------------------------------------
void marInterfaceCT::setHealthySlice( int hsS, int hs, int hsE ) {
        _experiment->getAxis()->setHealthySlice(hsS,hs,hsE);
        
}
// ----------------------------------------------------------------------------
void marInterfaceCT::setActualQuant(int act) {
        _experiment->getAxis()->setActualQuant( act ) ;
}

// ----------------------------------------------------------------------------
void marInterfaceCT::replaceContour2D(int i,int size,double *vx,double *vy) {
        _experiment->getAxis()->replaceContour2D(i,size,vx,vy);
}

void marInterfaceCT::replaceContour2D(int size,double *vx,double *vy, int type)
{
        _experiment->replaceContour2D(size,vx,vy,type);
}

// ----------------------------------------------------------------------------
void marInterfaceCT::EraseContour( int i ) {
        _experiment->getAxis()->EraseContour( i );
}

// ----------------------------------------------------------------------------
void marInterfaceCT::ClearContours() {
        _experiment->ClearContours();
}

// ----------------------------------------------------------------------------
void marInterfaceCT::RegenerateAxis() {
        _experiment->RegenerateAxis();
}

// ----------------------------------------------------------------------------
void marInterfaceCT::RegenerateSignal() {
        _experiment->RegenerateSignal();
}

// ----------------------------------------------------------------------------
void marInterfaceCT::RecalculateAxis() {
        _experiment->RegenerateAxis();
}

// ---------------------------------------------------------------------------- 
void marInterfaceCT::getMinMax( double& min, double& max ) {
        _experiment->getDynData( )->getVolume( )->getMinMax( min, max );
}

// ---------------------------------------------------------------------------- 
marContour* marInterfaceCT::getContour( int point, int contour ) {
        return _experiment->getContour(point,contour);
}

// ---------------------------------------------------------------------------- 
vtkPoints*      marInterfaceCT::get3Dcontour( int point, int contour ) {
        return _experiment->get3Dcontour(point,contour);
}

// ---------------------------------------------------------------------------- 
vtkPolyData* marInterfaceCT::get2Dcontour( int point, int contour ) {
        return _experiment->get2Dcontour(point,contour);
}

// ---------------------------------------------------------------------------- 
vtkPoints* marInterfaceCT::get2DDiameterMin( int point, int contour ) {
        return _experiment->get2DDiameterMin(point,contour);
}

// ---------------------------------------------------------------------------- 
vtkPoints* marInterfaceCT::get2DDiameterMax( int point, int contour ) {
        return _experiment->get2DDiameterMax(point,contour);
}

// ---------------------------------------------------------------------------- 
marParameters* marInterfaceCT::getParameters(){
        return _parameters;
}
// ---------------------------------------------------------------------------- 
marDynData* marInterfaceCT::getDynData(){
        return  _experiment->getDynData();
}

// ---------------------------------------------------------------------------- 
int marInterfaceCT::getNumberOfContours(int point) {
        return _experiment->getNumberOfContours(point);
}


// ----------------------------------------------------------------------------
void marInterfaceCT::updateLumenPercentage(int percentage) {
        _experiment->updateLumenPercentage(percentage);
}

// ----------------------------------------------------------------------------
void marInterfaceCT::updateCalcPercentage(int percentage) {
        _experiment->updateCalcPercentage(percentage);
}

// ----------------------------------------------------------------------------
void marInterfaceCT::updateDiscontinuityThreshold(int percentage) {
        _experiment->updateDiscontinuityThreshold(percentage);
        //TODO HACER RESET DEL CONTORNO
}

// ----------------------------------------------------------------------------
int marInterfaceCT::getContourType(int point, int index)
{
        return _experiment->getContourType(point,index);
}

// ----------------------------------------------------------------------------
void marInterfaceCT::histogram(int point)
{
        _experiment->histogram(point);
}

// ----------------------------------------------------------------------------
void marInterfaceCT::setCalibration(bool calib)
{
        _experiment->setCalibration(calib);
}

// ----------------------------------------------------------------------------
bool marInterfaceCT::getCalibration()
{
        return _experiment->getCalibration();
}

// ----------------------------------------------------------------------------
void marInterfaceCT::ClearContoursPartial(int start)
{
        _experiment->ClearContoursPartial(start);
}

// ----------------------------------------------------------------------------
void marInterfaceCT::setStartIndex(int start)
{
        _experiment->setStartIndex(start);
}

// ----------------------------------------------------------------------------
int     marInterfaceCT::getPointSize()
{
        return _experiment->getPointSize();
}

// ----------------------------------------------------------------------------
marPoint* marInterfaceCT::getPoint(int i)
{
        return _experiment->getPoint(i);
}

// ----------------------------------------------------------------------------
void marInterfaceCT::markUpLumen(int point)
{
        _experiment->markUpLumen(point);
}

// ----------------------------------------------------------------------------
void marInterfaceCT::generateFile()
{
        _experiment->generateFile();
}

// ----------------------------------------------------------------------------
void marInterfaceCT::cleanContours(int type)
{
        _experiment->cleanContours(type);
}

// ----------------------------------------------------------------------------
marIsocontour* marInterfaceCT::loadMarIsocontour(int size, double *vx, double *vy)
{
        return _experiment->loadMarIsocontour(size,vx,vy);
}

// ----------------------------------------------------------------------------
double marInterfaceCT::performXOR(int type, std::vector<marIsocontour*> manual)
{
        return _experiment->performXOR(type, manual);
}

// ----------------------------------------------------------------------------
double marInterfaceCT::performAND(int type, std::vector<marIsocontour*> manual)
{
        return _experiment->performAND(type, manual);
}


double marInterfaceCT::performUnion(int type, std::vector<marIsocontour*> manual)
{
        return _experiment->performUnion(type, manual);
}
// eof - marInterfaceCT.cxx